队列实现及其操作java版

队列实现及其操作java版

静态队列–循环队列

未完成，出现无法出队及最后一个元素无法显示的bug

package 数据结构.队列;

/*
    静态队列通常都是循环队列——数组前面删掉的多了，闲置空间就无法利用在队列中，使得队列空间越用越少
    1.什么是循环队列——数组中两个指针内区间域作为队列域，循环的是指针，
    2.循环队列结构——有限数组，头指针（int），尾指针（int）
    3.头尾指针不同场景下的含义：
        (1)初始化：front=rear=0
        (2)队列非空：front指向队列第一个元素；rear指向队列最后一个有效元素的下一个元素
        (3)队列为空：front=rear,但不一定为0，因为是循环队列，数组中两个指针内区间域作为队列域
    4.入队操作
        (1)将值插入到rear所在位置
        (2)rear=(rear+1)%数组的长度——取余操作，使队列尾指针可以循环（一直在队列内）
    5.出队操作
        (1)front=(front+1)%数组的长度——取余操作，使队列头指针可以循环（一直在队列内），出队节点的元素不用管，后面会自动覆盖赋值
    6.判断是否为空
        (1)front==rear,则队列一定为空
    7.判断是否为满
        前置知识：front可能比rear大，也可能小，也可能相等——因为指针循环
        判断方法：两种方式
        (1)增加一个queue_len变量,监控队列空间
        (2)如果r和f的值紧挨着，则队列已满
           判断条件：（r+1）%数组长度==f,则满
    //未完成，出现无法出队及最后一个元素无法显示的bug
 */

class Queue_arr {
    private int[] arr;  //构造队列体
    private int front;  //构造头指针——指向队列第一个数
    private int rear;  //构造尾指针——指向队列最后一个数

    Queue_arr(int queue_max) {
        this.arr = new int[queue_max];
        this.front = 0;//初始化，头指针指向数组第一个空间
        this.rear = 0;//初始化，尾指针指向数组第一个空间
    }

    //入队
    void In_queue(int x) {
        //先判断队列是否已满
        if (front != (rear + 1) % arr.length) {
            arr[rear] = x;
            rear = (rear + 1) % arr.length;
        } else {
            System.out.println("队列已满");
        }
    }

    //出队
    int Out_queue() {
        //先判断队列是否不为空
        if (front == rear) {
            int res = arr[front];
            front = (front + 1) % arr.length;
            return res;
        } else {
            System.out.println("队列为空");
            return -1;
        }
    }

    //打印
    void print_queue() {
        //三种情况：front<rear——未出现循环,front==rear——队列为空,front>rear——出现循环
        //1.front<rear——依次打印出队列值
        if (front < rear) {
            System.out.print("队列数据为：");
            for (int i = front; i < rear; i++) {//注意端点取值
                System.out.print(arr[i]);
                System.out.print(' ');
            }
            System.out.println();
        //2.front==rear——为空？
        } else if (front == rear) {
            System.out.println("队列为空");
        //3.front > rear——有循环，分开遍历
        } else if (front > rear) {
            //先遍历front到末端的值
            System.out.print("队列数据为：");
            for (int i = front; i < arr.length; i++) {//注意端点取值
                System.out.print(arr[i]);
                System.out.print(' ');
            }
            //在遍历rear到front（不含）的值
            for (int i = rear; i < front; i++) {//注意端点取值
                System.out.print(arr[i]);
                System.out.print(' ');
            }
            System.out.println();
        }

    }

}

public class 静态队列 {
    public static void main(String[] args) {
        Queue_arr A = new Queue_arr(3);
        A.In_queue(10);
        A.In_queue(50);
        A.In_queue(30);
        A.print_queue();
        A.In_queue(10);
        int x = A.Out_queue();
        System.out.println(x);
    }
}

链式队列

已实现队列功能

package 数据结构.队列;

/*
    思路：实现先进先出，函数：入队、出队
         从尾部入队，从头部出队
         节点设置：单链表节点
         节点外指针：头指针-front，尾指针-rear
         出队：头指针下移，返回首节点
         入队：尾指针下移，指向新节点
 */


//构造节点
class link {
    int content;
    link next;

    //构造器
    link(int content) {
        this.content = content;
        this.next = null;//这句可以不用写，没有赋值时next本身就是null
    }
}

class Queue{
    //指针设置
    link front;//头指针
    link rear;//尾指针

    //初始化,无需头结点-头指针代替头结点功能，不过要在队列为空入队时要先将头指针尾指针先指向新节点
    Queue(){
        front = null;
        rear = null;
    }

    //入队-修改尾节点，修改尾指针
    void In_Queue(int x){
        //创建新节点
        link new_link = new link(x);

        //判断是否为空队列，是则将头指针尾指针先指向新节点
        if (front == null) {
            front = new_link;
            rear = new_link;
        }else {
            //修改尾节点
            rear.next = new_link;
            //修改尾指针
            rear = new_link;
        }


    }

    //出队-头指针下移，返回首节点
    int Out_Queue(){
        //先判断有无节点
        if (front != null) {
            //缓存首节点内容
            int l = front.content;
            //头指针下移
            front = front.next;
            //返回首节点内容
            return l;
        }else {
            System.out.println("队列为空");
            return -1;
        }

    }
    //显示
    void print_Queue(){
        //定义遍历指针
        link team = front;
        //循环取数据打印,当遍历指针为空时结束循环
        System.out.print("队列中数据为：");
        while (team!=null){
            System.out.print(team.content);
            System.out.print(" ");
            team = team.next;
        }
        System.out.println();
        return;
    }
}

public class 链式队列 {
    public static void main(String[] args) {
        //新建队列
        Queue queue = new Queue();
        //入队
        queue.In_Queue(10);
        //显示
        queue.print_Queue();
        //入队
        queue.In_Queue(20);
        //显示
        queue.print_Queue();
        //出队
        int i = queue.Out_Queue();
        System.out.println(i);
        queue.print_Queue();
    }
}