数据结构 栈和队列

概述

栈和队列都是通过动态集合来存储数据，在栈和队列中添加和删除数据都是预先设定的，在栈（Stack）中，被删除的元素是最近添加的元素，所以栈的实现方式是后进先出（Last-in， First-out）；在队列中，被删除的元素是最开始添加的的元素，也就是在动态集合中存放时间最长的那个元素，所以队列的实现方式是先进先出（First-in，First-out）。

栈

在栈的数据结构中，添加元素的操作被称之为入栈（PUSH），删除元素的操作被称之为出栈，也可以称为弹出（POP）。如果栈中不存在任何一个元素，那么这个栈被称为空栈。

栈的代码实现

package structdemo;

/**
 * 栈
 */
public class Stack<E> {

    /**
     * 初始大小
     */
    private static final int DEFAULT_CAPACITY = 10;

    private Object[] elementData;

    public Stack() {
        elementData = new Object[DEFAULT_CAPACITY];
    }

    private int size;

    public int getSize() {
        return size;
    }

    /**
     * 判断元素是否为空
     */
    public boolean isEmpty() {
        return size == 0 ? true : false;
    }

    /**
     * 压入
     * 
     * @param e
     */
    public void push(E e) {
        ensureCapacity();
        elementData[size] = e;
        size++;
    }

    /**
     * 数组扩容
     */
    private void ensureCapacity() {
        int oldCapacity = elementData.length;
        if (size == oldCapacity) {
            int newCapacity = oldCapacity + (oldCapacity >> 1);
            Object[] newTable = new Object[newCapacity];
            System.arraycopy(elementData, 0, newTable, 0, size);
            elementData = newTable;
        }
    }

    /**
     * 出栈
     * 
     * @return
     */
    public E pop() {
        if (size == 0) {
            return null;
        }
        E e = (E) elementData[size - 1];
        size--;
        return e;
    }

}

队列

在队列中，添加元素的操作被称之为入队（enqueue），而删除元素的操作被称之为出队（dequeue）。在队列中，会有队头（head）和队尾（tail）。当一个元素入队时，该元素就被放入到队尾的位置，而出队的元素就是队头的元素。

队列的代码实现

package structdemo;

/**
 * 队列
 * 
 * @author zhangke
 *
 * @param <E>
 */
public class Queue<E> {

    /**
     * 初始大小
     */
    private static final int DEFAULT_CAPACITY = 10;

    private Object[] elementData;

    /**
     * 队头和队尾
     */
    private E head, tail;

    public Queue() {
        elementData = new Object[DEFAULT_CAPACITY];
    }

    private int size;

    public int getSize() {
        return size;
    }

    /**
     * 判断元素是否为空
     */
    public boolean isEmpty() {
        return size == 0 ? true : false;
    }

    /**
     * 入队
     * 
     * @param e
     */
    public void enqueue(E e) {
        ensureCapacity();
        elementData[size] = e;
        size++;
    }

    /**
     * 数组扩容
     */
    private void ensureCapacity() {
        int oldCapacity = elementData.length;
        if (size == oldCapacity) {
            int newCapacity = oldCapacity + (oldCapacity >> 1);
            Object[] newTable = new Object[newCapacity];
            System.arraycopy(elementData, 0, newTable, 0, size);
            elementData = newTable;
        }
    }

    /**
     * 弹出
     * 
     * @return
     */
    public E dequeue() {
        if (size == 0) {
            return null;
        }
        E e = (E) elementData[0];
        System.arraycopy(elementData, 1, elementData, 0, size - 1);
        elementData[--size] = null;
        return e;
    }

    /**
     * 队头
     * 
     * @return
     */
    public E getHead() {
        if (size == 0) {
            return null;
        }
        return (E) elementData[0];
    }

    /**
     * 队尾
     * 
     * @return
     */
    public E getTail() {
        if (size == 0) {
            return null;
        }
        return (E) elementData[size - 1];
    }

}