栈和队列的实现

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

关于数据结构中栈和队列的实现

一、 栈(Stack)

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

1. 利用顺序表实现，即使用尾插 + 尾删的方式实现
2. 利用链表实现，则头尾皆可 相对来说，顺序表的实现上要更为简单一些，所以我们优先用顺序表实现栈。

二、队列(Queue)

2.1 概念 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾（Tail/Rear） 出队列：进行删除操作的一端称为队头 （Head/Front）
2.2 实现 队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上 出数据，效率会比较低。

1.栈结构使用数组实现和链表实现

代码如下（示例）：

import java.util.Arrays;

public class MyStack {
` public int []arr;//定义一个数组
    public  int szie=0;//用来记录元素的个数
    //提供一个构造器可以自己确定数组容量的大小
    public MyStack(int[] arr) {
        this.arr = arr;
    }
    //提供一个默认大小的数组
    public MyStack() {
        arr=new int[15];
    }
    //返回元素个数
    public int size(){
        return szie;
    }
    //进行入栈和出栈都要判断栈的容量是否满足将要进行的操作
    public boolean isEmputy(){//判断空栈的元素情况
        return szie==0;
    }
    //判断栈的容量是否充足，如果不够进行扩容
    public void enough(){
        if (szie>=arr.length){
            int len=(arr.length-1)*2;
            int [] newArray = new int[len];//构建新的数组空间
            newArray= Arrays.copyOf(arr,arr.length);//将原来的数组的值复制的新的数组当中
            arr=newArray;//将新的数组的地址指向原来的数组
        }
    }

    //栈的入栈操作
    public void push(int val){
        //判断栈是否还能放入
        enough();
        arr[szie++]=val;//利用szie
    }
    //栈的出栈操作
    public int  pop(){
        //判断栈是否为空
        if(isEmputy()){
            throw  new  RuntimeException(String.format("栈为空 szie= %d",szie));
        }
       return arr[--szie];
    }
    //取出栈顶元素
    public int peek(){
        return arr[szie-1];
    }

}
//栈使用链表
public class Node {
    public int val;
    public Node next;

    public Node(int val) {
        this.val = val;
    }

    @Override
    public String toString() {
        return "Node{" +
                "val=" + val +
                '}';
    }
}



public class MylinkedStack {
    //栈使用链表的方式实现
    public Node head;//头指针
    public int size;//记元素的个数

    public MylinkedStack() {
        this.head = null;
        this.size = 0;
    }

    //判断栈是否为空
    public boolean LinkedIsEmputy() {
        return size == 0;
    }

    //入栈操作
    public void linkedPush(Node node) {
        if (head == null) {
            head = node;
            return;
        }
        Node cur = head.next;
        while (cur != null) {
            cur = cur.next;
        }
        cur = node;
        size++;
    }

    //出栈操作
    public Node pop() {
        if (LinkedIsEmputy()) {
            throw new RuntimeException(String.format("栈为空"));
        }
        Node cur = head.next;
        while (cur.next != null) {
            cur = cur.next;
        }
        return cur;
    }

    //返回栈顶元素
    public Node peek() {
        Node cur = head.next;
        while (cur.next != null) {
            cur=cur.next;
        }
        return cur;
    }
}
---
## 1队列结构使用数组实现和链表实现
public class MyQueue {
  
        //这样实现是有一定的问题的当出队后指针不能后退空的空间不能访问

        private int maxSize=0;
        private int front=-1;
        private int rear =-1;
        private int [] arry;
        //构造一个队列
        public MyQueue(int arrmaxSize){
            arry=new int[10];
        }
        //判断队列是否为空
        public boolean isEmpty(){
            return maxSize==0;
        }
        //判断队列是否满
        public boolean ifFull(){
            return maxSize==arry.length;
        }
        //添加队列元素
        public void addQueue(int e){
            if (ifFull()){
                throw new RuntimeException("队列满了无法添加元素");
            }
            rear++;
            arry[rear]=e;
            maxSize++;
        }
        //取出队列元素
        public  int  getQueue(){
            //判断队列是否为空
            if (isEmpty()){
                throw new RuntimeException("队列没有元素");
            }
            front++;
            maxSize--;
            return arry[front];

        }
        public void showQueue() {
            if (isEmpty()) {
                System.out.println("对列为空····");
                return;
            }
            for (int i=0;i<arry.length;i++){
                System.out.println("数据为"+arry[i]);
            }
        }

        public  int headQueue()  {
            if (isEmpty()){
                throw new RuntimeException("对列没有数据");
            }

            return arry[front+1];
        }
    }
    //循环对列实现
    class CirleQueue{
        private int size1=0;
        private int front1=-1;
        private int rear1=-1;
        private int [] arry1;
        public CirleQueue(int arrmaxSize){

            arry1=new int[10];
        }
        //判断队列是否为空
        public boolean isEmputy(){
            return front1 ==rear1;//当队头和队尾指针指向同一个数
        }
        //队列的元素个数
        public int size1(){
            return (rear1-front1+arry1.length)%arry1.length;//或者return size1;
        }
        //判断队列是否满
        public boolean isFill(){
            return (rear1+1)%arry1.length==front1;
        }
        //入队的方式
        public void add(int val){
            if (isFill()){
                throw new RuntimeException("队列已经满了");
            }
            arry1[(rear1+1)%arry1.length]=val;
            size1++;
        }
        //移除并返回队列头部的元素
        public int remove(){
            if (isEmputy()){
                throw new RuntimeException("队列为空");
            }
            int val=arry1[front1];
            front1=(front1+1)%arry1.length;
            size1--;
            return val;
        }
     //   element  返回队列头部的元素
        public int element(){
            if (isEmputy()){
                throw new RuntimeException("队列为空");
            }
            return arry1[front1];
        }

    }


队列使用链表实现
public class QueueNode {
   public int val;
   public QueueNode next;

    public QueueNode(int val) {
        this.val = val;
    }
}

public class MyQueueLinked {
    public int size=0;//记录元素的个数
    public QueueNode head;//对头zhizhen
    public QueueNode last;//队尾指针
    //队列是否为空
    public boolean isEmputy(){
        return size==0;
    }
    //返回元素的个数
    public int getSize(){
        return size;
    }
    //元素的添加
    public void offer(int val){
     //使用尾插法建队
        //判断该队是否为空
        if (isEmputy()){
            QueueNode queueNode=new QueueNode(val);//当该队列元素为0队头队尾指针为空，把新建立的结点指向队头队尾
            queueNode.next=null;
            head=last=queueNode;
        }else {
          QueueNode queueNode1=new QueueNode(val);
          queueNode1.next=null;
          last.next=queueNode1;
          last=queueNode1;//队尾指针向后移
            size++;
        }
    }
    //元素出队列并返回
    public  int  poll(){
        if (isEmputy()){
            throw new RuntimeException("队列为空");
        }
       int val=head.val;
        head=head.next;
        size--;
        return val;
    }
//返回队头元素
    public int peek(){
        if (isEmputy()){
            throw new RuntimeException("队列为空");
        }
        return head.val;
    }

}