JAVA数据结构:栈和队列

实现一个基本的栈

public class StackX{
    int maxSize;
    long [] stackArr;
    int top;
    public StackX(int maxSize){
        this.maxSize = maxSize;
        top = -1;
        stackArr = new long[maxSize];
    }
    public void push(long value){
        stackArr[++top] = value;
    }
    public long peek(){
        return stackArr[top];
    }
    public long pull(){
        return stackArr[top--];
    }
    public boolean isEmpty(){
        return( top == -1);
    }

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

实现一个基本的队列

public class Queue{
    private int maxSize;
    private int nItems;
    private long [] queArray;
    private int rear;
    private int front;
    public Queue(int size){
        maxSize = size;
        nItems = 0;
        rear = 0;
        front =-1;
        queArray = new long[size];
    }
    //入队
    public void insert(long value){
        //环绕式处理
        if(rear  == maxSize -1){
            rear = -1;
        }
        queArray[++rear] = value;
        nItems++;
    }
    public long remove(){
        if(!isEmpty()){
            long temp = queArray[front];
            if(front == maxSize){
                front = 0 ;
            }
            nItems --;
            return temp;
        }else{
            System.out.print("queue is full");
            return -1;
        }
    }
    public boolean isEmpty(){
        return nItems==0;
    }
    public boolean isFull(){
        return nItems == maxSize;
    }
    public int size(){
        return nItems;
    }
    public long peekFront(){
        return queArray[front];
    }
    public void display(){
        //没有回绕存在
        if(rear>=front){
            for(int i=front; i<=rear;i++){
                System.out.print(queArray[i]+" ");
            }
        }else{
            for(int i = front;i<nItems;i++){
                System.out.print(queArray[i]+" ");
            }
            for(int j = 0;j<=rear;j++){
                System.out.print(queArray[i]+" ");
            }
        }   
    }

}

当在queue中插入一个数据时，队尾Rear箭头向上移动。当删除一个数据时，队头Front箭头向上移动。这样设计的问题是，队尾Rear很快就会到达数组的末端，

这种情况下，没办法插入新的元素，但是此时其实队列是没有满的。
环绕式处理
为了避免这种情况的发生，可以让队头队尾指针绕回数组开始的位置，这就是循环队列（有时也称“缓冲环“）

队列和栈一样，移除数据和插入数据的时间复杂度都是O(1).

优先级队列
优先级队列是比栈和队列更专用的数据结构，优先级队列有一个队头和队尾，并且也是从队头移除数据，不过在优先级队列中，数据按有序的关键字进行排序。

public class Priority{
        private int maxSize;
    public long[] queArray;
    private  int nItems;


    public PriorityQ(int s){
        maxSize = s;
        queArray = new long[maxSize];
        nItems =0;
    }
    public void insert(long items){
        int j;
        if(nItems ==0){   
            queArray[nItems++] = items;
        }else{
            //比items小的需要后移一个位置
            for(j= nItems-1;j>=0;j--){
                if(items>queArray[j]){
                    queArray[j+1] = queArray[j];
                }else{
                    break;
                }
            }
            queArray[j+1] =items;
            nItems++;
        }
    }




    public long remove(){
        long temp = queArray[--nItems];
        return temp;
    }
    //最小的队尾
    public long peekMin(){
        return queArray[nItems-1];
    }

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

    public void inserttwo (long items){
        if(!isFull()){
            queArray[nItems++] = items;
        }
    }

    public long removetwo(){
        long min = queArray[0];
        int flag = 0;
        //到nItem-1就比较完了
        for(int i=0;i<nItems-1;i++){
            if(queArray[i]>queArray[i+1]){
                flag = i+1;
                min = queArray[i+1];
            }
        }
        for(int i = flag;i<nItems-1;i++){
            queArray[i] =  queArray[i+1];
        }
        nItems --;
        return min;
    }
    //按插入顺序输出
    public void display1(){
        for(int i =0;i<queArray.length;i++){
            System.out.print(queArray[i]+" ");
        }
    }
    //按优先级，先排序，再输出
    public void display2(){
        long[] temp = new long[nItems];//临时表
        System.arraycopy(queArray, 0, temp, 0, nItems);
        int out , in;
        for(out = 1;out<nItems;out++){
            in = out;
            long t =temp[out];
            while(in>0 && t < temp[in-1]){
                temp[in] = temp[in-1];
                in --;
            }
            temp[in] =t;
        }
        System.out.println("队列为");
        for(int i=0;i<nItems;i++){
            System.out.print(temp[i]+" ");
        }
        System.out.println();
    }   
}

优先级队列可以不用定义rear和front,优先级队列的rear = nItems -1,
front =0