【栈和队列】使用数组实现栈，使用数组实现链表，使用链表实现队列，使用链表实现栈

学习目标：

目标：熟练运用Java所学知识

---

学习内容：

本文内容：学习栈和队列的基本知识，然后使用数组实现栈，使用数组实现链表，使用链表实现队列，使用链表实现队列

---

具体实现：

• 使用数组实现栈

//数组实现栈
class MyStack{
    
    
    int[] data=new int[100];
    int size=0;
    //入栈操作
    public void push(int value){
    
    
        //数组空间已满
        if(size>=data.length){
    
    
            return;
        }
        data[size++]=value;
    }
    //出栈操作
    public Integer pop(){
    
    
        //栈为空时
        if(size==0){
    
    
            return null;
        }
        size--;
        return data[size];
    }
    //取栈顶元素
    public Integer peek(){
    
    
        if(size==0){
    
    
            return null;
        }
        return data[size-1];
    }
}

• 数组实现链表

数组实现的队列是一个环形队列
记录头和尾下标
入队时尾下标加一，当尾下标走到数组最大下标时，再次加一则等于0；
出队时头下标加一，当头下标走到数组最大下标时，再次加一则等于0；
通过以上两步操作实现环形队列

环形队列的好处：

在普通数组中，出队操作需要遍历数组所有元素，时间复杂度为O(n);
环形队列在出队时，直接将头下标自增，使得原队列的头元素不在有效数据范围内。这样时间复杂度为O(1)

/*数组实现队列*/
class MyQueue_2{
    
    
    int[] data =new int[100];
    int size=0;
    int head=0;
    int tail=0;
    //入队操作
    public boolean offer(int value){
    
    
        if(size==data.length){
    
    
            return false;
        }
        data[tail++]=value;
        //当为下标等于数组长度时，既此时已经超出数组下标范围
        if(tail==data.length){
    
    
            tail=0;
        }
        size++;
        return true;
    }
    //出队操作
    public Integer poll(){
    
    
        if(size==0){
    
    
            return null;
        }
        int ret=data[head++];//记录队首元素
        if(head==data.length){
    
    
            head=0;
        }
        size--;
        return ret;
    }
    //获取队首元素
    public Integer peek(){
    
    
        if(size==0){
    
    
            return null;
        }
        return data[head];
    }
}

• 创建结点

class ListNode {
    
    
        int val;
        ListNode next;//指向下一个节点
        public ListNode(int val){
    
    
            this.val=val;
        }
    }

• 使用链表实现队列

//链表实现对列
class MyQueue {
    
    
    ListNode head = null;
    ListNode tail = null;
    //入队操作
    public boolean offer(int value) {
    
    
        ListNode newHead = new ListNode(value);
        //当队列为空时
        if (head == null) {
    
    
            head = newHead;
            tail = newHead;
            return true;
        }
        tail.next = newHead;//尾插新节点
        tail = newHead;//更新尾结点
        return true;
    }

    //出队操作
    public Integer poll() {
    
    
        //当链表为空时
        if (head == null) {
    
    
            return null;
        }
        
        int ret = head.val;//记录头结点元素
        head = head.next;//删除头结点
        //当删除头结点之后，如果头结点为null
        if (head == null) {
    
    
            tail = null;//将尾结点赋值为null
        }
        return ret;
    }

    //取队首元素
    public Integer peek() {
    
    
        if (head == null) {
    
    
            return null;
        }
        int ret = head.val;
        return ret;
    }
}

• 使用链表实现栈

//链表实现栈
public class MyStack_2{
    
    
    ListNode head=null;//头结点
    
    //入栈
    public void push(int value){
    
    
        ListNode newHead=new ListNode(value);
        //当链表为空时
        if(head==null){
    
    
            head=newHead;
            return;
        }
        //头插操作
        newHead.next=head;
        head=newHead;
    }
    
    //出栈操作
    public Integer pop(){
    
    
        //当链表为空
        if(head==null){
    
    
            return null;
        }
        //头删操作
        int ret=head.val;
        head=head.next;
        return ret;
    }
    //取栈顶元素
    public Integer peek(){
    
    
        if(head==null){
    
    
            return null;
        }
        return head.val;
    }
}