java实现队列

 队列(FIFO)

• 四个成员属性(MaxSize、font、rear、数组）
• 用头(font)尾(rear)指针来实现普通的队列，入队列rear变，出队列font变(注意font和rear指向哪里)
• 注意添加删除取出之前都要判空。

普通队列

package DataStructure;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: Mr.chen
 * @Date: 2022/10/09/10:14
 * @Description:用数组模拟队列
 */
public class queue {

    //队列的属性
    private int MaxSize;
    private int []arr ;
    private int font ;//指向开头,指向队列元素的前一个位置
    private int rear ;//指向末尾

    //创建队列的构造器
    public queue(int MaxSize){
        this.MaxSize=MaxSize;
        arr= new int[MaxSize];
        /*开始时都指向第一个元素之前*/
        font = -1;//指向队列第一个位置的前一个位置
        rear =-1;//开始跟font一样，但加元素后是直接指向最后一个元素
    }
    //判断是否为空
    public boolean isNull(){
    return rear ==font;
    }
    //判断队列是否已满
    public boolean isFull(){
        return rear ==MaxSize-1;//数组最大容量减一
    }
    //添加数据到队列
    public void addElem(int i){
        if(isFull()){
            System.out.println("队列已满，不能加入！");
            return ;
        }
        rear++;//先向后移，因为rear的开始是-1
        arr[rear]= i;//再赋值
        System.out.println("添加成功");
    }
    //数据出队列（删首元）
    public int outQueue(){
        if(isNull()){
        //为空返回-1，0都不对，只能抛出异常，因为返回的值是整形，可能返回-1，0等任意整数
            throw new RuntimeException("队列为空，取不出元素");
        }
        font++;//font后移，这里相当于是跳过元素，元素实际上还在
        return arr[font];
    }
    //得到首元素（不删首元）
    public int getElem(){
        if(isNull()){
        //为空返回-1，0都不对，只能抛出异常，因为返回的值是整形，可能返回-1，0等任意整数
            throw new RuntimeException("队列为空");
        }
        return arr[font+1];
    }
    //显示队列的所有数据
    public void showQueue(){
        if(isNull()){
            System.out.println("数组为空");
            return ;
        }
      for(int i = font+1;i<rear+1;i++){//注意范围
          System.out.println("a["+i+"]"+"="+arr[i]);
      }
    }
}

 普通队列测试

package DataStructure;

import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: Mr.chen
 * @Date: 2022/10/09/10:43
 * @Description:
 */
public class testQueue {
    public static void main(String[] args) {
        //创建队列
        queue q =new queue(3);
        boolean sign =true;

        while(sign){
            System.out.println("添加A 显示首员不删H 获得首元素G 显示所有S 退出E");
            Scanner scanner = new Scanner(System.in);
            char c = scanner.next().charAt(0);//接收一个字符
            switch (c){
                case 'A':
                    System.out.println("请输入一个数");
                    int num =scanner.nextInt();
                    q.addElem(num);
                    break;
                case 'H':
                    try{
                        int nums =q.getElem();//获取第一个元素
                        System.out.println("第一个元素为:"+nums);
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    break;
                case 'G':
                    try{
                        int nums =q.outQueue();
                        System.out.println("第一个元素为:"+nums+"，且删除成功！");
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    break;
                case 'S':
                    q.showQueue();
                    break;
                case 'E':
                    sign=false;
                    System.out.println("欢迎下次使用");
                    break;
                default:
                    System.out.println("输入错误请重新输入！");
            }
        }
    }
}

循环队列

为了取出的空间能够再次使用

思路：

• 调整font指向队列的第一个元素，arr[font]指向第一个元素，rear指向最后一个元素的后一个位置，空出一个空间作为一个约定，来判断队列是否满   初始值都为0
• 队列满时：（rear=maxsize+1）%maxsize =font  可以一直增长
• 队列为空： rear==font
• 队列中有效的数据的个数：（rear+maxsize-font)%maxsize;  括号内看作两部分相加 

难点：

有效个数取模是因为有两种情况，当rear>font,此时长度rear-font

当rear<font此时长度（0+rear）-（font+Size）

因此综合为（0+rear+maxsize-font)%maxsize;

package DataStructure;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: Mr.chen
 * @Date: 2022/10/09/16:29
 * @Description:环形队列，有一个数是空的
 */
public class circlequeue {
    //队列的属性
    private int MaxSize;//数组最大容量
    private int []arr ;//数组
    private int font ;//指向开头,指向队列元素的前一个位置
    private int rear ;//指向末尾

    //构造队列
    public circlequeue(int MaxSize){
        this.MaxSize=MaxSize;
        arr= new int[MaxSize];
        //都指向第一个元素
        font =0;
        rear =0;
    }
    //判断是否为空
    public boolean isNull(){
        return rear ==font;
    }
    //判断队列是否已满
    public boolean isFull(){
        return (rear+1)%MaxSize==font;  //取模是为了满足特殊条件（最后一个元素）
    }
    //添加数据到队列
    public void addElem(int i){
        if(isFull()){
            System.out.println("队列已满，不能加入！");
            return ;
        }
        arr[rear]= i;
        rear=(rear+1)%MaxSize;//尾指针后移
        System.out.println("添加成功");
    }
    //出队列
    public int outQueue(){
        //判断是否为空
        if(isNull()){
            throw new RuntimeException("队列为空，取不出元素");
        }
        //font是指向队列的第一个元素
        int temp = font;
        font = (font+1)%MaxSize;//font也会越界
        return arr[temp];//返回保存的font
    }
    //得到首元素
    public int getElem(){
        if(isNull()){
            throw new RuntimeException("队列为空");
        }
        return arr[font];
    }
    //显示队列的所有数据
    public void showQueue(){
        if(isNull()){
            System.out.println("数组为空");
            return ;
        }
        //从front开始遍历，遍历front+？
        //?为当前有效数据的个数
        for(int i = font;i<font+(rear+MaxSize-font)%MaxSize;i++){
            System.out.println("a["+i%MaxSize+"]"+"="+arr[i%MaxSize]);
        }
    }
}

循环队列测试

package DataStructure;

import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: Mr.chen
 * @Date: 2022/10/09/17:16
 * @Description:
 */
public class testCieclequeue {
    public static void main(String[] args) {
        //创建队列
        circlequeue q =new circlequeue(4);//实际上只有三个
        boolean sign =true;
        while(sign){
            System.out.println("添加A 显示首员不删H 获得首元素G 显示所有S 退出E");
            Scanner scanner = new Scanner(System.in);
            char c = scanner.next().charAt(0);//接收一个字符
            switch (c){
                case 'A':
                    System.out.println("请输入一个数");
                    int num =scanner.nextInt();
                    q.addElem(num);
                    break;
                case 'H':
                    try{
                        int nums =q.getElem();//获取第一个元素
                        System.out.println("第一个元素为:"+nums);
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    break;
                case 'G':
                    try{
                        int nums =q.outQueue();
                        System.out.println("第一个元素为:"+nums+"，且删除成功！");
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    break;
                case 'S':
                    q.showQueue();
                    break;
                case 'E':
                    sign=false;
                    System.out.println("欢迎下次使用");
                    break;
                default:
                    System.out.println("输入错误请重新输入！");
            }
        }
    }
}