Comment implémenter la file d'attente via un tableau en Java

La méthode d'implémentation du tableau de la file d'attente est la suivante :

1 La file d'attente elle-même est une liste ordonnée. La structure est utilisée pour stocker les données de la file d'attente, la déclaration du tableau de file d'attente est comme indiqué ci-dessus, où maxSize est la capacité maximale de la file d'attente

2 L'entrée et la sortie de la file d'attente sont traitées depuis le début ; et l'arrière se termine respectivement, donc deux variables, avant et arrière, sont nécessaires pour enregistrer respectivement l'avant et l'arrière de la file d'attente, qui changera avec la saisie des données

3 La file d'attente où. les données sont stockées dans une "file d'attente" :

①, vide : arrière==avant

② La file d'attente est pleine : arrière=maxSize-1; Lorsque le pointeur de queue arrière

Partage du didacticiel vidéo :

tutoriel vidéo Java

Le code d'implémentation spécifique est le suivant :

(1), déterminez si la file d'attente est pleine

(2) Déterminez si la file d'attente est vide

(3) Ajoutez des données à la file d'attente

(4) Récupérez les données de la file d'attente et retirez-les de la file d'attente

;

(5 ), afficher les données actuelles de la file d'attente ;

(6), afficher les données d'en-tête de la file d'attente, veillez à ne pas supprimer les données

L'exemple est le suivant ; suit :

package com.ycx.queue;
import java.util.Scanner;

public class ArrayQueueDemo {
    public static void main(String[] args) {
        //测试
        //创建一个队列
        ArrayQueue queue = new ArrayQueue(3);
        char key = ' ';//接受用户输入
        Scanner input = new Scanner(System.in);
        boolean flag = true; //控制循环 默认死循环

        //输出菜单
        while (flag){
            System.out.println("s(show),显示队列");
            System.out.println("e(exit),退出队列");
            System.out.println("a(add),添加数据到队列");
            System.out.println("g(get),从队列取出数据");
            System.out.println("h(head),查看队列头的数据");

            key=input.next().charAt(0);//接受收一个字符
            switch (key){
                case 's':
                    queue.showQueue();
                    break;
                case 'a':
                    System.out.println("输一个数");
                    int val=input.nextInt();
                    queue.addQueue(val);
                    break;
                case 'g':   //取出数据  因为方法里面抛出了异常 所以这里需要捕获
                    try{
                        int res=queue.getQueue();
                        System.out.printf("取出的数据为%d\n",res);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                     try{
                         int res=queue.headQueue();
                         System.out.printf("队列头的数据为%d\n",res);
                     }catch (Exception e){
                         System.out.println(e.getMessage());
                     }
                     break;
                case 'e':    //退出程序
                    input.close();//关闭
                    flag=false;
                    break;

                    default:
                        break;
            }
        }
        System.out.println("程序退出");
    }
}

//一、使用数组模拟队列-编写一个ArrayQueue类

class ArrayQueue{
    private  int maxSize;//表示数组的最大容量
    private  int front; //队列头
    private  int rear; // 队列尾
    private  int[] arr; // 该数组用于存放数据，模拟队列


    //创建队列的构造器
    public ArrayQueue(int arrMaxsize){
        maxSize=arrMaxsize;
        arr = new int[maxSize];// 初始化数组
        front=-1;//指向队列头部，分析出front是指向队列头的前一个位置 有效数据的位置
        rear=-1;//指向队列尾，指向队列尾的数据（即就是队列最后一个位置 ）
    }

    //1.判断队列是否满
    public boolean isFull(){
        return rear==maxSize-1;//因为rear是从-1开始的（如果不理解就看笔记上的图）
    }

    //2.判断队列是否为空
    public boolean isEmpty(){
        return rear==front;
    }

    //3.添加数据到队列中
    public void addQueue(int n){
        //判断队列是否为满
        if(isFull()){
            System.out.println("队列已满，不能加入数据");
        }
        rear++;//rear 后移
        arr[rear]=n; //也可以直接写成 arr[++rear]：rear先加再取值
    }

    //4.获取队列的数据，出队列
    public  int getQueue(){
        if(isEmpty()){
            throw new RuntimeException("队列空，不能取数据");
        }
        front++; //front 后移 因为front指向的是前一个元素（front=-1）
        return arr[front];
    }

    //5.显示当前队列数据
    public void showQueue() {
         //遍历
         if(isEmpty()){
             System.out.println("当前队列为空");
             return;
         }
        for (int i = 0; i <arr.length ; i++) {
            System.out.printf("arr[%d]=%d\n",i,arr[i]); //格式化输出
        }
    }

    //6.显示队列的头数据，注意不是取出数据
    public int headQueue(){
        if(isEmpty()){
            throw new RuntimeException("队列为空");
        }
        return arr[front+1]; //注意：front需要加1
    }
}

Analyse des problèmes et optimisation

(1) Inconvénients : le tableau ne peut être utilisé qu'une seule fois et la réutilisation du code ne peut pas être réalisée.

(Lorsque tous les éléments du tableau sont supprimés, le tableau sera vide, mais les éléments ne peuvent pas être ajoutés dans le tableau)

(2) Optimisation : il peut être modifié en un tableau circulaire ( reste pris) .

Articles et tutoriels connexes recommandés :

Démarrage rapide avec Java

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!