Java中栈和队列的实现（利用顺序表、链表还有库中分别实现）

用一个有味道的例子来说
栈就是吃了吐，队列就是吃了拉（emmm）

== 栈和队列都是基于顺序表链表实现的。==

栈

栈的操作

栈的操作：

1、入栈：把元素通过栈顶往下放
2、出栈：把栈顶的元素删除
3、取栈顶元素：获取到最上面的元素
后进先出

栈的实现

基于顺序表

入栈

出栈

取栈顶元素

public class MyStack {
    //基于顺序表，创建栈，实质是数组，这里是无扩容
    private int[] array = new int[100];
    //定义一个size用来计数数组中的存储元素数量
    private int size = 0;

    //入栈
    public void push(int value){
        array[size] = value;
        size++;
    }

    //出栈
    public Integer pop(){
        //判断栈是否为空
        if(size <= 0){
            return null;
        }
        int ret = array[size-1];
        size--;
        return ret;
    }

    
    //取栈顶元素
    public Integer peak(){
        if(size <= 0){
            return null;
        }
        int ret = array[size-1];
        return ret;
    }

    public static void main(String[] args) {
        MyStack myStack = new MyStack();
        myStack.push(1);
        myStack.push(2);
        myStack.push(3);
        while (true){
            Integer cur = myStack.pop();
            if(cur == null){
                break;
            }
            System.out.println(cur);
        }

    }

}

基于链表

带傀儡节点，用链表头部表示栈顶，链表尾部表示栈底，只要知道头结点就可以获取到后面的所有节点

入栈

出栈

取栈顶元素

//通过链表实现栈
public class MyStack1 {
    //定义链表
    static class Node{
        public int val;
        public Node next;

        public Node(int val) {
            this.val = val;
        }
    }
    Node head = new Node(-1);

    //入栈，单链表头插法
    public void push(int val){
        Node newNode = new Node(val);
        newNode.next = head.next;
        head.next = newNode;
    }

    //出栈 单链表头删
    public Integer pop(){
        Node toDelete = head.next;
        if(toDelete == null){
            //栈为空
            return null;
        }
        head.next = toDelete.next;
        return toDelete.val;
    }

    //取栈顶
    public Integer peak(){
        if(head.next == null){
            //栈为空
            return null;
        }
        return head.next.val;

    }

    public static void main(String[] args) {
        MyStack1 myStack1 = new MyStack1();
        myStack1.push(1);
        myStack1.push(2);
        myStack1.push(3);
        System.out.println(myStack1.peak());

        while (true){
            Integer cur = myStack1.pop();
            if(cur == null){
                break;
            }
            System.out.println(cur);
        }
    }
}

队列

使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头出数据，效率会比较低。

队列的类型

**1、普通对列：**先进先出
**2、优先队列：**出队列顺序和入队列顺序不一样，每次出队列的元素都是优先级最高的元素。（本质上是一个堆）。
**3、消息队列：**不是严格的先进先出，而是按照“类型”获取元素。（就像是医院做B超检查，虽然病人是按照先来的在前面这样的顺序排队的，但是做检查的时候却是凭借医生所叫的病种顺序依次进行检查。）
**4、阻塞队列：**当队列为空时，出队列操作就会阻塞，当队列为满时，入队列操作就会阻塞。
**5、无锁队列：**线程安全队列，比较高效，不是通过锁来实现线程安全通过CAS操作实现。

队列的操作

队列的操作：

1、入队列：从队尾插入元素
2、出队列：删除队首的元素
3、取队首元素：获取队首的元素的值
先进先出

基于顺序表

基于顺序表（数组），构成了循环队列

入队列

如果尾超过数组长度返回队首

出队列

如果头超过数组长度则返回队首

取队首元素

//基于顺序表（数组），构成了循环队列
public class MyQueue1 {
    //定义数组
    private int[] array = new int[100];
    private int head = 0;//指向队首
    private int tail = 0;//指向队尾
    private int size = 0;//有效数据个数



    //入队列
    public boolean push(int val){
        if(size == array.length){
            return false;
        }
        array[tail] = val;
        tail++;
        //如果尾超过数组长度返回队首
        if(tail >= array.length){
            tail = 0;
        }
        //tail = tail % array.length
        size++;
        return true;
    }


    //出队列
    public Integer pop(){
        if(size == 0){
            return null;
        }
        int ret = array[head];
        head++;
        //如果头超过数组长度则返回队首
        if(head >= array.length){
            head = 0;
        }
        size--;
        return ret;
    }

    //取队首元素
    public Integer peak(){
        if(size == 0){
            return null;
        }
        return array[head];
    }
    public static void main(String[] args) {
        MyQueue1 myQueue1 = new MyQueue1();
        myQueue1.push(1);
        myQueue1.push(2);
        myQueue1.push(3);
        System.out.println(myQueue1.peak());

        while (true){
            Integer cur = myQueue1.pop();
            if(cur == null){
                break;
            }
            System.out.println(cur);
        }
    }
}

基于单链表

实现队列使用链表，将链表表头作为队首，链表表尾作为队尾，因为是先进先出所以要进行尾插，为了更加方便进行尾插，所以多定义一个引用指向队尾。

入队列

出队列

取队首元素

public class MyQueue {
    //实现队列使用链表
    //将链表表头作为队首，链表表尾作为队尾，因为是先进先出所以要进行尾插
    //为了更加方便进行尾插，所以多定义一个引用指向队尾
    static class Node{
        public int val;
        public Node next;

        public Node(int val) {
            this.val = val;
        }
    }
    Node head = new Node(-1);
    Node tail = head;


    //入队列
    public void push(int val){
        //进行尾插
        Node newNode = new Node(val);
        tail.next = newNode;
        //插入完毕后更新tail，tail始终指向最后一个
        tail = tail.next;
    }

    //出队列
    public Integer pop(){
        //头删法
        if(head.next == null){
            return null;
        }
        Node toDelete = head.next;
        head.next = toDelete.next;
        //如果删除后队列为空，让tail指回傀儡节点
        if(head.next == null){
            tail = head;
        }
        return toDelete.val;
    }

    //取队首元素

    public Integer peak(){
        if(head.next == null){
            return null;
        }
        return head.next.val;
    }
    public static void main(String[] args) {
        MyQueue myQueue = new MyQueue();
        myQueue.push(1);
        myQueue.push(2);
        myQueue.push(3);
        System.out.println(myQueue.peak());

        while (true){
            Integer cur = myQueue.pop();
            if(cur == null){
                break;
            }
            System.out.println(cur);
        }
    }
}

库中的栈和队列使用

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
public class TestStackQueue {
    public static void main(String[] args) {
        System.out.println("==============");
        Stack<String> stack = new Stack<>();
        stack.push("科比");
        stack.push("韦德");
        stack.push("詹姆斯");
        stack.push("乔丹");
        while (! stack.empty()) {
            System.out.println(stack.pop());
        }
        System.out.println("===============");
        //在Java库中Queue是个j接口不能直接实例化对象
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(45);
        queue.offer(52);
        queue.offer(63);
        while (! queue.isEmpty()) {
            System.out.println(queue.poll());
        }

    }
}