数据结构基础（二）栈和队列

栈和队列从数据结构的角度来看，也是线性表的一种，但比起线性表，操作少了许多。从数据类型来看，它们是和线性表大不相同的两种重要的抽象数据类型

栈

栈（stack）：后进先出（Last In First Out），简称为LIFO线性表。从线性表的特定可知，栈也有顺序栈和链栈两种

顺序栈：采用数组实现，栈的容量有限。也可用代码实现可自增容量的栈。

链栈：采用链表实现，栈的容量没有限度

下面给出顺序栈和链栈的代码。

顺序栈

/**
* 顺序栈
*/
public class Stack {
private Object[] elementDates;
private int top = 0;

public Stack() {
this.elementDates = new Object[5];
}

public int getSize() {
if (elementDates == null)
return 0;
return elementDates.length;
}

public Stack(int capacity) {
if (capacity <= 0)
throw new IllegalArgumentException();
this.elementDates = new Object[capacity];
}

/**
* 返回栈此时的大小
* @return
*/
public int getTopPos() {
return top;
}

/**
* 弹栈
* @return
*/
public Object pop() {
if (top == 0) {
System.out.println("栈为空，无法弹出");
return null;
}
Object delEle = elementDates[--top];
return delEle;
}

/**
* 进栈
* @param o
*/
public void push(Object o) {
if (top >= elementDates.length) {
System.out.println("栈已满，不能继续加入");
return;
}
elementDates[top++] = o;
}

/**
* 返回栈顶部的元素
* @return
*/
public Object peek() {
return top==0?null:elementDates[top-1];
}
/**
* 遍历输出栈中元素
*/
public void doList() {
for (int i = 0; i < top; i++) {
System.out.print(elementDates[i] + " ");
}
System.out.println();
}

public static void main(String[] args) {
Stack stack = new Stack();
//测试空栈的弹出特例
stack.pop();
//压入几个数据进栈
stack.push(1);
stack.push(2);
stack.push(3);
stack.push(4);
stack.push(5);
stack.doList();
//测试弹栈出栈功能
stack.pop();
stack.doList();
stack.push(6);
stack.doList();
//测试满栈压数据的特例
stack.push(7);
System.out.println(stack.peek());
stack.doList();
}

}/*output:
栈为空，无法弹出
1 2 3 4 5
1 2 3 4
1 2 3 4 6
栈已满，不能继续加入
6
1 2 3 4 6   **/

链栈

import java.util.ArrayList;

/**
*链栈
*/
public class LinkStack {
private Node top;
private int length = 0;

/**
* 链表节点
*/
private static class Node {
Object item;
Node pre;

public Node(Object item, Node pre) {
this.item = item;
this.pre = pre;
}
}

public LinkStack() {
top = null;
}

/**
* 压栈
* @param o
*/
public void push(Object o) {
length++;
top=new Node(o, top);
}

/**
* 弹栈
* @return
*/
public Object pop() {
if (top == null) {
System.out.println("栈已为空，无法再弹出");
return null;
}
Node delNode = top;
//释放引用
delNode.pre=null;
top = top.pre;
length--;
return delNode.item;
}

/**
* 返回栈顶部的元素
* @return
*/
public Object peek() {
return top==null?null:top.item;
}
/**
* 遍历输出栈中元素
* 为了顺序输出，先存在arraylist中再反序输出
*/
public void doList() {
ArrayList<Object> list=new ArrayList<Object>();
Node t=top;
while (t!=null) {
list.add(t.item);
t=t.pre;
}

for (int i = length-1; i >=0; i--) {
System.out.print(list.get(i)+" ");
}
System.out.println("["+length+"]");
}

public static void main(String[] args) {
LinkStack linkStack = new LinkStack();
// 测试空栈的弹出特例
linkStack.pop();
// 压入几个数据进栈
linkStack.push(1);
linkStack.push(2);
linkStack.push(3);
linkStack.push(4);
linkStack.push(5);
linkStack.doList();
// 测试弹栈出栈功能
linkStack.pop();
linkStack.doList();
linkStack.push(6);
System.out.println(linkStack.peek());
linkStack.doList();
}
}/*output:
栈已为空，无法再弹出
1 2 3 4 5 [5]
1 2 3 4 [4]
6
1 2 3 4 6 [5]**/

队列

队列（queue）：与栈相反，队列是一种先进先出（first in first out,简称FIFO）的线性表。它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。

顺序队列：一片连续的存储空间，设置两个指针进行管理。一个是队头指针front，它指向队头元素；另一个是队尾指针rear，它指向下一个入队元素的存储位置。每次在队尾插入一个元素是，rear增1；每次队头删除一个元素时，front增1。当rear指向分配空间之外时，尽管还有空间，出现溢出错误。

