数据结构-栈和队列

一、栈

1、栈的定义

栈（stack ）又称堆栈，它是运算受限的线性表。
其限制是仅允许在表的一端进行插入和删除操作，不允许在其他任何位置进行插入、查找、删除等操作。
表中进行插入、删除操作的一端称为 栈顶（top） ，栈顶保存的元素称为 栈顶元素。
相对的，表的另一端称为栈底（bottom）

当栈中没有数据元素时称为空栈；
向一个栈插入元素又称为 进栈或 入栈；
从一个栈中删除元素又称为 出栈或 退栈。
由于栈的插入和删除操作仅在栈顶进行，后进栈的元素必定先出栈，
所以又把堆栈称为 后进先出表（Last In First Out，简称 LIFO）

2、栈的存储结构

顺序栈
顺序栈是使用顺序存储结构实现的堆栈，即利用一组地址连续的存储单元依次存放堆栈中的数据元素。
由于堆栈是一种特殊的线性表，因此在线性表的顺序存储结构的基础上，选择线性表的一端作为栈顶即可。
根据数组操作的特性，选择数组下标大的一端，即线性表顺序存储的表尾来作为栈顶，此时入栈、出栈等操作可以在Ο(1)时间完成。
由于堆栈的操作都在栈顶完成，因此在顺序栈的实现中需要附设一个指针 top 来动态的指示栈顶元素在数组中的位置。
通常 top 可以用栈顶元素所在数组下标来表示，top= -1 时表示空栈。

链栈
链栈即采用链式结构作为存储结构实现的栈。
当采用单链表存储线性表后，根据单链表的操作特性选择单链表的头部作为栈顶，此时，入栈、出栈等操作可以在Ο(1)内完成。
由于堆栈的操作只在线性表的一端进行，在这里使用带头结点的单链表或不带头结点的单链表都可以。
使用带头结点的单链表时，结点的插入和删除都在头结点之后进行；
使用不带头结点的单链表时，结点的插入和删除都在链表的首结点上进行。

二、队列

1、队列的定义：

队列（queue ）简称队，它同堆栈一样，也是一种运算受限的线性表，
其限制是仅允许在表的一端进行插入，而在表的另一端进行删除。
在队列中把插入数据元素的一端称为 队尾（rear） ），删除数据元素的一端称为 队首（front） ）。
向队尾插入元素称为 进队或入队，新元素入队后成为新的队尾元素；
从队列中删除元素称为 离队或出队，元素出队后，其后续元素成为新的队首元素。
由于队列的插入和删除操作分别在队尾和队首进行，每个元素必然按照进入的次序离队，
也就是说先进队的元素必然先离队，所以称队列为 先进先出表（First In First Out,简称FIFO）。

2、队列的存储结构

顺序队列

• 方法1：使用数组作为存储结构：
  
  缺点：通过出队操作将数据弹出队列后，front之前的空间还能够再次得到吗？
  不能。所以使用普通数组实现队列，就再也不能使用front之前的空间了，这会导致大量空间丢失

• 方法2：使用循环数组作为存储结构：
  为了解决这个问题，将普通数组换成循环数组。在循环数组中，末尾元素的下一个元素不是数组外，而是数组的头元素。
  这样就能够再次使用front之前的存储空间了
  

链式队列
队列的链式存储可以使用单链表来实现。
为了操作实现方便，这里采用带头结点的单链表结构。
根据单链表的特点，选择链表的头部作为队首，链表的尾部作为队尾。
除了链表头结点需要通过一个引用来指向之外，还需要一个对链表尾结点的引用，以方便队列的入队操作的实现。
为此一共设置两个指针，一个队首指针和一个队尾指针，如图 所示。

队首指针指向队首元素的前一个结点，即始终指向链表空的头结点，队尾指针指向队列当前队尾元素所在的结点。
当队列为空时，队首指针与队尾指针均指向空的头结点

双端队列deque double ended queue 通常读为“deck”

