Stack栈和Queue队列

Stack栈

       栈是一种用于存储数据的简单数据结构，栈与线性表的最大区别是数据的存取的操作，可以这样认为栈Stack是一种特殊的线性表，其插入和删除操作只允许在线性表的一端进行，一般而言，把允许操作的一端称为栈顶Top，不可操作的一端称为栈底Bottom，同时把插入元素的操作称为入栈Push，删除元素的操作称为出栈Pop。若栈中没有任何元素，则称为空栈。有顺序栈和链式栈两种。

       java预定义的栈实现
public class Stack<E> extends Vector<E>实现方式为自定义实现的可变长数组，线程安全

常用方法

- E push(E item) 把项压入堆栈顶部
- synchronized E pop() 移除堆栈顶部的对象，并作为此函数的值返回该对象
- synchronized E peek() 查看堆栈顶部的对象，但不从堆栈中移除它
- boolean empty() 测试堆栈是否为空
- synchronized int search(Object o) 返回对象在堆栈中的位置，以 1 为基数

自定义栈

public class 自定义栈 {
	public static void main(String[] args) {
		Stack<Integer> s = new SeqStack<Integer>();
		System.out.println("是否为空" + s.empty());
		for (int i = 0; i < 5; i++)
			s.push(i);
		System.out.println("栈顶数据为" + s.peek());
		while (!s.empty())
			System.out.println(s.pop());

	}
}

//定义接口
interface Stack<T> {
	// 栈是否为空
	boolean empty();

	// data元素入栈
	void push(T data);

	// 返回栈顶元素,未出栈
	T peek();

	// 出栈,返回栈顶元素,同时从栈中移除该元素
	T pop();
}
class SeqStack<T> implements Stack<T>, Serializable {
	// 栈顶指针，-1代表空栈
	private int top = -1;
	// 容量大小默认为10
	private int capacity = 10;
	// 存放元素的数组
	private T[] array;
	//当前栈中存在的数据长度
	private int size;

	@SuppressWarnings("unchecked")
	public SeqStack() {
		array = (T[]) new Object[capacity];
	}

	// 一般情况下应该方法名称为getSize，但是遵循一般的使用习惯，所以命名为size()
	public int size() {
		return size;
	}

	@Override
	public boolean empty() {
		return this.top == -1;
	}

	// 添加元素,从栈顶(数组尾部)插入
	public void push(T data) {
		// 判断容量是否充足
		if (size == array.length)
			ensureCapacity(size * 2 + 1);// 扩容
		// 从栈顶添加元素
		array[++top] = data;
		size++;
	}

	@SuppressWarnings("unchecked")
	private synchronized void ensureCapacity(int len) {
		Object[] res = new Object[len];
		System.arraycopy(array, 0, res, 0, this.size);
		this.array = (T[]) res;
	}

	// 获取栈顶元素的值,不删除
	public T peek() {
		if (empty())
			throw new EmptyStackException();
		return array[top];
	}

	// 从栈顶(顺序表尾部)删除
	public T pop() {
		if (empty())
			throw new EmptyStackException();
		size--;
		return array[top--];
	}

}

class EmptyStackException extends RuntimeException {
	private static final long serialVersionUID = 1L;

	public EmptyStackException() {
		super();
		// TODO Auto-generated constructor stub
	}

	public EmptyStackException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
		super(message, cause, enableSuppression, writableStackTrace);
		// TODO Auto-generated constructor stub
	}

	public EmptyStackException(String message, Throwable cause) {
		super(message, cause);
		// TODO Auto-generated constructor stub
	}

	public EmptyStackException(String message) {
		super(message);
		// TODO Auto-generated constructor stub
	}

	public EmptyStackException(Throwable cause) {
		super(cause);
		// TODO Auto-generated constructor stub
	}


}

Queue队列

      队列是一种特殊的线性表，特殊之处在于它只允许在表的前端front进行删除操作，而在表的后端rear进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作端称为队尾，进行删除操作端称为队头。
      根据实现方式不同分为顺序队列和链式队列

接口定义（方法）

public interface Queue<E> extends Collection<E> {
     boolean add(E e);  在队尾添加数据
     boolean offer(E e); 在LinkedList中就是使用add提供的实现

     E remove();  删除队列头部的数据，同时返回删除的数据
     E poll();
   
     E element(); 获取队列头部的数据，并不会执行删除操作
     E peek();
  }

几种常见的队列

队列主要分为阻塞和非阻塞，有界和无界、单向链表和双向链表之分