循环队列：为了解决顺序队列浪费空间，对顺序队列的使用方法稍加改进：无论插入或删除，一旦rear指针增1或front指针增1 时超出了所分配的队列空间，就让它指向这片连续空间的起始位置。

链队列：用链表实现的队列，动态创建和删除节点，效率较低，但是可以动态增长。

循环队列：

注意点：

为与rear==front队列为空的情况区分，牺牲一个空间，规定当rear在front的后面时队列已满。

为实现递增长的循环，用（i+1）%length实现

/**
*循环队列
*/
public class CircleQueue {
Object[] queue=null;
private int front=0;
private int rear=0;

/**
* 默认队列数组大小为5
*/
public CircleQueue() {
queue=new Object[5];
}

/**构造时设置队列数组长度
* @param capacity
*/
public CircleQueue(int capacity) {
if(capacity<=0){
queue=new Object[5];
return ;
}
queue=new Object[capacity];
}

/**
* 出队
* @return
*
* @author wsz
*/
public Object deQueue() {
//当rear==front时判断队列为空
if(front==rear){
System.out.println("队列为空，无法弹出");
return null;
}

Object delNode=queue[front];
front=(front+1)%queue.length;
return delNode;
}

/**
* 入队
* @param o
*
* @author wsz
*/
public void enQueue(Object o) {
//当rear在front后时判断队满
if((rear+1)%queue.length==front){
System.out.println("队列已满，无法加入"+o);
return ;
}
queue[rear]=o;
rear=(rear+1)%queue.length;
}

/**
* 遍历队列
* @author wsz
*/
public void doList() {
for (int i = front; i !=rear ; i=(i+1)%queue.length) {
System.out.print(queue[i]+" ");
}
System.out.println();
}

public static void main(String[] args) {
CircleQueue circleQueue=new CircleQueue();
circleQueue.enQueue(1);
circleQueue.enQueue(2);
circleQueue.enQueue(3);
circleQueue.enQueue(4);
circleQueue.enQueue(5);
circleQueue.doList();

circleQueue.deQueue();
circleQueue.deQueue();
circleQueue.deQueue();
circleQueue.doList();

circleQueue.enQueue(6);
circleQueue.enQueue(7);
circleQueue.doList();

circleQueue.deQueue();
circleQueue.deQueue();
circleQueue.deQueue();
circleQueue.deQueue();
circleQueue.doList();
}
}/*output:
队列已满，无法加入5
1 2 3 4
4
4 6 7
队列为空，无法弹出 **/

链队列

/**
*链队列
*/
public class LinkQueue {
/**
* 队头
*/
private Node front;

/**
* 队尾
*/
private Node rear;
/**
* 队长
*/
private int length = 0;

/**
* 链队节点
*/
private static class Node {
Object item;
Node next;

public Node(Object item, Node pre) {
this.item = item;
this.next = pre;
}
}

public LinkQueue() {
front = rear=null;
}

/**
* 入队
* @param o
*/
public void enQueue(Object o) {
length++;
Node node=new Node(o, null);
//如果此时为空队，把front和rear指向同一个节点
if(rear==null){
front=rear=node;
return ;
}
//否则直接加入，修改rear为新加入节点
rear.next=new Node(o, null);
rear=rear.next;
}

/**
* 出队
* @return
*/
public Object delQueue() {
//如果队列为空
if (front == null) {
System.out.println("队列已为空，无法出队");
return null;
}
Node delNode = front;
//修改队头为下一个节点
front = front.next;
//如果出队后没有节点，把队尾也置为空
if(front==null)
rear=front;
//释放引用
delNode.next=null;
length--;
return delNode.item;
}

/**
* 遍历输出栈中元素
* 为了顺序输出，先存在arraylist中再反序输出
*/
public void doList() {
Node node=front;
if(node==null)
return ;
while (node!=null) {
System.out.print(node.item+" ");
node=node.next;
}
System.out.println();
}

public static void main(String[] args) {
LinkQueue linkStack = new LinkQueue();
// 测试队列的弹出特例
linkStack.delQueue();
linkStack.doList();
// 压入几个数据入队
linkStack.enQueue(1);
linkStack.enQueue(2);
linkStack.enQueue(3);
linkStack.enQueue(4);
linkStack.enQueue(5);
linkStack.doList();
// 测试出队功能
linkStack.delQueue();
linkStack.delQueue();
linkStack.delQueue();
linkStack.delQueue();
linkStack.delQueue();
linkStack.doList();
linkStack.enQueue(6);
linkStack.doList();
}
}/*output:
栈已为空，无法再弹出
1 2 3 4 5
6 **/