栈和队列

一:栈的构造和应用

先进后出

public class Stack {
        //栈的底层实现是数组
        long[] arr ;
        //表示栈顶
        int top;

        //构造方法
    public Stack(){
        arr = new long[10];
        top = -1;  //初始化栈顶没有数据
    }
    public Stack(int length){
        arr = new long[length];
        top = -1;
    }

    //添加数据--压栈
    public void push(long value){
        arr[++top] = value;
    }

    //删除数据--弹栈
    public long pop(){
        return arr[top--];  //弹栈后数组长度减少
    }

    //查看数据
    public long peek(){
        return arr[top];  //查看数据,不会弹出数据
    }

    //判断是否为空
    public boolean isEmpty(){
        return top==-1;  //返回true则为空
    }

    //判断是否满了
    public boolean isFull(){
        return top==arr.length-1;  //top和数组长度减1 是否相等
    }

}

//main方法

public class Test {
    public static void main(String[] args) {
        Stack stack = new Stack(5);

        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.push(5);
        //stack.push(6);  如果压栈数量大于指定栈长度就会报错

        System.out.println("长度: "+(stack.top+1));

        long pop = stack.pop();
        System.out.println("弹栈: "+ pop);

        long peek = stack.peek();
        System.out.println("查看数据: "+peek);

        boolean empty = stack.isEmpty();
        System.out.println("是否为空: "+empty);

        boolean full = stack.isFull();
        System.out.println("是否满: "+full);

        System.out.println("长度: "+(stack.top+1));
    }
}

二:列队的构造和应用

先进先出

1.常规列队(remove全部数据后无法再插入数据)

public class Quene {
    //队列底层也是数组
    long[] arr;
    //队列长度
    int length;
    //队头
    int front;
    //队尾
    int end;

    //构造方法
    public Quene(){
        arr = new long[10];
        length=0;
        front=0;
        end=-1;
    }
    public Quene(int size){
        arr = new long[size];
        length=0;
        front=0;
        end=-1;
    }

    //1.添加数据,从队列尾插入
    public void insert(long value){
        arr[++end] = value;
        length++;
    }

    //2.删除数据,从队头开始
    public long romove(){
        length--;            //长度减减
        return arr[front++]; //把第一个数据移除,队头就会++
    }

    //3.查看数据,从队头查看
    public long peek(){
        return arr[front];
    }

    //4.判断是否为空
    public boolean isEmpty(){
        return length==0;
    }

    //5.判断是否满了
    public boolean isFull(){
        return length == arr.length;
    }

}

public class Test01 {
    public static void main(String[] args) {

        Quene quene = new Quene(5);
        quene.insert(1);
        quene.insert(2);
        quene.insert(3);  //不满的队列以 0 填充,但是长度不会因为填充的0而变长

        System.out.println("原队列: "+ Arrays.toString(quene.arr)); //原队列: [1, 2, 3, 0, 0]
        System.out.println("队列长度: "+ quene.length);      //队列长度: 3
        System.out.println("数组长度: "+ quene.arr.length);  //数组长度: 5
        System.out.println("是否为空: "+quene.isEmpty());    //是否为空: false
        System.out.println("是否为满: "+quene.isFull());      //是否为满: false
        System.out.println("查看数据: "+quene.peek());        //查看数据: 1
        System.out.println("删除数据: "+quene.romove());      //删除数据: 1

        //删除后数组不变: [1, 2, 3, 0, 0],因为队列删除只是把 front队头的位置++,标记后面的数据,而不是把原数据剔除
        System.out.println("删除后队列: "+ Arrays.toString(quene.arr));
        System.out.println("查看数据: "+quene.peek());  //2

    }
}

2.循环列队

在插入数据的时候,判断end队尾是否到达数组length-1的位置,是则初始化end=-1;
在删除数据的时候,判断front是否到达数据length的位置,是则初始化front=0;
目的: 在循环删除队列数据后任然可以插入新的数据,非循环队列在删除完队列数据后插入数据会报数组越界异常

public class CycleQuene {
    //队列底层也是数组
    long[] arr;
    //队列长度
    int length;
    //队头
    int front;
    //队尾
    int end;

    //构造方法
    public CycleQuene(){
        arr = new long[10];
        length=0;
        front=0;
        end=-1;
    }
    public CycleQuene(int size){
        arr = new long[size];
        length=0;
        front=0;
        end=-1;
    }

    //1.添加数据,从队列尾插入
    public void insert(long value){
        //循环队列判断队尾是否到达最后
        if (end == arr.length-1){
            end=-1;
        }
        arr[++end] = value;
        length++;
    }

    //2.删除数据,从队头开始
    public long romove(){
        long value= arr[front++];
        //循环队列判断队头是否到达末尾
        if (front==arr.length){
            front=0;
        }
        length--;            //长度减减
        return value; //把第一个数据移除,队头就会++
    }

    //3.查看数据,从队头查看
    public long peek(){
        return arr[front];
    }

    //4.判断是否为空
    public boolean isEmpty(){
        return length==0;
    }

    //5.判断是否满了
    public boolean isFull(){
        return length == arr.length;
    }
}

public class Test01 {
    public static void main(String[] args) {

        CycleQuene quene = new CycleQuene(3);
        quene.insert(1);
        quene.insert(2);
        quene.insert(3);

        //循环移除所有数据
        while (!quene.isEmpty()){
            System.out.println(quene.romove()+",");  //1,2,3,
        }

        //插入数据
        quene.insert(8);
        System.out.println(quene.peek());  //8

    }
}