Java实现栈和队列

栈（stack）:是限定仅在表尾进行插入和删除操作的线性表；

        （1）我们把允许插入和删除的一端称为栈顶（top），另一端称为栈底（bottom），不含任何数据元素的栈称为空栈，栈又称为后进先出（Last In First Out）的线性表，简称LIFO结构；

         （2）首先，栈是一个线性表，也就是说，栈具有线性关系，即前驱后继关系，只不过它是一种特殊的线性表而已；而定义中说的在线性表的表尾进行插入和删除操作，这里的表尾是指栈顶，而不是栈底；

          （3）栈的应用：平衡符号，后缀表达式，中缀到后缀的转换，栈与递归；

栈的实现：由于栈属于线性表，所以栈的实现方式也有顺序实现方式和链式实现方式；并且实现时，可以直接调用前面两种线性表；

顺序实现方式：

package list;

public class Stack<T>
{
	private MyArrayList<T> list = new MyArrayList<T>();
	private int size;;
	
	public void push(T e)
	{
		list.add(e);
		size ++;
	}
	
	public T pop()
	{
		T e = list.get(size - 1);
		size --;
		return e;
	}
	
	public int getSize()
	{
		return size;
	}
	public static void main(String[] args)
	{
		Stack<String> list = new Stack<String>();
		
		list.push("input1");
		list.push("input2");
		list.push("input3");
		list.push("input4");
		
		System.out.println(list.pop());
		System.out.println(list.getSize());
	}
}

而链式实现方式类似，在此省略；

队列（queue）：只允许在一端进行插入操作，而在另一端进行删除操作的线性表；

           （1）队列是一种先进先出的线性表（First In First Out），简称FIFO，允许插入的一端为队尾，允许删除的一端为队头；

            （2）队列的链表实现是很简单的，但队列的数组实现或许有些问题，因此就出现了循环数组来实现队列；

队列的顺序实现方式：

package list;

public class Queue<T>
{
	private MyArrayList<T> list = new MyArrayList<T>();
	private int size;
	
	//入队
	public void enQueue(T e)
	{
		list.add(e);
		size++;
	}
	
	//出队
	public T deQueue()
	{
		if (size > 0)
		{
			T e = list.get(0);
			list.remove(0);
			return e;
		}
		else
		{
			throw new RuntimeException("已经到队列顶部");
		}
	}
	
	public int getSize()
	{
		return size;
	}
	
	public static void main(String[] args)
	{
		Queue<String> list = new Queue<String>();
		
		list.enQueue("input1");
		list.enQueue("input2");
		list.enQueue("input3");
		list.enQueue("input4");
		
		System.out.println(list.deQueue());
		
		System.out.println(list.getSize());
	}
}