From fe4f540812c1c09af958138facc67709237ecb73 Mon Sep 17 00:00:00 2001 From: songyc macbook Date: Sat, 16 Aug 2025 00:10:11 +0900 Subject: [PATCH] DS study : queue --- code_study/data_structure/DS_queue.c | 156 +++++++++++++++++++++++ code_study/data_structure/DS_queue.java | 120 +++++++++++++++++ code_study/data_structure/DS_queue.py | 96 ++++++++++++++ code_study/data_structure/DS_queue.swift | 117 +++++++++++++++++ code_study/data_structure/DS_queue.ts | 109 ++++++++++++++++ 5 files changed, 598 insertions(+) create mode 100644 code_study/data_structure/DS_queue.c create mode 100644 code_study/data_structure/DS_queue.java create mode 100644 code_study/data_structure/DS_queue.py create mode 100644 code_study/data_structure/DS_queue.swift create mode 100644 code_study/data_structure/DS_queue.ts diff --git a/code_study/data_structure/DS_queue.c b/code_study/data_structure/DS_queue.c new file mode 100644 index 0000000..ecbc964 --- /dev/null +++ b/code_study/data_structure/DS_queue.c @@ -0,0 +1,156 @@ +#include +#include +#include +#include + +typedef struct C_Queue C_Queue; + +void _enqueue(C_Queue *q, int value); +int _dequeue(C_Queue *q); +bool _isEmpty(C_Queue *q); +bool _isFull(C_Queue *q); +void _info(C_Queue *q); +void _destroyQ(C_Queue *q); + +struct C_Queue{ + int *data; + int front, rear, size; + + bool (*isEmpty)(C_Queue *q); + bool (*isFull)(C_Queue *q); + void (*enqueue)(C_Queue *q, int value); + int (*dequeue)(C_Queue *q); + void (*info)(C_Queue *q); + void (*destroyQ)(C_Queue *q); +}; + +C_Queue creatQueue(int capacity){ + C_Queue q; + q.front = -1; + q.rear = -1; + q.size = capacity; + q.data = (int*)malloc(sizeof(int)*capacity); + + q.enqueue = _enqueue; + q.dequeue = _dequeue; + q.info = _info; + q.isEmpty = _isEmpty; + q.isFull = _isFull; + q.destroyQ = _destroyQ; + + return q; +} + +int opcode(char *input); + +int main(){ + printf("생성하려는 원형큐의 용량을 입력해주세요. : "); + int capacity; + scanf("%d",&capacity); + + C_Queue q = creatQueue(capacity); + bool exit_flag = true; + while(exit_flag){ + printf("+++++++++++++++++++++++++++++++++++++++++++++++++\n"); + printf("명령어 목록 : enqueue | dequeue | info | exit\n"); + printf("명령어를 입력해주세요. : "); + char input[10]; + scanf("%s",input); + switch (opcode(input)) + { + case 1: + if(q.isFull(&q)) { + printf("큐가 꽉차있어서 입력할 수 없습니다.\n"); + } + else{ + printf("넣을 값을 입력해주세요. : "); + int num; + scanf("%d",&num); + q.enqueue(&q, num); + } + break; + case 2: + if(q.isEmpty(&q)){ + printf("큐가 비어있어서 값을 꺼낼 수가 없습니다.\n"); + } + else{ + printf("추출값 : %d\n",q.dequeue(&q)); + } + break; + case 3: + q.info(&q); + break; + case 4: + exit_flag = false; + printf("종료합니다\n"); + break; + default: + printf("명령어를 잘못 입력했습니다. 다시 입력해주세요.\n"); + break; + } + } + q.destroyQ(&q); +} + +int opcode(char *input){ + if(!strcmp(input, "enqueue")) return 1; + if(!strcmp(input, "dequeue")) return 2; + if(!strcmp(input, "info")) return 3; + if(!strcmp(input, "exit")) return 4; + return -1; +} + +bool _isEmpty(C_Queue *q){ + return q->front == -1; +} + +bool _isFull(C_Queue *q){ + return ((q->rear)+1)%(q->size) == q->front; +} + +void _enqueue(C_Queue *q, int value){ + if(q->isFull(q)){ + return; + } + if(q->isEmpty(q)){ + q->front = 0; + } + q->rear = ((q->rear)+1)%(q->size); + q->data[q->rear] = value; +} + +int _dequeue(C_Queue *q){ + if(q->isEmpty(q)){ + return -1; + } + int value = q->data[q->front]; + if(q->front == q->rear){ + q->front = -1; + q->rear = -1; + } + else{ + q->front = ((q->front)+1)%q->size; + } + + return value; +} + +void _info(C_Queue *q){ + if(q->isEmpty(q)){ + printf("큐가 비어있습니다.\n"); + } + else{ + printf("큐 목록: "); + int i = q->front; + while(true){ + printf("%d ",q->data[i]); + if(i==q->rear) break; + i = (i+1)%q->size; + } + printf("\n"); + } +} + +void _destroyQ(C_Queue *q){ + free(q->data); +} \ No newline at end of file diff --git a/code_study/data_structure/DS_queue.java b/code_study/data_structure/DS_queue.java new file mode 100644 index 0000000..9dddbd6 --- /dev/null +++ b/code_study/data_structure/DS_queue.java @@ -0,0 +1,120 @@ +import java.security.cert.TrustAnchor; +import java.util.*; + +class Cir_Queue { + private int[] data; + private int front, rear, size; + + Cir_Queue(int size){ + this.data = new int[size]; + this.front = -1; + this.rear = -1; + this.size = size; + } + + public boolean isEmpty(){ + return this.front == -1; + } + + public boolean isFull(){ + return (this.rear + 1)%(this.size) == front; + } + + public void enqueue(int value){ + if(this.isFull()){ + System.out.println("Queue is Full!"); + return; + } + if(this.isEmpty()){ + this.front = 0; + } + this.rear = (this.rear + 1)%(this.size); + this.data[rear] = value; + } + + public int dequeue(){ + if(this.isEmpty()){ + System.out.println("Queue is Empty!"); + return -1; + } + int value = this.data[this.front]; + if(this.rear == this.front){ + this.rear = -1; + this.front = -1; + } + else { + this.front = (this.front + 1)%this.size; + } + + return value; + } + + public int peek(){ + if(this.isEmpty()){ + System.out.println("Queue is Empty!"); + return -1; + } + return this.data[this.front]; + } + + public void info(){ + if(this.isEmpty()){ + System.out.println("큐가 비어있습니다."); + return; + } + + StringBuilder result = new StringBuilder("Queue List : "); + int i = this.front; + while(true){ + result.append(this.data[i] + " "); + if(i==this.rear) break; + i = (i + 1)%this.size; + } + System.out.println(result); + } +} + +public class DS_queue { + public static void main(String[] args) { + Scanner sc= new Scanner(System.in); + System.out.println("큐의 사이즈를 입력해주세요."); + int size = Integer.parseInt(sc.nextLine()); + Cir_Queue q = new Cir_Queue(size); + + boolean exitFlag = true; + while(exitFlag){ + System.out.println("명령어 목록 : enque [value] | deque | peek | info | exit"); + String[] opcode = sc.nextLine().split(" "); + switch (opcode[0]) { + case "enque": + q.enqueue(Integer.parseInt(opcode[1])); + break; + case "deque": + if(q.isEmpty()){ + q.dequeue(); + break; + } + System.out.println(q.dequeue()); + break; + case "peek": + if(q.isEmpty()){ + q.peek(); + break; + } + System.out.println(q.peek()); + break; + case "info": + q.info(); + break; + case "exit": + exitFlag = false; + System.out.println("Exit!!"); + break; + default: + System.out.println("제대로 입력해주세요."); + break; + } + } + sc.close(); + } +} diff --git a/code_study/data_structure/DS_queue.py b/code_study/data_structure/DS_queue.py new file mode 100644 index 0000000..510c557 --- /dev/null +++ b/code_study/data_structure/DS_queue.py @@ -0,0 +1,96 @@ +class queue : + + def __init__(self,size) : + self.__size = size + self.__data = [0]*size + self.__front = -1 + self.__rear = -1 + + def isEmpty(self) : + return self.__front == -1 + + def isFull(self) : + return (self.__rear + 1)%(self.__size) == self.__front + + def enqueue(self, value) : + if self.isFull() : + print("Queue is Full!!") + return + + if self.isEmpty() : + self.__front = 0 + + self.__rear = (self.__rear + 1) % self.__size + self.__data[self.__rear] = value + print("삽입 완료") + + def dequeue(self) : + if self.isEmpty() : + print("Queue is Empty!") + return -1 + + value = self.__data[self.__front] + + if self.__front == self.__rear : + self.__front = -1 + self.__rear = -1 + else : + self.__front = (self.__front + 1) % self.__size + + print(value) + + return value + + def peek(self) : + if self.isEmpty() : + print("Queue is Empty!") + return -1 + + value = self.__data[self.__front] + + print(value) + + return value + + def info(self) : + if self.isEmpty() : + print("Queue is Empty!, Max Size is : {0}".format(self.__size)) + return + + i = self.__front + result = "Queue List : [ " + while True: + result += str(self.__data[i]) + if i == self.__rear : + result += " ]" + break + + result += ", " + i = (i + 1) % self.__size + + print("Max Size is : {0}".format(self.__size)) + print(result) + +q = queue(int(input("원형큐의 최대사이즈를 입력해주세요 : "))) + +endFlag = True + +while endFlag : + opcode = input("명령어 목록 : enqueue [num] | dequeue | peek | info | exit\n") + + if "enqueue" in opcode : + if opcode.split()[0] != "enqueue" : + print("제대로 입력해주세요 enqueue와 정수를 입력받습니다.") + continue + q.enqueue(int(opcode.split()[1])) + elif opcode == "dequeue" : + q.dequeue() + elif opcode == "peek" : + q.peek() + elif opcode == "info" : + q.info() + elif opcode == "exit" : + endFlag = False + print("Exit") + else : + print("제대로 입력해주세요") \ No newline at end of file diff --git a/code_study/data_structure/DS_queue.swift b/code_study/data_structure/DS_queue.swift new file mode 100644 index 0000000..3bb7e54 --- /dev/null +++ b/code_study/data_structure/DS_queue.swift @@ -0,0 +1,117 @@ +class CircularQueue { + private var data: [Int] + private var front, rear, size : Int + + init(size: Int){ + self.front = -1 + self.rear = -1 + self.size = size + self.data = Array(repeating: 0, count: size) + } + + func isEmpty() -> Bool { + return self.front == -1 + } + + func isFull() -> Bool { + return (self.rear + 1)%self.size == self.front + } + + func info(){ + if self.isEmpty(){ + print("Empty!") + return + } + var i: Int = self.front + while true { + print("\(self.data[i]) ",terminator: " ") + if i == self.rear { + print() + break + } + i = (i+1)%self.size + } + } + + func enqueue(to value: Int){ + if self.isFull() { + print("Full!!!") + return + } + + if self.isEmpty(){ + self.front = 0 + } + self.rear = (self.rear + 1)%self.size + self.data[self.rear] = value + } + + func dequeue() -> Int? { + if self.isEmpty(){ + return nil + } + let value: Int = self.data[self.front] + if(self.front == self.rear){ + self.front = -1 + self.rear = -1 + } + else { + self.front = (self.front+1) % self.size + } + + return value + } + + func peek() -> Int? { + if self.isEmpty(){ + return nil + } + return self.data[self.front] + } +} + +let cirQueue: CircularQueue = CircularQueue(size: 10) +var exitFlag: Bool = true + +while exitFlag { + print("명령어를 입력하세요 (enqueue [값], dequeue, peek, info, exit):") + if let input = readLine() { + let components = input.split(separator: " ") + let order = String(components.first ?? "") + + switch order { + case "enqueue" : + if components.count == 2, let value = Int(components[1]) { + cirQueue.enqueue(to: value) + print("\(value) enqueue!") + } + else { + print("enqueue 명령어 뒤에 공백에 이어서 숫자를 입력해야합니다.") + } + case "dequeue" : + if let value = cirQueue.dequeue(){ + print("\(value) dequeue!!") + } + else { + print("Empty!!") + } + case "peek" : + if let value = cirQueue.peek(){ + print("\(value) peek!!") + } + else { + print("Empty!!") + } + case "info" : + cirQueue.info() + case "exit" : + exitFlag = false + print("Exit!!!") + default : + print("제대로 된 명령어를 입력하세요") + } + } + else { + print("제대로 입력해주세요") + } +} \ No newline at end of file diff --git a/code_study/data_structure/DS_queue.ts b/code_study/data_structure/DS_queue.ts new file mode 100644 index 0000000..b9cadcd --- /dev/null +++ b/code_study/data_structure/DS_queue.ts @@ -0,0 +1,109 @@ +export {}; + +class CircularQueue { + private data: number[]; + private front: number; + private rear: number + private size: number; + + constructor(size: number){ + this.size = size; + this.rear = -1; + this.front = -1; + this.data = Array.from({length: size}, () => 0); + } + + public isEmpty(): boolean{ + return this.front === -1; + } + + public isFull(): boolean{ + return (this.rear + 1)%(this.size) === this.front; + } + + public enqueue(value: number){ + if(this.isFull()){ + console.log("Queue is full!"); + return; + } + if(this.isEmpty()){ + this.front = 0; + } + + this.rear = (this.rear + 1)%(this.size); + this.data[this.rear] = value; + } + + public dequeue(): number | undefined { + if(this.isEmpty()) return undefined; + const value: number = this.data[this.front]; + if(this.rear === this.front) { + this.rear = -1; + this.front = -1; + } + else { + this.front = (this.front + 1)%(this.size); + } + return value; + } + + public peek(): number | undefined { + return (this.isEmpty()) ? undefined : this.data[this.front]; + } + + public info() { + if(this.isEmpty()){ + console.log("Empty!"); + return; + } + let result = "list : ["; + let i = this.front; + while(true){ + result += this.data[i].toString(); + if(i === this.rear){ + result += "]"; + break; + } + i = (i+1)%(this.size); + result += ","; + } + console.log(result); + } +} + +console.log("원형큐를 생성합니다. 사이즈를 입력해주세요.") +const size: number = Number(require("fs").readFileSync(0,"utf8").toString().trim()); +let cq = new CircularQueue(size); +let exitFlag: boolean = true; + +while(exitFlag){ + console.log("++++++++++++++++명령어모음++++++++++++++++"); + console.log("enqueue | dequeue | peek | info | exit"); + console.log("========================================"); + console.log("명령어를 입력해주세요!"); + const input:string[] = require("fs").readFileSync(0,"utf8").toString().trim().split(" "); + switch(input[0]) + { + case "enqueue": + cq.enqueue(Number(input[1])); + break; + case "dequeue": + const deqvalue = cq.dequeue(); + console.log(deqvalue===undefined ? "큐가 비었습니다." : deqvalue); + break; + case "peek": + const peekValue = cq.peek(); + console.log(peekValue===undefined ? "큐가 비었습니다." : peekValue); + break; + case "info": + cq.info(); + break; + case "exit": + exitFlag = false; + console.log("종료합니다.") + break; + default: + console.log("제대로 입력해주세요.") + break; + } +} \ No newline at end of file