Java简单实现栈和队列（附代码和理论知识）

数据结构之栈和队列

数组和链表是线性表的物理存储结构：即顺序存储和链式存储，栈和队列都属于线性表的逻辑存储结构。

上面这句话啥意思？

我们知道常见的数据结构中有一个线性表，线性表包括：数组、链表、栈、队列。

物理存储结构：数据在物理存储空间上选择集中存放还是分散存放，如数组（顺序存储结构）、链表（链式存储结构）。

逻辑存储结构：数据之间的逻辑关系，需要借助物理存储结构进行设计以体现出数据之间的逻辑关系。如：栈、队列、树、图。

上面的那些不利于理解的话我们可以简单理解为：物理存储结构就是数据怎么存，是放在一起连续的存，还是分散的存，而逻辑存储就是数据之间的逻辑关系，这些关系存在于口头语言上，比如树、他能直接实现吗？不能，树提出的只是一个抽象的慨念，只能借助数组或者链表去实现他所描述的逻辑关系。

1、栈

栈（stack）是一种线性数据结构，栈中的元素只能先入后出（First In Last Out，简称FILO）。

最早进入的元素存放的位置叫作栈底（bottom），最后进入的元素存放的位置叫作栈顶 （top）。

存储原理

栈既可以用数组来实现，也可以用链表来实现

栈的数组实现如下图：

数组实现的栈也叫顺序栈或静态栈

栈的链表实现如下图：

链表实现的栈也叫做链式栈或动态栈

代码实现：

数组方式

/**
 * 线性表之栈   使用数组简单模拟栈 
 * TODO WJH
 */
public class ArrayStack<T> {

    private T[] arr;
    private int count;


    public ArrayStack() {
        //创建泛型数组
        this.arr = (T[]) new Object[1 << 4];
    }

    /**
     * 入栈操作
     * @param element
     * @return
     */
    public boolean push(T element) {
        //数组扩容
        if(count >= arr.length) {
            T[] newArr = (T[]) new Object[arr.length * 2];
            System.arraycopy(arr, 0 ,newArr, 0 , arr.length);
            this.arr = newArr;
        }
        arr[count++] = element;
        return true;
    }

    /**
     * 出栈操作
     * @return
     */
    public T pop() {
        return count == 0 ? null : arr[--count];
    }


}

/**
 * 测试类
 */
class ArrayStackTest {
    public static void main(String[] args) {
        ArrayStack<String> stack = new ArrayStack<String>();
        stack.push("我");
        stack.push("是");
        stack.push("猪");

        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());

    }
}

链表方式

/**
 * 线性表之栈 使用链表简单模拟栈
 * TODO WJH
 */
public class LinkedStack<T> {

    private Node<T> head;
    private int count;

    public LinkedStack() {
        head = null;
        count = 0;
    }

    /**
     * 入栈
     * @param element
     * @return
     */
    public boolean push(T element) {
        Node<T> node = new Node<>(element);
        if (head != null) {
            node.next = head;
        }
        head = node;
        count++;
        return true;
    }

    /**
     * 出栈
     * @return
     */
    public T pop() {
        if(count > 0) {
            Node<T> oldHead = head;
            head = head.next;
            count--;
            return oldHead.element;
        } else {
            return null;
        }
    }



    class Node<T> {
        private T element;
        private Node<T> next;

        public Node(T element) {
            this.element = element;
        }
    }

}

/**
 * 测试类
 */
class LinkedStackTest {
    public static void main(String[] args) {
        LinkedStack<String> stack = new LinkedStack<>();
        for (int i = 0; i < 5; i++) {
            stack.push(i + "");
        }

        for (int i = 0; i < 5; i++) {
            System.out.println(stack.pop());
        }

    }
}

2、队列

概念

队列（queue）是一种线性数据结构，队列中的元素只能先入先出（First In First Out，简称 FIFO）。

队列的出口端叫作队头（front），队列的入口端叫作队尾（rear）。

存储原理

队列这种数据结构既可以用数组来实现，也可以用链表来实现。

• 数组实现

用数组实现时，为了入队操作的方便，出队操作的判断方便、把队尾位置规定为最后入队元素的下一个位置。

• 链表实现

代码实现：

数组实现

/**
 * 线性表之队列  使用数组简单模拟队列
 * TODO WJH
 * @param <T>
 */
public class ArrayQueue<T> {

    private T[] arr;
    public int head; //队头下标
    public int tail; //队尾下标

    public ArrayQueue() {
        this.arr = (T[]) new Object[1 << 4];
        head = 0;
        tail = 0;
    }

    /**
     * 入队操作
     * @param element
     * @return
     */
    public boolean enqueue(T element) {
        //数组扩容
        if (tail >= arr.length) {
            T[] newArr = (T[]) new Object[arr.length * 2];
            System.arraycopy(arr, 0, newArr, 0, arr.length);
            this.arr = newArr;
        }
        arr[tail++] = element;
        return true;
    }

    /**
     * 出队操作
     * @return
     */
    public T dequeue() {
        return head == tail ? null : arr[head++];
    }


}

class ArrayQueueTest {
    public static void main(String[] args) {
        ArrayQueue<Integer> queue = new ArrayQueue<>();



        for (int i = 0; i < 10; i++) {
            System.out.println(queue.dequeue());
        }

    }
}

链表实现

/**
 * 线性表之队列 用单向链表简单模拟队列
 * TODO WJH
 * @param <T>
 */
public class LinkedQueue<T> {


    Node<T> head;
    Node<T> tail;
    int count;


    /**
     * 入队
     * @param element
     * @return
     */
    public boolean enqueue(T element) {
        Node<T> node = new Node<>(element);
        if(head == null && tail == null && count == 0) {
            head = node;
            tail = node;
        } else {
            tail.next = node;
            tail = node;
        }
        count++;
        return true;
    }

    /**
     * 出队
     * @return
     */
    public T dequeue() {
        if(head == null && tail == null && count == 0) {
            return null;
        }
        Node<T> tmp = head;
        //选举新的队头
        head = head.next;

        //把旧的队头下一个节点执行null,让gc回收,注意这行代码和上行代码不可交换，会报NullPointerException
        tmp.next = null;

        //最后一个元素了，这个时候head和tail指向同一个元素，干掉head后，tail也没存在的必要了，变为空队列
        if(head == null) {
            tail = null;
        }
        count--;
        return tmp.element;
    }


    class Node<T> {
        T element;
        Node<T> next;

        public Node(T element) {
            this.element = element;
        }


    }

}
class LinkedQueueTest {
    public static void main(String[] args) {
        LinkedQueue<Integer> queue = new LinkedQueue<>();
        for (int i = 0; i < 10; i++) {
            queue.enqueue(i);
        }

        for (int i = 0; i < 10; i++) {
            System.out.println(queue.dequeue());
        }
    }
}