如果讓你手寫個棧和佇列，你還會寫嗎？

來源：程式設計師私房菜（ID：eson_15）

昨天跟一個CSDN上的朋友聊天，他說現在如果讓他自己手寫一個棧或者佇列，估計都要寫蠻久的，平時雖然都在用，但是都是別人封裝好的集合。

確實，經典的資料結構，包括排序演算法，雖然我們平時不用手寫了，但是這些內功，作為開發人員來說是必須要掌握的。受此啟發，我打算更一下經典資料結構和演算法的系列文章。今天先從棧和佇列說起。

這些東西，擠地鐵時，吃飯排隊時，等公交時，可以拿來看看，或者，就把它當作個下午茶吧~

我們知道，在陣列中，若知道資料項的下標，便可立即訪問該資料項，或者通過順序搜尋資料項，訪問到陣列中的各個資料項。但是棧和佇列不同，它們的訪問是受限制的，即在特定時刻只有一個資料項可以被讀取或者被刪除。眾所周知，棧是先進後出，只能訪問棧頂的資料，佇列是先進先出，只能訪問頭部資料。這裡不再贅述。

棧的主要機制可以用陣列來實現，也可以用連結串列來實現，下面用陣列來實現棧的基本操作：

1. class ArrayStack {

2.    private long[] a;

3.    private int size; //棧陣列的大小

4.    private int top; //棧頂

6.    public ArrayStack(int maxSize) {

7.        this.size = maxSize;

8.        this.a = new long[size];

9.        this.top = -1; //表示空棧

10.    }

12.    public void push(long value) {//入棧

13.        if(isFull()) {

14.            System.out.println("棧已滿！");

15.            return;

16.        }

17.        a[++top] = value;

18.    }

20.    public long peek() {//返回棧頂內容，但不刪除

21.        if(isEmpty()) {

22.            System.out.println("棧中沒有資料");

23.            return 0;

24.        }

25.        return a[top];

26.    }

28.    public long pop() { //彈出棧頂內容，刪除

29.        if(isEmpty()) {

30.            System.out.println("棧中沒有資料！");

31.            return 0;

32.        }

33.        return a[top--];        

34.    }

36.    public int size() {

37.        return top + 1;

38.    }

40.    public boolean isEmpty() {

41.        return (top == -1);

42.    }

44.    public boolean isFull() {

45.        return (top == size -1);

46.    }

48.    public void display() {

49.        for(int i = top; i >= 0; i--) {

50.            System.out.print(a[i] + " ");

51.        }

52.        System.out.println("");

53.    }

54. }

資料項入棧和出棧的時間複雜度均為O(1)。這也就是說，棧操作所消耗的時間不依賴於棧中資料項的個數，因此操作時間很短。棧不需要比較和移動操作。

佇列也可以用陣列來實現，不過這裡有個問題，當陣列下標滿了後就不能再新增了，但是陣列前面由於已經刪除佇列頭的資料了，導致空。所以佇列我們可以用迴圈陣列來實現，見下面的程式碼：

1. public class RoundQueue {

2.    private long[] a;

3.    private int size;   //陣列大小

4.    private int nItems; //實際儲存數量

5.    private int front;  //頭

6.    private int rear;   //尾

8.    public RoundQueue(int maxSize) {

9.        this.size = maxSize;

10.        a = new long[size];

11.        front = 0;

12.        rear = -1;

13.        nItems = 0;

14.    }

16.    public void insert(long value) {

17.        if(isFull()){

18.            System.out.println("佇列已滿");

19.            return;

20.        }

21.        rear = ++rear % size;

22.        a[rear] = value; //尾指標滿了就迴圈到0處,這句相當於下面註釋內容      

23.        nItems++;

24. /*        if(rear == size-1){

25.            rear = -1;

26.        }

27.        a[++rear] = value;

28. */

29.    }

31.    public long remove() {

32.        if(isEmpty()) {

33.            System.out.println("佇列為空！");

34.            return 0;

35.        }

36.        nItems--;

37.        front = front % size;

38.        return a[front++];

39.    }

41.    public void display() {

42.        if(isEmpty()) {

43.            System.out.println("佇列為空！");

44.            return;

45.        }

46.        int item = front;

47.        for(int i = 0; i < nItems; i++) {

48.            System.out.print(a[item++ % size] + " ");

49.        }

50.        System.out.println("");

51.    }

53.    public long peek() {

54.        if(isEmpty()) {

55.            System.out.println("佇列為空！");

56.            return 0;

57.        }

58.        return a[front];

59.    }

61.    public boolean isFull() {

62.        return (nItems == size);

63.    }

65.    public boolean isEmpty() {

66.        return (nItems == 0);

67.    }

69.    public int size() {

70.        return nItems;

71.    }

72. }

和棧一樣，佇列中插入資料項和刪除資料項的時間複雜度均為O(1)。

還有個優先順序佇列，優先順序佇列是比棧和佇列更專用的資料結構。優先順序佇列與上面普通的佇列相比，主要區別在於佇列中的元素是有序的，關鍵字最小（或者最大）的資料項總在隊頭。資料項插入的時候會按照順序插入到合適的位置以確保佇列的順序。優先順序佇列的內部實現可以用陣列或者一種特別的樹——堆來實現。

1. public class PriorityQueue {

2.    private long[] a;

3.    private int size;

4.    private int nItems;//元素個數

6.    public PriorityQueue(int maxSize) {

7.        size = maxSize;

8.        nItems = 0;

9.        a = new long[size];

10.    }

12.    public void insert(long value) {

13.        if(isFull()){

14.            System.out.println("佇列已滿！");

15.            return;

16.        }

17.        int j;

18.        if(nItems == 0) { //空佇列直接新增

19.            a[nItems++] = value;

20.        }

21.        else{//將陣列中的數字依照下標按照從大到小排列

22.            for(j = nItems-1; j >= 0; j--) {

23.                if(value > a[j]){

24.                    a[j+1] = a[j];

25.                }

26.                else {

27.                    break;

28.                }

29.            }

30.            a[j+1] = value;

31.            nItems++;

32.        }

33.    }

35.    public long remove() {

36.        if(isEmpty()){

37.            System.out.println("佇列為空！");

38.            return 0;

39.        }

40.        return a[--nItems];

41.    }

43.    public long peekMin() {

44.        return a[nItems-1];

45.    }

47.    public boolean isFull() {

48.        return (nItems == size);

49.    }

51.    public boolean isEmpty() {

52.        return (nItems == 0);

53.    }

55.    public int size() {

56.        return nItems;

57.    }

59.    public void display() {

60.        for(int i = nItems-1; i >= 0; i--) {

61.            System.out.print(a[i] + " ");

62.        }

63.        System.out.println(" ");

64.    }

65. }

這裡實現的優先順序佇列中，插入操作需要 O(N) 的時間，而刪除操作則需要 O(1) 的時間。

（完）

Java團長

專注於Java乾貨分享

掃描上方二維碼獲取更多Java乾貨