所谓双端队列是指两端都可以进行进队和出队操作的队列，如下图所示，将队列的两端分别称为前端和后端，两端都可以入队和出队。其元素的逻辑结构仍是线性结构

在双端队列进队时：前端进的元素排列在队列中后端进的元素的前面，后端进的元素排列在队列中前端进的元素的后面。在双端队列出队时，无论前端出还是后端出，先出的元素排列在后出的元素的前面。

输出受限的双端队列，即一个端点允许插入和删除，另一个端点只允许插入的双端队列。

输入受限的双端队列，即一个端点允许插入和删除，另一个端点只允许删除的双端队列。

双端队列既可以用来队列操作，也可以用来实现栈操作（只操作一端就是栈了）

三、Java中的栈和队列类

• Stack类：栈类 (过时 ) public class Stack extends Vector
• Queue：队列类
• Deque：双端队列（栈操作建议使用）

队列：public interface Queue extends Collection

双端队列 ：public interface Deque extends Queue

Java中实现栈和队列操作都可以通过使用LinkedList类实现，当然底层使用的链表

public class LinkedList<E>  extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

1、栈的实现及应用

自定义栈的实现

public class GeneralArrayStack<T> {

    private static final int DEFAULT_SIZE = 12;
    private T[] mArray;
    private int count;

    public GeneralArrayStack(Class<T> type) {
        this(type, DEFAULT_SIZE);
    }

    public GeneralArrayStack(Class<T> type, int size) {
        // 不能直接使用mArray = new T[DEFAULT_SIZE];
        mArray = (T[]) Array.newInstance(type, size);
        count = 0;
    }

    // 将val添加到栈中
    public void push(T val) {
        mArray[count++] = val;
    }

    // 返回“栈顶元素值”
    public T peek() {
        return mArray[count-1];
    }

    // 返回“栈顶元素值”，并删除“栈顶元素”
    public T pop() {
        T ret = mArray[count-1];
        count--;
        return ret;
    }

    // 返回“栈”的大小
    public int size() {
        return count;
    }

    // 返回“栈”是否为空
    public boolean isEmpty() {
        return size()==0;
    }

    // 打印“栈”
    public void PrintArrayStack() {
        if (isEmpty()) {
            System.out.printf("stack is Empty\n");
        }

        System.out.printf("stack size()=%d\n", size());

        int i=size()-1;
        while (i>=0) {
            System.out.println(mArray[i]);
            i--;
        }
    }

    public static void main(String[] args) {
        String tmp;
        GeneralArrayStack<String> astack = new GeneralArrayStack<String>(String.class);

        // 将10, 20, 30 依次推入栈中
        astack.push("10");
        astack.push("20");
        astack.push("30");

        // 将“栈顶元素”赋值给tmp，并删除“栈顶元素”
        tmp = astack.pop();
        System.out.println("tmp="+tmp);

        // 只将“栈顶”赋值给tmp，不删除该元素.
        tmp = astack.peek();
        System.out.println("tmp="+tmp);

        astack.push("40");
        astack.PrintArrayStack();    // 打印栈
    }
}

Deque的实现类：ArrayDeque
public class ArrayDeque<E> extends AbstractCollection<E>
                           implements Deque<E>, Cloneable, Serializable
ArrayDeque是Deque 接口的大小可变数组的实现

/**
 * 功能：模拟生活中叠盘子案例
 * 
 * LinkedList既可以当做线性表处理，也可以当做栈、队列使用
 * @author Administrator*
 */
public class TestDeque {

	public static void main(String[] args) {
		//创建一个栈
		Deque deque =  new LinkedList();		
		//叠盘子:入栈
//		deque.addFirst("盘子1");
//		deque.addFirst("盘子2");
//		deque.addFirst("盘子3");
		deque.push("盘子1");
		deque.push("盘子2");
		deque.push("盘子3");		
		//获取最上面的盘子：获取栈顶元素
//		System.out.println(deque.getFirst());
//		System.out.println(deque.getFirst());
//		System.out.println(deque.getFirst());
		System.out.println(deque.peek());
		System.out.println(deque.peek());
		System.out.println(deque.peek());		
		//拿走盘子：出栈
//		System.out.println(deque.removeFirst());
//		System.out.println(deque.removeFirst());
//		System.out.println(deque.removeFirst());
		System.out.println(deque.pop());
		System.out.println(deque.pop());
		System.out.println(deque.pop());

	}
}