阻塞和非阻塞
（1）阻塞队列
- 入列(添加元素)时，如果元素数量超过队列总数，会进行等待（阻塞），待队列的中的元素出列后，元素数量未超过队列总数时，就会解除阻塞状态，进而可以继续入列；
- 出列(删除元素)时，如果队列为空的情况下，也会进行等待（阻塞），待队列有值的时候即会解除阻塞状态，进而继续出列；
- 阻塞队列的好处是可以防止队列容器溢出；只要满了就会进行阻塞等待；也就不存在溢出的情况；只要是阻塞队列，都是线程安全的；
（2）非阻塞队列
- 不管出列还是入列，都不会进行阻塞，
- 入列时，如果元素数量超过队列总数，则会抛出异常，
- 出列时，如果队列为空，则取出空值；
一般情况下，非阻塞式队列使用的比较少，一般都用阻塞式的对象比较多；阻塞和非阻塞队列在使用上的最大区别就是阻塞队列提供了以下2个方法：
-  出队阻塞方法 ： take()
-  入队阻塞方法 ： put()

非阻塞队列
1、ConcurrentLinkedQueue 单向链表结构的无界并发队列, 非阻塞队列，由CAS实现线程安全，内部基于节点实现
2、ConcurrentLinkedDeque双向链表结构的无界并发队列, 非阻塞队列，由CAS实现线程安全  
3、PriorityQueue 内部基于数组实现，线程不安全的队列
阻塞队列
1、DelayQueue 一个支持延时获取元素的无界阻塞队列
2、LinkedTransferQueue一个由链表结构组成的无界阻塞队列。
3、ArrayBlockingQueue有界队列，阻塞式,初始化时必须指定队列大小，且不可改变；底层由数组实现；
4、SynchronousQueue最多只能存储一个元素，每一个put操作必须等待一个take操作，否则不能继续添加元素
5、PriorityBlockingQueue一个带优先级的队列，而不是先进先出队列。元素按优先级顺序被移除，而且它也是无界的，也就是没有容量上限，虽然此队列逻辑上是无界的，但是由于资源被耗尽，所以试图执行添加操作可能会导致 OutOfMemoryError 错误

Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Deque接口。

双向队列接口Deque
public interface Deque<E> extends Queue<E> {
    void addFirst(E e); 在队列头部添加数据
           boolean offerFirst(E e);
    void addLast(E e);  在队尾添加数据
        boolean offerLast(E e);
    E removeFirst(); 从对头中删除数据，同时返回删除的数据
        E pollFirst();
    E removeLast();  从队尾删除数据
        E pollLast();
    E getFirst(); 从对头获取数据
        E peekFirst();
    E getLast(); 从队尾获取数据
        E peekLast();
  }

顺序队列实现

public class ArrayQueue {
	private Object[] items; // 具体存储数据的数组
	private int head = 0;// 队头下标
	private int tail = 0; // 队尾下标

	public ArrayQueue() {
		this(10);
	}

	public ArrayQueue(int capacity) {
		items = new Object[capacity];
	}

	public boolean enqueue(Object item) { // 入队操作
		if (tail == items.length)
			return false; // 队伍已满，拒绝插入操作
		items[tail++] = item;
		return true;
	}

	public Object dequeue() { // 出队操作
		if (head == tail)
			return null;// 队列为空
		head++;
		Object x=items[0];
		Object[] res=new Object[items.length];
		System.arraycopy(items, 1, res, 0, items.length-head);
		this.items=res;
		return x;
	}
	
	public static void main(String[] args) {
		ArrayQueue cq = new ArrayQueue();
		for (int i = 0; i < 12; i++) {
			cq.enqueue(i);
		}
		System.out.println(Arrays.toString(cq.items));
		System.out.println("队头:" + cq.head);
		for (int i = 0; i < 4; i++)
			System.out.println(cq.dequeue());
		System.out.println(Arrays.toString(cq.items));
	}
}

循环列表实现

public class CircleQueue {
	private Object[] items;
	private int head = 0, tail = 0;

	public CircleQueue() {
		this(16);
	}

	public CircleQueue(int capacity) {
		items = new Object[capacity];
	}

	public boolean enqueue(Object item) {
		// 如果尾指针和头指针重合则表示不能插入数据，因为头指针指向的位置上有数据
		if (tail % items.length  == head && items[head] != null) {
			return false;
		} // 拒绝插入数据
		tail = tail % items.length;
		items[tail++] = item;
		return true;
	}

	public Object dequeue() {
		if (head== tail && items[head] != null)
			return null;
		Object res = items[head];
		items[head++] = null;
		head = head % items.length;
		return res;
	}

	public static void main(String[] args) {
		CircleQueue cq = new CircleQueue();
		for (int i = 0; i < 12; i++) {
			cq.enqueue(i);
		}
		System.out.println(Arrays.toString(cq.items));
		System.out.println("ddd:" + cq.head);
		for (int i = 0; i < 4; i++)
			System.out.println(cq.dequeue());
		for (int i = 11; i < 20; i++) {
			cq.enqueue(i);
		}
		System.out.println(Arrays.toString(cq.items));
	}
}