栈是一种特殊的线性表，数据只能在栈顶一端进行插入与删除操作，数据元素遵从“先进后出”的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据在栈顶
栈的常用方法
| 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的对象。