应用：

/**
 * 借助栈实现进制转换（10----2）
 * @author Administrator
 *
 */
public class TestConversion {
	public static void main(String[] args) {		
		int n = 13;
		int t = n;
		//String str = "";
		Deque<Integer>  deque = new LinkedList<Integer>();
		while(t>0){
			//除以2得到余数作为二进制位
			int mod = t%2;
			//System.out.print(mod);
			//str = mod + str;
			deque.push(mod);
			//除以2得到商作为被除数继续
			int result = t/2;
			t = result;
		}
		System.out.print(n+"--------->");
		while(!deque.isEmpty()){
			System.out.print(deque.pop());
		}		
	}
}

2、自定义队列及java中自带队列的代码测试

自定义队列

/**
 * Java : 数组实现“队列”，可以存储任意类型的数
 */
public class ArrayQueue<T> {

    private static final int DEFAULT_SIZE = 12;
    private T[] mArray;
    private int mCount;

    public ArrayQueue(Class<T> type) {
        this(type, DEFAULT_SIZE);
    }

    public ArrayQueue(Class<T> type, int size) {
        // 不能直接使用mArray = new T[DEFAULT_SIZE];
        mArray = (T[]) Array.newInstance(type, size);
        mCount = 0;
    }

    // 将val添加到队列的末尾
    public void add(T val) {
        mArray[mCount++] = val;
    }

    // 返回“队列开头元素”
    public T front() {
        return mArray[0];
    }

    // 返回“栈顶元素值”，并删除“栈顶元素”
    public T pop() {
        T ret = mArray[0];
        mCount--;
        for (int i=1; i<=mCount; i++)
            mArray[i-1] = mArray[i];
        return ret;
    }

    // 返回“栈”的大小
    public int size() {
        return mCount;
    }

    // 返回“栈”是否为空
    public boolean isEmpty() {
        return size()==0;
    }

    public static void main(String[] args) {

        ArrayQueue<Integer> astack = new ArrayQueue(Integer.class);

        // 将10, 20, 30 依次推入栈中
        astack.add(10);
        astack.add(20);
        astack.add(30);

        // 将“栈顶元素”赋值给tmp，并删除“栈顶元素”
        Integer tmp = astack.pop();
        System.out.printf("tmp=%d\n", tmp);

        // 只将“栈顶”赋值给tmp，不删除该元素.
        tmp = astack.front();
        System.out.printf("tmp=%d\n", tmp);

        astack.add(40);

        System.out.printf("isEmpty()=%b\n", astack.isEmpty());
        System.out.printf("size()=%d\n", astack.size());
        while (!astack.isEmpty()) {
            System.out.printf("size()=%d\n", astack.pop());
        }
    }
}

java中自带队列的代码测试

/**
 * 功能：模拟生活中超市购物排队结算
 * 技能：使用LinkedList实现队列的操作
 */
public class TestQueue {
	public static void main(String[] args) {
		//创建一个队列
		java.util.Queue queue = new LinkedList();		
		//入队
		queue.offer("张三");
		queue.offer("李四");
		queue.offer("王五");
		//获取队头元素
		System.out.println(queue.element());
		System.out.println(queue.element());
		System.out.println(queue.element());
		//出队
		System.out.println(queue.remove());
		System.out.println(queue.poll());
		queue.offer("赵六");
		System.out.println(queue.poll());
		System.out.println(queue.poll());
		System.out.println(queue.poll());
		System.out.println(queue.poll());
		System.out.println(queue.poll());
	}
}