數據結構之棧和隊列

  棧或者隊列是經典的數據結構,雖然平時都在用,可是都是別人封裝好的集合,咱們不用手寫了,可是這些內功,做爲開發人員來講是必需要掌握的。java

  咱們知道,在數組中,若知道數據項的下標,即可當即訪問該數據項,或者經過順序搜索數據項,訪問到數組中的各個數據項。可是棧和隊列不一樣,它們的訪問是受限制的,即在特定時刻只有一個數據項能夠被讀取或者被刪除。衆所周知,棧是先進後出,只能訪問棧頂的數據,隊列是先進先出,只能訪問頭部數據。這裏再也不贅述。數組

  棧的主要機制能夠用數組來實現,也能夠用鏈表來實現,下面用數組來實現棧的基本操做:數據結構

public class ArrayStack {
    private long[] a;
    //棧數組大小
    private int size;
    //棧頂
    private int top;

    //初始化棧
    public ArrayStack(int maxSize) {
        this.size = maxSize;
        a = new long[size];
        //表示空棧
        top = -1;
    }

    //入棧
    public void push(int value) {
        if (isFull()) {
            System.out.println("Stack is Full!");
            return;
        }
        a[++top] = value;
    }

    //出棧,返回棧頂元素並刪除
    public long pop() {
        if (isEmpty()) {
            System.out.println("Stack is Empty!");
            return 0;
        }
        return a[top--];
    }

    //獲取並返回棧頂元素
    public long peak() {
        if (isEmpty()) {
            System.out.println("Stack is Empty!");
            return 0;
        }
        return a[top];
    }

    public boolean isFull() {
        return top == size - 1;
    }

    public boolean isEmpty() {
        return top == -1;
    }

    //遍歷棧元素
    public void display() {
        if (isEmpty()) {
            System.out.println("Stack is Empty!");
            return;
        }
        for (int i = top; i >= 0; i--) {
            System.out.print(a[i] + " ");
        }
        System.out.println();
    }
}

數據項入棧和出棧的時間複雜度均爲O(1)。這也就是說,棧操做所消耗的時間不依賴於棧中數據項的個數,所以操做時間很短。棧不須要比較和移動操做。this

隊列

  隊列也能夠用數組來實現,不過這裏有個問題,當數組下標滿了後就不能再添加了,可是數組前面因爲已經刪除隊列頭的數據了,致使空。因此隊列咱們能夠用循環數組來實現,見下面的代碼:spa

public class RoundQueue {
    private long[] a;
    //數組大小
    private int size;
    //隊頭
    private int front;
    //隊尾
    private int rear;
    //實際存儲元素個數
    private int nItems;

    //初始化隊列
    public RoundQueue(int maxSize) {
        this.size = maxSize;
        a = new long[size];
        front = 0;
        rear = -1;
        nItems = 0;
    }

    //插入數據
    public void insert(int value) {
        if (isFull()) {
            System.out.println("Queue is Full!");
            return;
        }
        //尾指針滿了就循環到0處
        rear = ++rear % size;
        a[rear] = value;
        nItems++;
        /*if (rear == size - 1) {
            rear = -1;
        }
        a[++rear] = value;*/
    }

    //刪除數據
    public long remove() {
        if (isEmpty()) {
            System.out.println("Queue is Empty!");
            return 0;
        }
        nItems--;
        front = front % size;
        return a[front++];
    }

    //返回隊頭數據
    public long peak() {
        if (isEmpty()) {
            System.out.println("Queue is Empty!");
            return 0;
        }
        return a[front];
    }

    public boolean isFull() {
        return nItems == size;
    }

    public boolean isEmpty() {
        return nItems == 0;
    }

    public void display() {
        if (isEmpty()) {
            System.out.println("Queue is Empty!");
            return;
        }
        int item = front;
        for (int i = 0; i < nItems; i++) {
            System.out.print(a[item++ % size] + " ");
        }
        System.out.println();

    }
}

  和棧同樣,隊列中插入數據項和刪除數據項的時間複雜度均爲O(1)指針

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

public class PriorityQueue {
    private long[] a;
    //數組大小
    private int size;
    //實際存儲元素個數
    private int nItems;

    public PriorityQueue(int maxSize) {
        this.size = maxSize;
        a = new long[size];
        nItems = 0;
    }

    public void insert(int value) {
        if (isFull()) {
            System.out.println("Queue is Full!");
            return;
        }
        int j;
        //空隊列直接添加
        if (nItems == 0) {
            a[nItems++] = value;
        } else {
            //將數組元素從小到大排列
            for (j = nItems - 1; j >= 0; j--) {
                if (value > a[j]) {
                    a[j + 1] = a[j];
                } else {
                    break;
                }
            }
            a[j + 1] = value;
            nItems++;
        }

    }

    public long remove() {
        if (isEmpty()) {
            System.out.println("Queue is Empty!");
            return 0;
        }
        return a[--nItems];
    }

    public long peekMin() {
        return a[nItems - 1];
    }

    public boolean isFull() {
        return nItems == size;
    }

    public boolean isEmpty() {
        return nItems == 0;
    }

    public int size() {
        return nItems;
    }

    public void display() {
        for (int i = nItems - 1; i >= 0; i--) {
            System.out.print(a[i] + " ");
        }
        System.out.println();
    }
}

這裏實現的優先級隊列中,插入操做須要 O(N) 的時間,而刪除操做則須要 O(1) 的時間blog

 

 

原文參考【Java知音網隊列

相關文章
相關標籤/搜索