数据结构与算法-java-数组实现队列和栈

首先还是看看什么是队列

队列是只允许在表的前面进行删除操作，表的后面进行插入数据，也就是所谓的先进先出

 

 那么看一下实例

import java.util.Scanner;

public class Queue {
    public static void main(String[] args) {
        ArrQueue queue=new ArrQueue(3);
        char key=' ';
        Scanner scan=new Scanner(System.in);  //标准输入，拿到一个扫描器
        boolean loop=true;  //默认死循环
        while(loop) {
            System.out.println("s(show)：显示队列");
            System.out.println("a(add):添加数据到队列");
            System.out.println("g(get)：从队列取出数据");
            System.out.println("h(head)：查看队列头的数据");
            System.out.println("e(exit)：退出程序");
            key=scan.next().charAt(0);

            switch(key) {
                case's':
                    queue.showQueue();
                    break;
                case'a':
                    System.out.println("请输入一个数字：");
                    int value=scan.nextInt();
                    queue.addQueue(value);
                    break;
                case'g':
                    try {
                        int res=queue.getQueue();
                        System.out.printf("取出的数据是%d
",res);
                    } catch (Exception e) {

                        System.out.println(e.getMessage());
                    }
                    break;
                case'h':
                    try {
                        int res=queue.headQueue();
                        System.out.printf("队列头的数据是：%d
",res);

                    } catch (Exception e) {

                        System.out.println(e.getMessage());
                    }
                    break;
                case'e':
                    scan.close();
                    loop=false;
                    break;
                default:
                    break;
            }

        }
        System.out.println("程序退出~~");
    }
    }


class ArrQueue{
    private int Maxsize;//表示数组的最大容量
    private int front;//队列头
    private int rear;//队列尾
    private int[] Arr;//用于存放数据

    //创建队列的构造器
    public ArrQueue(int ArrMaxsize) {
        Maxsize=ArrMaxsize;
        Arr=new int[Maxsize];
        front=-1;
        rear=-1;
    }

    //判断队列是否满
    public boolean QueueisFull(){
        return  rear==Maxsize-1;
    }
    //判断队列是否空
    public boolean QueueisEmpty() {
        return rear==front;
    }
    //添加数据到队列
    public void addQueue(int n) {
        if(QueueisFull()) {
            System.out.println("队列已满，无法加入数据");
            return;
        }
        rear++;//rear后移
        Arr[rear]=n;
    }
    //获取队列数据，出队列
    public int getQueue(){
        //判断队列是否为空
        if(QueueisEmpty()) {
            //不能return -1;避免万一就有-1这个值。
            throw new RuntimeException("队列为空，没有数据");
            //并且这里不能再return ，因为throw本身就会终止，它也会马上返回，所以throw本身就会return
        }
        front++;
        return Arr[front];
    }
    //显示队列的所有数据
    public void showQueue(){
        if(QueueisEmpty()) {
            System.out.println("队列为空，没有数据");
            return;
        }for(int i=0;i<Arr.length;i++) {
            System.out.printf("Arr[%d]=%d
",i,Arr[i]);
        }
    }
    //显示队列的头数据
    public int headQueue() {
        if(QueueisEmpty()) {
            System.out.println("队列为空，没有数据");
        }return Arr[front+1];

    }
        }

那么既然明白了队列，那栈也类似

栈（stack），它是一种运算受限的线性表。这种限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底，向一个栈中插入新元素，我们一般称为入栈或者压栈，从一个栈中删除元素，我们一般称为弹栈或者出栈，即先进后出，而出栈入栈操作时栈底是不会动的

下面来看代码

 
public class ArrayStack {
    //准备一个数组和一个指针
    private Integer[] arr;
    private Integer index;
 
    //构造函数
    public ArrayStack(int stackSize) {
        if (stackSize < 0) {
            throw new IllegalArgumentException("初始化大小不能小于0");
        }
        //初始化一个数组，并将指针指向索引0位置
        arr = new Integer[stackSize];
        index = 0;
    }
    //向栈中存入数据
    public void push(int num){
        if(index==arr.length){
            throw new IllegalArgumentException("栈已满");
        }
        arr[index]=num;
        index++;
    }
    //从栈中弹出数据
    public Integer pop(){
        if(index==0){
            throw new  IllegalArgumentException("栈目前为空");
        }
        index--;
        return arr[index];
    }
    //查看目前栈顶数据
    public Integer peek(){
        if(index==0){
            return null;
        }
        return arr[index-1];
    }