栈，队列，优先级队列

一.栈

1.栈：先进后出，后进先出，每次访问一个数据项，即最后一个添加的数据项(每次添加的数据放到最后)。数据入栈和出栈的时间复杂度O(1)，栈不需要移动和比较数据。

2.代码

public class Stack {
    private int maxsize;
    private int[] arr;
    private int top;
    
    public Stack(int s){
        maxsize = s;
        arr = new int[maxsize];
        top = -1;
    }
    
    public void push(int s){
        arr[++top] = s;
    }
    
    public int delete(){
        return arr[top--];
    }
    
    public boolean isEmpty(){
        return top == -1;
    }
    
    public boolean isFull(){
        return top == maxsize-1;
    }
    
    public static void main(String[] args) {
        Stack s = new Stack(10);
        s.push(5);
        s.push(10);
        s.push(2);
        s.push(4);
        while(!s.isEmpty()){
            int a = s.delete();
            System.out.println(a);
        }
    }

}

二.队列

1.队列：先进先出，每次操作一个数据项，先进去的。数据放到最后，从最前面开始拿，所以需要两个标记，队头和队尾。

　　　　为了解决队列不满，又不能添加数据的问题，采用环绕式处理。

2.代码：

public class Stack1 {
    private int maxsize;
    private int[] arr;
    private int first;
    private int last;
    private int num;

    public Stack1(int s) {
        maxsize = s;
        arr = new int[maxsize];
        first = -1;
        last = 0;
        num = 0;
    }

    public void insert(int a) {
        if (last == maxsize - 1 && num != maxsize) {
            last = 0;
        }
        arr[last++] = a;
        num++;
    }

    public int delete() {
        num--;
        return arr[++first];

    }

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

    public boolean isFull() {
        return maxsize == num;
    }

    public static void main(String[] args) {
        Stack1 s = new Stack1(5);
        s.insert(10);
        s.insert(5);
        s.insert(9);
        s.insert(80);
        while (!s.isEmpty()) {
            int b = s.delete();
            System.out.println(b);
        }

    }

三.优先级队列

1.优先级队列：跟普通队列一样，优先级队列也有队头和队尾，但是，优先级队列中，按关键字的值进行排序，数据项插入的时候也按照顺序插入确保队列的顺序。

2.代码

public class Stack2 {
    private int maxsize;
    private int arr[];
    private int nItems;

    public Stack2(int a) {
        maxsize = a;
        arr = new int[maxsize];
        nItems = 0;
    }

    public void insert(int b) {
        int j;
        if (nItems == 0)
            arr[nItems] = b;
        else {
            for (j = nItems - 1; j >= 0; j--) {
                if (arr[j] > b)
                    arr[j + 1] = arr[j];
                else
                    break;
            }
            arr[j+1] = b;            
        }
        nItems++;
    }
    
    public int remove(){
        return arr[--nItems];
    }
    
    public boolean isEmpty(){
        return nItems==0;
    }
    
    public boolean isFull(){
        return maxsize == nItems;
    }

    public static void main(String[] args) {
        Stack2 s = new Stack2(5);
        s.insert(10);
        s.insert(5);
        s.insert(80);
        s.insert(2);
        while(!s.isEmpty()){
            int a = s.remove();
            System.out.println(a);
        }
    }
}