【数据结构-Java描述】栈与队列

一.栈（Stack）

栈是一种特殊的线性表，数据只能在栈顶一端进行插入与删除操作，数据元素遵从“先进后出”的原则。

压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据在栈顶
                                                            栈的常用方法

Stack()	构造一个空的栈
E push(E e)	将e入栈，并返回e
E pop()	将栈顶元素出栈并返回
E peek()	获取栈顶元素
int size()	获取栈中有效元素个数
boolean empty()	检测栈是否为空

在实际使用过程中，栈可以改变元素的序列，以及可以将递归转为循环等..... 

用数组模拟实现一个栈：

public class MyStack {
int[] array;
int size;
public MyStack(){
array = new int[10];
}
public int push(int e){
resize();
array[size++] = e;
return e;
}
public int pop(){
int e = peek();
size--;
return e;
}
public int peek(){
if(empty()){
throw new RuntimeException("栈为空");
} r
eturn array[size-1];
}
public int size(){
return size;
}
public boolean empty(){
return 0 == size;
}
private void resize(){
if(size == array.length){
array = Arrays.copyOf(array, size*2);
}
}

二.队列（Queue）

队列是一种只允许一端进行插入操作，另一端进行删除操作的特殊线性表，队列具有先进先出的特性，入队列：进行插入操作的一端称为队尾。出队列：进行删除操作的一端称为队头。

队列的使用

在Java中,Queue接口底层由链表实现，常用方法如下：

boolean offer(E e)	入队列
E poll()	出队列
peek()	获取队头元素
int size()	获取队列中有效元素个数
boolean isEmpty()	检测队列是否为空

链表模拟实现队列：

class SingleLinkedList {
        public int val;
        public SingleLinkedList next;
        public SingleLinkedList head;
        public int usersize;
        SingleLinkedList(int data) {
            this.val=data;
        }
        SingleLinkedList() {

        }
    public void addFirst(int data){
        SingleLinkedList Node=new SingleLinkedList(data);
        Node.next=head;
        head=Node;
        usersize++;
    }
    //尾插法
    public void addLast(int data){
        if(this.head==null){
            addFirst(data);
            return;
        }
        SingleLinkedList cur=head;
            while(cur.next!=null){
                cur=cur.next;
            }
        SingleLinkedList Node=new SingleLinkedList(data);
        cur.next=Node;
        usersize++;
    }
    public boolean addIndex(int index,int data){
            if(index>usersize || index<0) return false;
            if(index==usersize) {
                addLast(data);
                return true;
            }
            if(index==0) {
                addFirst(data);
                return true;
            }
           SingleLinkedList cur=head;
           SingleLinkedList prev = null;
           while(index>0){
               prev=cur;
               cur=cur.next;
               index--;
           }
           SingleLinkedList Node=new SingleLinkedList(data);
           prev.next=Node;
           Node.next=cur;
           usersize++;
           return true;
    }
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key){
        SingleLinkedList cur=head;
        while(cur!=null){
            if(cur.val==key) return true;
            cur=cur.next;
        }
        return false;
    }
    //删除第一次出现关键字为key的节点
    public void remove(int key){
        SingleLinkedList cur=head;
        SingleLinkedList prev=null;
        while(cur!=null){
            if(cur.val==key) {
                if(prev==null){
                    this.head=head.next;
                    usersize--;
                    return;
                }else{
                    prev.next=cur.next;
                    usersize--;
                    return;
                }
            }
            prev=cur;
            cur=cur.next;
        }
    }
    public void removeAllKey(int key){
        SingleLinkedList cur=head;
        SingleLinkedList prev=null;
        while(cur!=null){
            if(cur.val==key) {
                if(prev==null){
                    this.head=head.next;
                    prev=null;
                }else{
                    prev.next=cur.next;
                }
                usersize--;
                cur=cur.next;
                continue;
            }
            prev=cur;
            cur=cur.next;
        }
    }
    //得到单链表的长度
    public int size(){
            return usersize;
    }
    public void display(){
            SingleLinkedList cur=head;
            while(cur!=null){
                System.out.println(cur.val+" ");
                cur=cur.next;
            }
    }

    public void clear(){
            this.head.next=null;
            this.head=null;
    }
}

循环队列

循环队列是指队尾连接在队首之后形成一个循环，

 循环的队列一半由数组实现，定义两个指针，一个指向头结点，一个指向尾结点，并且设定一个位置作为缓冲区，这个位置不存放数据，当尾结点的下一个是头结点时意味着队列已满。头尾位置的确定要进行取余，从而保证下标不越界。

数组模拟实现循环队列：

class MyCircularQueue {
     public int[] list;
     public int usedsize;
     public int front=0;
     public int rear=0;
     public int length=0;
    public MyCircularQueue(int k) {
         this.list=new int[k+1];
         this.length=k+1;
    }


    public boolean enQueue(int value) {
        if(isFull()) return false;
        list[rear]=value;
        rear=(rear+1)%length;
        usedsize++;
        return true;
    }


    public boolean deQueue() {
      if(isEmpty()) return false;
        front=(front+1)%length;
        usedsize--;
        return true;
    }


    public int Front() {
        if(isEmpty()) return -1;
        return list[front];
    }


    public int Rear() {
        if(isEmpty()) return -1;
        if(rear==0) return list[length-1];
        else return list[rear-1];
    }


    public boolean isEmpty() {
     if(usedsize==0) return true;
     else return false;
    }


    public boolean isFull() {
    if((rear+1)%length==front) return true;
    else return false;
    }
}

双端队列 (Deque)
双端队列（deque）是指允许两端都可以进行入队和出队操作的队列，deque 是 “double ended queue” 的简称。那就说明元素可以从队头出队和入队，也可以从队尾出队和入队。Deque是一个接口，使用时必须创建LinkedList的对象。