栈和队列！

---

前言

随着数据结构的学习，今天我将为大家介绍两种新的数据结构————栈和队列，以及他们的实现方法。

一、Stack的概念

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据在栈顶

二、Stack的实现

栈的实现我将使用顺序表来实现。

2.1MyStack类的构建

public class MyStack{
    public int[] array;
    public int usedsize;
    private static final int Default_Capicity=10;

    public MyStack() {
        this.array=new int[Default_Capicity];
    }

2.2push方法

将元素入栈

 public void push(int val){
        if(isFull()){
            array= Arrays.copyOf(array,2*array.length);
        }
        array[usedsize]=val;
        usedsize++;
    }
 public boolean isFull(){
        return usedsize==array.length;
    }

2.3peek方法

获取栈顶元素，不删除

public int peek(){
        if(empty()){
            throw new StackNullException("栈为空！");
        }
        return array[usedsize-1];
    }
    public int size(){
        return usedsize;
    }

2.4pop方法

获取栈顶元素，且删除

public int pop(){
        int val=peek();
        usedsize--;
        return  val;
    }

2.5size方法

计算栈中的元素个数

 public int size(){
        return usedsize;
    }

2.6empty方法

判断栈为不为空

 public boolean empty(){
        return usedsize==0;
    }

2.7Main类

对栈的测试

public class Main {
    public static void main(String[] args) {
        MyStack myStack=new MyStack();
        myStack.push(1);
        myStack.push(2);
        myStack.push(3);
        myStack.push(4);
        System.out.println(myStack.peek());
        System.out.println(myStack.pop());
        System.out.println(myStack.size());
    }
}

2.8运行截图

三、队列的概念

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(FirstIn First Out) 。
入队列：进行插入操作的一端称为队尾（Tail/Rear）。
出队列：进行删除操作的一端称为队头（Head/Front）。

四、队列的实现

队列的实现我将使用链表来实现

4.1MyQueue类的构建

public class MyQueue {
    static class ListNode{
        public int  val;
        public ListNode next;
        public ListNode prev;

        public ListNode(int val) {
            this.val=val;
        }
        public ListNode head;
        public ListNode last;
        int size=0;
        }

4.2offer方法

模拟进队列

public boolean offer(int val){
            ListNode node=new ListNode(val);
            if(head==null){
                head=node;
                //last=node;
            }else{
                last.next=node;
                node.prev=last;
                //last=node;
            }
            last=node;
            size++;
            return true;
        }

4.3peek方法

获取队头元素不删除

 public int peek(){
            if(head==null){
            return -1;
            }
            return head.val;
        }

4.4poll方法

获取对头元素，且删除

public int poll(){
            if (isEmpty()){
              return -1;
            }
            int val=head.val;
            if(head==last){
                head=null;
                last=null;
            }else{
                head=head.next;
                head.prev=null;
            }
            size--;
            return val;
        }

4.5isEmpty方法

判断队列是否为空

public boolean isEmpty(){
            return size==0;
        }

4.6size方法

计算队列中有几个元素

public int size(){
            return size;
        }

4.7Main类

测试队列

public class Main {
    public static void main(String[] args) {
        MyQueue myQueue=new MyQueue();
        myQueue.offer(1);
        myQueue.offer(2);
        myQueue.offer(3);
        myQueue.offer(4);
        System.out.println(myQueue.poll());
        System.out.println(myQueue.peek());
        System.out.println(myQueue.size);
        System.out.println(myQueue.isEmpty());
    }
}

4.8运行截图

总结

以上就是栈和队列的实现，如果想对栈和队列有更深的理解，请看我的另一个专栏数据结构的应用————栈和队列的具体使用。