1๏ธโฃ Circular Queue(์ํ ํ)๋ฅผ ๋ฐฐ์ด๋ก ๊ตฌํ์ rear๋ฅผ -1์ผ๋ก ์ค์ ํ์ง ์๋ ์ด์ .
Java์์ ์ํ ํ๋ฅผ ๊ตฌํํ ๋ โrearโ ์ ์ด๊ธฐ๊ฐ์ โ-1โ ๋ก ์ค์ ํ์ง ์๋ ์ด์ ๋ ์ฌ๋ฌ ๊ฐ์ง๊ฐ ์์ต๋๋ค.
์ฃผ์ ์ด์ ๋ ํ์ ์ธ๋ฑ์ฑ์ ๋จ์ํํ๊ณ , ๋ ผ๋ฆฌ์ ์ธ ํ๋ฆ์ ์ผ๊ด๋๊ฒ ์ ์งํ๊ธฐ ์ํจ์ ๋๋ค.
๋ค์์ ๊ทธ ์ด์ ๋ฅผ ์์ธํ ์ค๋ช ํ ๊ฒ์ ๋๋ค.
1๏ธโฃ ์ธ๋ฑ์ค์ ์ผ๊ด์ฑ ์ ์ง.
-
โrearโ ๋ฅผ โ0โ ์ผ๋ก ์ด๊ธฐํํ๋ฉด ํ์ ์ธ๋ฑ์ฑ์ด ๋จ์ํด์ง๋๋ค.
- โrearโ ์ โfrontโ ๋ชจ๋ 0์์ ์์ํ์ฌ, ํ์ ํฌ๊ธฐ๋ฅผ โcapacityโ ๋ก ๋๋ ๋๋จธ์ง๋ฅผ ์ฌ์ฉํ์ฌ ์ธ๋ฑ์ค๋ฅผ ์ํ์ํต๋๋ค.
- ์ด๋ ๋ชจ๋๋ก ์ฐ์ฐ์ ์ฌ์ฉํ์ฌ ์ธ๋ฑ์ค๋ฅผ ๊ด๋ฆฌํ๋ ๋ฐ ์์ด ํธ๋ฆฌํฉ๋๋ค.
-
โrearโ ๋ฅผ โ-1โ ๋ก ์ค์ ํ ๊ฒฝ์ฐ, ์์๋ฅผ ์ถ๊ฐํ ๋๋ง๋ค ๋งค๋ฒ โrearโ ๋ฅผ โ0โ ์ผ๋ก ์กฐ์ ํ๋ ํน๋ณํ ์ฒ๋ฆฌ๊ฐ ํ์ํ๊ฒ ๋ฉ๋๋ค.
- ์ด๋ ์ฝ๋์ ๋ณต์ก์ฑ์ ์ฆ๊ฐ์ํค๊ณ ์ค์์ ๊ฐ๋ฅ์ฑ์ ๋์ ๋๋ค.
2๏ธโฃ ์ฝ๋์ ๋จ์ํ.
-
โrearโ ๋ฅผ โ0โ ์ผ๋ก ์ด๊ธฐํํ๋ฉด ์ด๊ธฐ ์ํ์ ์์ ์ถ๊ฐ, ์ญ์ ์ ๋ณ๋์ ์กฐ๊ฑด ๊ฒ์ฌ๋ฅผ ์ค์ผ ์ ์์ต๋๋ค.
- ์๋ฅผ ๋ค์ด โrearโ ๊ฐ โ-1โ ์ธ์ง ํ์ธํ๋ ์ถ๊ฐ ์กฐ๊ฑด๋ฌธ์ ํผํ ์ ์์ต๋๋ค.
- โ0โ ๋ถํฐ ์์ํ๋ฉด โenqueueโ ์ โdequeueโ ์ฐ์ฐ์์ โrearโ ์ โfrontโ ์ธ๋ฑ์ค์ ์ฆ๊ฐ์ ๊ฐ์๊ฐ ์ผ๊ด๋๊ฒ ์ฒ๋ฆฌ๋ฉ๋๋ค.
3๏ธโฃ ํธ๋ฆฌํ ์ด๊ธฐ ์ํ ์ฒ๋ฆฌ.
-
โrearโ ๋ฅผ โ0โ ์ผ๋ก ์ค์ ํ๋ฉด ์ด๊ธฐ ์ํ์์ ํ๊ฐ ๋น์ด ์๋์ง ํ์ธํ๋ ๊ฒ์ด ๋ ์ง๊ด์ ์
๋๋ค.
- ์๋ฅผ ๋ค์ด โisEmptyโ ๋ฉ์๋๋ ๋จ์ํ โsizeโ ๋ณ์๋ฅผ ํ์ธํ์ฌ ํ๊ฐ ๋น์ด ์๋์ง ํ์ธํ ์ ์์ต๋๋ค. โrearโ ๊ฐ โ-1โ ์ด๋ฉด ์ถ๊ฐ์ ์ธ ์ํ ๊ฒ์ฌ๊ฐ ํ์ํ ์ ์์ต๋๋ค.
2๏ธโฃ ์์ ์ฝ๋.
๋ค์์ โrearโ ์ ์ด๊ธฐ๊ฐ์ โ0โ ์ผ๋ก ์ค์ ํ๋ ์ํ ํ์ ์ฝ๋์ ๋๋ค.
public class CircularQueue {
private int[] queue;
private int front;
private int rear;
private int size;
private int capacity;
public CircularQueue(int capacity) {
this.capacity = capacity;
this.queue = new int[capacity];
this.front = 0;
this.rear = 0;
this.size = 0;
}
public boolean isFull() {
return size == capacity;
}
public boolean isEmpty() {
return size == 0;
}
public void enqueue(int data) {
if (isFull()) {
throw new RuntimeException("Queue is full");
}
queue[rear] = data;
rear = (rear + 1) % capacity;
size++;
}
public int dequeue() {
if (isEmpty()) {
throw new RuntimeException("Queue is empty");
}
int data = queue[front];
front = (front + 1) % capacity;
size--;
return data;
}
public int peek() {
if (isEmpty()) {
throw new RuntimeException("Queue is empty");
}
return queue[front];
}
public int getSize() {
return size;
}
public void displayCircularQueue() {
if (isEmpty()) {
throw new RuntimeException("Queue is empty");
}
int i = front;
int count = 0;
while (count < size) {
System.out.print("["+ queue[i] + "]");
i = (i + 1) % capacity;
count++;
}
System.out.println();
}
public int getMiddle() {
if (isEmpty()) {
throw new RuntimeException("Queue is empty");
}
int middleIndex = (front + size / 2) % capacity;
return queue[middleIndex];
}
}
// Main
public class Main {
public static void main(String[] args) {
CircularQueue circularQueue = new CircularQueue(5);
CircularQueue.enqueue(10);
CircularQueue.enqueue(20);
CircularQueue.enqueue(30);
CircularQueue.enqueue(40);
CircularQueue.enqueue(50);
CircularQueue.displayCircularQueue();
System.out.println();
System.out.println("Middle element: " + circularQueue.getMiddle());
circularQueue.displayCircularQueue();
System.out.println();
System.out.println("===DEQUEU===");
System.out.println(circularQueue.dequeue());
circularQueue.enqueue(60);
circularQueue.displayCircularQueue();
System.out.println();
System.out.println("Middle element: " + circularQueue.getMiddle());
circularQueue.displayCircularQueue();
}
}
// === ์ถ๋ ฅ ===
/*
[10][20][30][40][50]
Middle element: 30
[10][20][30][40][50]
===DEQUEU===
10
[20][30][40][50][60]
Middle element: 40
[20][30][40][50][60]
*/
์ ์ฝ๋์์ โrearโ ๋ฅผ 0์ผ๋ก ์ค์ ํจ์ผ๋ก์จ ํ์ ์ธ๋ฑ์ฑ๊ณผ ์ํ ์ฒ๋ฆฌ๊ฐ ๋จ์ํด์ง๊ณ , ์ดํดํ๊ธฐ ์ฌ์์ง๋๋ค.
์ด๋ ์ฝ๋์ ๊ฐ๋ ์ฑ๊ณผ ์ ์ง๋ณด์์ฑ์ ๋์ด๋ ๋ฐ ๋์์ด ๋ฉ๋๋ค.