자바 기반 배열 시 뮬 레이 션 순환 대기 열

1.대열 안내
대기 열 은'선 입 선 출'의 원칙 에 따라 대기 열 에 저 장 된 데 이 터 를 먼저 꺼 내 고 나중에 저 장 된 데 이 터 를 꺼 내 는 질서 있 는 목록 입 니 다.
대기 열 에는 두 가지 저장 표시 가 있 는데,순서 표시 와 체인 표시 가 있다.순 서 는 배열 로 이 루어 질 수 있다 는 것 을 나타 낸다.
2.배열 시 뮬 레이 션 대기 열
배열 로 대기 열 을 모 의 할 때 두 개의 값 front=0,rear=0 을 설정 합 니 다.front 는 대기 열의 첫 번 째 데이터 가 있 는 위 치 를 표시 하고,rear 는 마지막 데이터 의 다음 위 치 를 표시 합 니 다.
배열 대기 열 에 데 이 터 를 삽입 할 때(입 대)꼬리 부분 에서 삽입 합 니 다.즉,array[rear]=value,동시에 rear 뒤로 이동 합 니 다.rear+.데 이 터 를 꺼 낼 때(팀 에서)머리 에서 데 이 터 를 꺼 냅 니 다.value=array[front]와 함께 front 를 뒤로 이동 합 니 다.
front=0,rear=maxSize(배열 의 최대 길이),대기 열 이 가득 차 서 데 이 터 를 더 이상 저장 할 수 없습니다.
이때 팀 작업 을 수행 하면 저장 할 수 있 는 공간 이 있 지만 데 이 터 를 계속 삽입 하면 넘 치 는 현상 이 발생 할 수 있 습 니 다.즉,배열 이 경 계 를 넘 어서 프로그램 이 불법 으로 작 동 하 는 오류 가 발생 할 수 있 습 니 다.그러나 실제 공간 이 꽉 차지 않 았 기 때문에 이런 현상 을'가짜 넘 침'이 라 고 부른다.이것 은'팀 의 후미 가 팀 에 들 어가 고 팀 의 선두 가 팀 에서 나온다'는 제한 조작 으로 인해 생 긴 것 이다.
어떻게 가짜 유출 문 제 를 해결 합 니까?
정 답 은 순환 대열 이다.
3.배열 시 뮬 레이 션 순환 대기 열
순서 대기 열 을 링 공간 으로 바 꿉 니 다.front,rear 와 대기 열 요소 간 의 관 계 는 변 하지 않 습 니 다.순환 대기 열 에서 만 front,rear 가 순서대로 1 을 추가 하 는 작업 은'모드'연산 으로 이 루어 집 니 다.
모델 링 을 통 해 front,rear 는 순서 표 공간 에서 머리 와 꼬리 를 연결 하 는 방식 으로'순환'하여 이동 할 수 있다.
원소 출현 후 front=(front+1)%maxSize;
원소 가 입 대 된 후,rear=(rear+1)%maxSize.
(max Size 는 배열 대기 열의 최대 길이 입 니 다)
예 를 들 어 대기 열의 최대 길 이 는 4 이 고 rear=3 일 때 데 이 터 를 저장 합 니 다.array[3]=value,rear 후 한 자 리 를 옮 깁 니 다.모드 연산 이 없 으 면 rear=4 입 니 다.이때 데 이 터 를 계속 삽입 하고 array[4]경 계 를 넘 습 니 다.
모드 연산 을 진행 하면 rear=(rear+1)%max Size,이때 rear=0,rear 는 다시 0 의 위치 로 돌 아 옵 니 다.이러한 연산 은 rear 의 값 을 0,1,2,3 사이 에 순환 시 킵 니 다.
프론트 의 값 은 같다.
이렇게 많은 글 자 를 썼 으 니 차라리 코드 를 보 는 것 이 더 이해 하기 쉬 울 것 같다.
4.코드 구현
배열 시 뮬 레이 션 순환 대기 열

package com.ArrayQueue;

import java.util.Scanner;

public class CircleArrayQueueDemo {
    public static void main(String args[]){
        int maxSize = 4;
        CircleArrayQueue queue = new CircleArrayQueue(maxSize);
        Scanner scanner = new Scanner(System.in);
        char key;
        boolean loop = true;
        while (loop) {
            //         ，       
            System.out.println("a(add):      ");
            System.out.println("g(get):      ");
            System.out.println("h(head):      ");
            System.out.println("s(show):      ");
            System.out.println("q(quit):    ");
            //         ，         maxSize-1
            System.out.printf("(        ：%d)
",maxSize-1);
            key = scanner.next().charAt(0);//      
            try {
                switch (key) {
                    case 'a':
                        System.out.println("      ：");
                        int value = scanner.nextInt();
                        queue.addQueue(value);
                        System.out.println("      。");
                        break;
                    case 'g':
                        System.out.printf("      ：%d
", queue.getQueue());
                        break;
                    case 'h':
                        queue.headQueue();
                        break;
                    case 's':
                        queue.showQueue();
                        break;
                    case 'q':
                        scanner.close();
                        loop = false;
                        System.out.println("     。");
                        break;
                    default:
                        break;
                }
            } catch (RuntimeException e) {
                System.out.println(e.getMessage());
            }
        }
    }
}
/**
 *        
 *         
 */
class CircleArrayQueue{
    private int maxSize;
    private int front;//         
    private int rear;//               
    private int arr[];//       

    //   ，         
    public CircleArrayQueue(int size){
        maxSize = size;
        front = 0;
        rear = 0;
        //         maxSize，          maxSize-1
        arr = new int[maxSize];
    }
    //    ：front == rear
    public boolean isEmpty(){
        return front == rear;
    }
    //    ：(rear+1)%maxSize == front
    public boolean isFull(){
        return (rear+1)%maxSize == front;
    }
    //    ，  
    public void addQueue(int n){
        //  
        checkFull();
        arr[rear] = n;
        rear = (rear+1)%maxSize;
    }
    //    ，  
    public int getQueue(){
        //  
        checkEmpty();
        int value = arr[front];
        front = (front+1)%maxSize;
        return value;
    }
    //         
    public int size(){
        return (rear-front+maxSize)%maxSize;
    }
    //         
    public void showQueue(){
        //  
        checkEmpty();
        for(int i=front;i<front+size();i++){
            System.out.printf("arr[%d]=%d
",i%maxSize,arr[i%maxSize]);
        }
        System.out.printf("  front=%d,rear=%d
",front,rear);
    }
    //            ，   front   
    public void headQueue(){
        //  
        checkEmpty();
        System.out.printf("     ：%d
",arr[front]);
    }
    //        ，    front，rear  ，    
    public void checkEmpty(){
        if (isEmpty()) {
            System.out.printf("  front=%d,rear=%d
",front,rear);
            throw new RuntimeException("    ,     ");
        }
    }
    //       ，    front，rear  ，    
    public void checkFull(){
        if(isFull()){
            System.out.printf("  front=%d,rear=%d
",front,rear);
            throw new RuntimeException("    ，      ");
        }
    }
}

운행 결과




자바 기반 배열 시 뮬 레이 션 순환 대기 열 에 관 한 이 글 은 여기까지 소개 되 었 습 니 다.더 많은 자바 배열 시 뮬 레이 션 순환 대기 열 내용 은 우리 의 이전 글 을 검색 하거나 아래 의 관련 글 을 계속 찾 아 보 세 요.앞으로 많은 지원 바 랍 니 다!