5 1 3 u ADT Queue ADT Queue

  • Slides: 81
Download presentation

5. 1 큐 추상 데이타 타입(3) u 큐 추상 데이타 타입(ADT Queue) ADT Queue

5. 1 큐 추상 데이타 타입(3) u 큐 추상 데이타 타입(ADT Queue) ADT Queue 데이타 : 0개 이상의 원소를 가진 유한 순서 리스트 연산 : Q ∈ Queue; item ∈ Element; create. Q() : : = create an empty queue; enqueue(Q, item) : : = insert item at the rear of Q; is. Empty(Q) : : = if (Q is empty) then return true else return false; dequeue(Q) : : = if (is. Empty(Q)) then return null else remove and return the front element of Q; remove(Q) : : = if (is. Empty(Q)) then return null else remove the front element of Q; peek(Q) : : = if (is. Empty(Q)) then return null else return the front element of Q; End Queue

5. 2 큐의 순차 표현(3) u 큐의 연산자(2) dequeue(Q) // Q에서 원소를 삭제하여 반환

5. 2 큐의 순차 표현(3) u 큐의 연산자(2) dequeue(Q) // Q에서 원소를 삭제하여 반환 if (is. Empty(Q)) then return null; // Q가 공백인 상태를 처리 front ← front + 1; return Q[front]; end dequeue() remove(Q) // Q에서 원소를 삭제 if (is. Empty(Q)) then return null; // 큐(Q)가 공백인 상태를 처리 front ← front + 1; end remove() peek(Q) // Q에서 원소를 검색 if (is. Empty(Q)) then return null; // 큐(Q)가 공백인 상태를 처리 else return Q[front+1]; end peek()

5. 2 큐의 순차 표현(6) u 원형 큐에서의 enqueue와 dequeue 연산 enqueue(Q, item) //

5. 2 큐의 순차 표현(6) u 원형 큐에서의 enqueue와 dequeue 연산 enqueue(Q, item) // 원형 큐(Q)에 item을 삽입 rear ← (rear+1) mod n; if (front=rear) then queue. Full(); Q[rear] ← item; end enqueue() // 원형 큐(Q) 인덱스 // 큐(Q)가 만원인 상태를 처리 dequeue(Q) // 원형 큐(Q)에서 원소를 삭제하여 반환 if (front=rear) then return null; //큐(Q)가 공백인 상태를 처리 else { front ← (front+1) mod n; // 원형 인덱스 return Q[front]; } end dequeue()

5. 3 C 배열을 이용한 큐의 구현(1) u Queue를 구현하기 위한 기본 함수 프로토타입

5. 3 C 배열을 이용한 큐의 구현(1) u Queue를 구현하기 위한 기본 함수 프로토타입 int is. Empty(int *front, int rear); // 큐가 공백인가를 검사 void enqueue(int *rear, element item); // element 타입의 원소를 삽입 element dequeue(int *front, int rear); // element 타입의 원소를 삭제하여 반환 void delete(int *front, int rear); // 원소를 삭제 element peek(int front, int rear); // element 타입의 원소를 검색

5. 3 C 배열을 이용한 큐의 구현(2) u 1차원 배열(queue[])를 이용한 큐의 구현(1) /*

5. 3 C 배열을 이용한 큐의 구현(2) u 1차원 배열(queue[])를 이용한 큐의 구현(1) /* C 배열을 이용한 큐의 구현*/ #define Q_SIZE 100 /* 최대 큐 크기 */ typedef int element; element queue[Q_SIZE]; void enqueue(int *rear, element item) { if(*rear == Q_SIZE-1) { /* 큐가 만원인 경우를 처리 */ printf("Queue is fulln"); return; } queue[++*rear] = item; } int is. Empty (int *front, int rear) { if (*front == rear) return 1; /* 큐가 공백인 경우 */ else return 0; }

5. 3 C 배열을 이용한 큐의 구현(3) u 1차원 배열(queue[])를 이용한 큐의 구현(2) element

5. 3 C 배열을 이용한 큐의 구현(3) u 1차원 배열(queue[])를 이용한 큐의 구현(2) element dequeue(int *front, int rear) { if (*front == rear) { /* 큐가 공백인 경우 */ printf("Queue is emptyn"); exit(1); } else return queue[++*front]; } void delete(int *front, int rear) { if (*front == rear) { /* 큐가 공백인 경우 */ printf("Queue is emptyn"); exit(1); } else ++*front; }

5. 3 C 배열을 이용한 큐의 구현(4) u 1차원 배열(queue[])를 이용한 큐의 구현(3) element

5. 3 C 배열을 이용한 큐의 구현(4) u 1차원 배열(queue[])를 이용한 큐의 구현(3) element peek(int front, int rear) { if (front == rear) { /* 큐가 공백인 경우 */ printf("Queue is emptyn"); exit(1); } else { return queue[front+1]; } }

5. 3 C 배열을 이용한 큐의 구현(5) u 1차원 배열(queue[])를 이용한 큐의 구현(4) int

5. 3 C 배열을 이용한 큐의 구현(5) u 1차원 배열(queue[])를 이용한 큐의 구현(4) int main( void ) { int front = -1; /* 삭제 연산 인덱스 */ int rear = -1; /* 삽입 연산 인덱스 */ element data; enqueue(&rear, 1); enqueue(&rear, 2); data = peek(front, rear); printf("data=%dn", data); data = dequeue(&front, rear); printf("data=%dn", data); return 0; }

5. 4 큐의 연결 표현(2) u 연결 큐에서의 삽입, 삭제, 검색 연산 구현(1) enqueue(Q,

5. 4 큐의 연결 표현(2) u 연결 큐에서의 삽입, 삭제, 검색 연산 구현(1) enqueue(Q, item) // 연결큐(Q)에 item을 삽입 new. Node ← get. Node(); // 새로운 노드를 생성 new. Node. data ← item; new. Node. link ← null; if (rear = null) then { // Q가 공백인 경우 rear ← new. Node; front ← new. Node; } else { rear. link ← new. Node; rear ← new. Node; } end enqueue() dequeue(Q) // 큐(Q)에서 원소를 삭제하고 값을 반환 if (front = null) then return null; // Q가 공백인 경우 old. Node ← front; item ← front. data; front ← front. link; if (front = null) then rear ← null; // 삭제로 인해 Q가 공백이 되는 이유 ret. Node(old. Node); return item; end dequeue()

5. 4 큐의 연결 표현(3) u 연결 큐에서의 삽입, 삭제, 검색 연산 구현(2) delete(Q)

5. 4 큐의 연결 표현(3) u 연결 큐에서의 삽입, 삭제, 검색 연산 구현(2) delete(Q) // 큐(Q)에서 원소를 삭제 if (front = null) then queue. Empty(); else { old. Node ← front; front ← front. link; if (front = null) then rear ← null; ret. Node(old. Node); } end delete() // 큐(Q)가 공백인 경우 peek(Q) // 큐(Q)의 front 원소를 검색 if (front = null) then queue. Empty(); // 큐(Q)가 공백인 경우 else return (front. data); end peek()

5. 4 큐의 연결 표현(5) u m개의 큐에서의 삽입, 삭제, 검색 연산 구현(1) enqueue(i,

5. 4 큐의 연결 표현(5) u m개의 큐에서의 삽입, 삭제, 검색 연산 구현(1) enqueue(i, item) // 큐 i에 item을 삽입 new. Node ← get. Node(); new. Node. data ← item; new. Node. link ← null; if (front[i] = null) then { // 큐 i가 공백인 경우 front[i] ← new. Node; rear[i] ← new. Node; } else { // 큐 i가 공백이 아닌 경우 rear[i]. link ← new. Node; rear[i] ← new. Node; } end enqueue()

5. 4 큐의 연결 표현(7) u m개의 큐에서의 삽입, 삭제, 검색 연산 구현(3) delete(i)

5. 4 큐의 연결 표현(7) u m개의 큐에서의 삽입, 삭제, 검색 연산 구현(3) delete(i) // 큐 i에서 원소를 삭제 if (front[i] = null) then queue. Empty(); else { old. Node ← front[i]; front[i] ← front[i]. link; if(front[i] = null) then rear[i] ← null; ret. Node(old. Node); } end delete() peek(i) // 큐 i에서 원소 값을 검색 if (front[i] = null) then queue. Empty(); else return (front[i]. data); end peek()

5. 5 C 리스트를 이용한 큐의 구현(1) u 원소 데이타 · 노드 · 연결

5. 5 C 리스트를 이용한 큐의 구현(1) u 원소 데이타 · 노드 · 연결 큐 타입 typedef struct { /* 큐의 struct 원소 타입 */ int id; char name[10]; char grade; } element ; typedef struct queue. Node { /* 연결 큐의 노드 타입 */ element data; struct queue. Node* link; } queue. Node ; typedef struct { /* 연결 큐 데이타 타입 */ queue. Node* front; /* 삭제연산 포인터 */ queue. Node* rear; /* 삽입연산 포인터 */ int length; /* 큐(리스트)의 원소 수를 표현 */ } linked. Queue ;

5. 5 C 리스트를 이용한 큐의 구현(3) u 연결 리스트로 큐를 구현한 C 프로그램(1)

5. 5 C 리스트를 이용한 큐의 구현(3) u 연결 리스트로 큐를 구현한 C 프로그램(1) #include <stdio. h> #include <stdlib. h> typedef struct { /* 연결 큐의 struct 원소 타입 */ int id; char name[10]; char grade; }element ; typedef struct queue. Node { /* 연결 큐의 노드 타입 */ element data; struct queue. Node* link; } queue. Node ; typedef struct { /* 연결 큐 데이타 타입 */ queue. Node* front; /* 삭제연산 포인터 */ queue. Node* rear; /* 삽입연산 포인터 */ int length; /* 큐(리스트)의 원소 수를 표현 */ }linked. Queue ;

5. 5 C 리스트를 이용한 큐의 구현(4) u 연결 리스트로 큐를 구현한 C 프로그램(2)

5. 5 C 리스트를 이용한 큐의 구현(4) u 연결 리스트로 큐를 구현한 C 프로그램(2) linked. Queue* create. Q() { /* 연결 큐(q)를 생성하고 초기화 */ linked. Queue* q q = (linked. Queue*)malloc(sizeof(linked. Queue)); q->front = NULL; q->rear = NULL; q->length = 0; return q; } int is. Empty (linked. Queue* q) { /* 연결 큐가 공백인가를 검사 */ return (q->length == 0); }

5. 5 C 리스트를 이용한 큐의 구현(5) u 연결 리스트로 큐를 구현한 C 프로그램(3)

5. 5 C 리스트를 이용한 큐의 구현(5) u 연결 리스트로 큐를 구현한 C 프로그램(3) void enqueue(linked. Queue* q, element item) { /* 연결 큐에 원소를 삽입 */ queue. Node* new. Node; new. Node = (queue. Node*)malloc(sizeof(queue. Node)); new. Node->data = item; new. Node->link = NULL; if (q->length==0) { /* 연결 큐가 공백인 경우 */ q->front = q->rear = new. Node; } else { q->rear->link = new. Node; q->rear = new. Node; } q->length++; }

5. 5 C 리스트를 이용한 큐의 구현(6) u 연결 리스트로 큐를 구현한 C 프로그램(4)

5. 5 C 리스트를 이용한 큐의 구현(6) u 연결 리스트로 큐를 구현한 C 프로그램(4) element dequeue(linked. Queue* q) { /* 연결 큐에서 원소를 삭제하고 반환 */ queue. Node* temp; element item; if (q->length==0) { /* 연결 큐가 공백인 경우 */ printf("Queue is emptyn"); exit(1); } else { item = q->front->data; temp = q->front; q->front = q->front->link; if (q->front == NULL) q->rear = NULL; q->length--; free(temp); /* 삭제된 노드를 반환 */ return item; } }

5. 5 C 리스트를 이용한 큐의 구현(7) u 연결 리스트로 큐를 구현한 C 프로그램(5)

5. 5 C 리스트를 이용한 큐의 구현(7) u 연결 리스트로 큐를 구현한 C 프로그램(5) void delete(linked. Queue* q) { /* 연결 큐에서 원소를 삭제 */ queue. Node* temp; if (q->length==0) { /* 큐가 공백인 경우 */ printf("Queue is emptyn"); exit(1); } else { temp = q->front; q->front = q->front->link; if (q->front == NULL) q->rear = NULL; q->length--; free(temp); /* 삭제된 노드를 반환 */ } }

5. 5 C 리스트를 이용한 큐의 구현(8) u 연결 리스트로 큐를 구현한 C 프로그램(6)

5. 5 C 리스트를 이용한 큐의 구현(8) u 연결 리스트로 큐를 구현한 C 프로그램(6) element peek(linked. Queue* q) { /* 연결 큐에서 원소를 검색 */ if (q->length == 0) { /* 큐가 공백인 경우 */ printf("Queue is emptyn"); exit(1); } else return q->front->data; } int main() { element item; linked. Queue* q; q = create. Q(); item. id = 123; strcpy(item. name, "Hong"); item. grade ='A'; enqueue(q, item); ··· }

5. 7 우선 순위 큐(2) u 우선 순위 큐(priority queue) 추상 데이타 타입 ADT

5. 7 우선 순위 큐(2) u 우선 순위 큐(priority queue) 추상 데이타 타입 ADT Priority. Queue 데이타 : 우선순위를 가진 0개 이상의 원소로 된 수집(collection) 연산 : p. Q ∈ Priority. Queue; item ∈ Element; create. Q() : : = create an empty priority queue; length(p. Q) : : = return the number of items in p. Q; insert(p. Q, item) : : = insert the item into p. Q; delete(p. Q) : : = if (is. Empty(p. Q)) then return error else {delete the item with the highest priority from p. Q}; End Priority. Queue

5. 7. 2 C 우선순위 큐의 구현(3) u 정렬된 연결 리스트를 이용한 구현(3) l

5. 7. 2 C 우선순위 큐의 구현(3) u 정렬된 연결 리스트를 이용한 구현(3) l 정렬된 연결 리스트로 구현한 C 프로그램(2) priority. Q* create. Q() { /* 공백 연결 우선순위 큐를 생성 */ priority. Q* p. Q; p. Q = (priority. Q*)malloc(sizeof(priority. Q)); p. Q->length = 0; p. Q->head = NULL; return p. Q; } int compare. To(element item 1, element item 2) { /* insert() 함수의 보조 함수 */ int a = item 1. key; int b = item 2. key; return ((a==b) ? 0 : ((a>b) ? 1 : -1)); }

5. 7. 2 C 우선순위 큐의 구현(5) u 정렬된 연결 리스트를 이용한 구현(5) l

5. 7. 2 C 우선순위 큐의 구현(5) u 정렬된 연결 리스트를 이용한 구현(5) l 정렬된 연결 리스트로 구현한 C 프로그램(4) element delete(priority. Q* p. Q) { element item; p. List. Node* temp; if (p. Q->length == 0) { /* 큐가 공백인 경우 */ printf("Queue is emptyn"); exit(1); } else { item = p. Q->head->data; temp = p. Q->head; p. Q->head = p. Q->head->link; p. Q->length--; free(temp); return item; } }

5. 7. 2 C 우선순위 큐의 구현(8) u 무정렬 배열을 이용한 우선순위 큐의 구현(3)

5. 7. 2 C 우선순위 큐의 구현(8) u 무정렬 배열을 이용한 우선순위 큐의 구현(3) l 무정렬 배열로 구현한 C 프로그램(2) priority. Q* create. Q() { /*공백 우선순위 큐 생성 */ priority. Q* p. Q; p. Q = (priority. Q*)malloc(sizeof(priority. Q)); p. Q->length = 0; p. Q->q. Size = 20; p. Q->increment = 5; p. Q->data = (element*)malloc(p. Q->q. Size * sizeof(element)); return p. Q; } int compare. To(element item 1, element item 2) { int a = item 1. key; int b = item 2. key; return ((a==b) ? 0 : ((a>b) ? 1 : -1)); }

5. 7. 3 스트링 타입 원소를 위한 C 우선순위 큐(2) u 우선순위 큐를 이용한

5. 7. 3 스트링 타입 원소를 위한 C 우선순위 큐(2) u 우선순위 큐를 이용한 스트링 정렬(1) void main() { int i; int n = 7; /* 정렬할 원소 수 */ char* names[] = {"Kim", "Cho", "Lee", "Koh", "Pak", "Han", "Yoo"}; element* data = (element*)malloc(n * sizeof(element)); for (i = 0; i < n; i++) { strcpy(data[i]. name, names[i]); printf("%s, ", data[i]. name); } printf("rn"); priority. Qsort(data, n); /* 배열 data[]를 priority. Qsort()로 정렬 */ for (i = 0; i < n; i++) { printf("%s, ", data[i]. name); } printf("rn"); free(data); }

5. 8 덱(2) u 덱의 추상 데이타 타입(ADT) create. Deque() : : = create

5. 8 덱(2) u 덱의 추상 데이타 타입(ADT) create. Deque() : : = create an empty deque; insert. First(Deque, e) : : = insert new element e at the beginning of Deque; insert. Last(Deque, e) : : = insert new element e at the end of Deque; is. Empty(Deque) : : = if Deque is empty then return true else return false; delete. First(Deque) : : = if is. Empty(Deque) then return null else remove and return the first element of Deque; delete. Last(Deque) : : = if is. Empty(Deque) then return null else remove and return the last element of Deque; remove. First(Deque) : : = if is. Empty(Deque) then return null else remove the first element of Deque; remove. Last(Deque) : : = if is. Empty(Deque) then return null else remove the last element of Deque; peek. Last(Deque) : : = return the last element of Deque; peek. First(Deque) : : = return the first element of Deque;

5. 8 덱(3) u 공백 덱에 대한 일련의 연산 수행 연산 insert. First(Deque, 3)

5. 8 덱(3) u 공백 덱에 대한 일련의 연산 수행 연산 insert. First(Deque, 3) insert. First(Deque, 5) delete. First(Deque) insert. Last(Deque, 7) delete. First(Deque) delete. Last(Deque) insert. First(Deque, 9) insert. Last(Deque, 7) insert. First(Deque, 3) insert. Last(Deque, 5) delete. Last(Deque) delete. First(Deque) 덱(Deque) (3) (5, 3) (3, 7) () (9, 7) (3, 9, 7, 5) (3, 9, 7) (9, 7)

5. 8 덱(4) u 스택과 큐 ADT 연산에 대응하는 덱의 연산 l 스택 ADT

5. 8 덱(4) u 스택과 큐 ADT 연산에 대응하는 덱의 연산 l 스택 ADT 연산에 대응하는 연산 스택 연산 l 덱 연산 create. Stack() create. Deque() push(S, e) insert. Last(Deque, e) is. Empty(S) is. Empty(Deque) pop(S) delete. Last(Deque) remove(S) remove. Last(Deque) peek(S) peek. Last(Deque) 큐 ADT 연산에 대응하는 연산 큐 연산 덱 연산 create. Q() create. Deque() enqueue(Q, e) insert. Last(Deque, e) is. Empty(Q) is. Empty(Deque) dequeue(Q) delete. First(Deque) remove(Q) remove. First(Deque) peek(Q) peek. First(Deque)

5. 8 덱(6) u 이중 연결 리스트를 이용한 덱 l 공백 이중 연결 덱

5. 8 덱(6) u 이중 연결 리스트를 이용한 덱 l 공백 이중 연결 덱 w Length = 0, first = last = null length first deque l 0 null last null 3개의 원소를 포함한 이중 연결 덱 length first deque last 3 llink data null X 3 rlink llink data X 2 rlink llink data X 1 rlink null

5. 8 덱(7) u 이중 연결 리스트를 이용한 덱 구현 #include <stdio. h> #include

5. 8 덱(7) u 이중 연결 리스트를 이용한 덱 구현 #include <stdio. h> #include <stdlib. h> typedef struct { int key; char name[10]; char grade; }element ; typedef struct double. List. Node { element data; struct double. List. Node* rlink; struct double. List. Node* llink; } deq. Node; typedef struct { deq. Node* first; deq. Node* last; int length; } deque;

5. 8 덱(8) deque* create. Deque() { /* 공백 이중 연결 덱을 생성 */

5. 8 덱(8) deque* create. Deque() { /* 공백 이중 연결 덱을 생성 */ deque* deq; deq = (deque *)malloc(sizeof(deque)); deq->first = NULL; deq->last = NULL; deq->length = 0; return deq; } int is. Empty(deque* deq) { /* 덱이 공백인가를 검사 */ if (deq->length == 0) return 1; else return 0; }

5. 8 덱(9) void insert. First(deque* deq, element item) { /* 연결 덱에 첫

5. 8 덱(9) void insert. First(deque* deq, element item) { /* 연결 덱에 첫 번째 원소를 삽입 */ deq. Node* new. Node; new. Node = (deq. Node *)malloc(sizeof(deq. Node)); new. Node->data = item; if (deq->length == 0) { deq->first = new. Node; deq->last = new. Node; new. Node->rlink = NULL; new. Node->llink = NULL; } else { deq->first->llink = new. Node; new. Node->rlink = deq->first; new. Node->llink = NULL; deq->first = new. Node; } deq->length++; }

5. 8 덱(10) void insert. Last(deque* deq, element item) { /* 연결 덱에 마지막

5. 8 덱(10) void insert. Last(deque* deq, element item) { /* 연결 덱에 마지막 원소로 삽입 */ deq. Node* new. Node; new. Node = (deq. Node * )malloc(sizeof(deq. Node)); new. Node->data = item; if (deq->length == 0) { /* 덱이 공백인 경우 */ deq->first = new. Node; deq->last = new. Node; new. Node->rlink = NULL; new. Node->llink = NULL; } else { deq->last->rlink = new. Node; new. Node->rlink = NULL; new. Node->llink = deq->last; deq->last = new. Node; } deq->length++; }

5. 8 덱(11) element delete. First(deque* deq) { /* 연결 덱에서 첫 번째 원소를

5. 8 덱(11) element delete. First(deque* deq) { /* 연결 덱에서 첫 번째 원소를 삭제하고 반환 */ deq. Node* temp; element item; if (deq->length==0) { /* 연결 덱이 공백인 경우 */ printf("Deque is emptyn"); exit(1); } else { item = deq->first->data; temp = deq->first; if (deq->first->rlink = NULL) { /* 원소가 1개인 경우 */ deq->first = NULL; deq->last = NULL; } else { /* 원소가 2개 이상인 경우 */ deq->first = deq->first->rlink; deq->first->llink = NULL; } deq->length--; free(temp); /* 삭제된 노드를 반환 */ return item; } }

5. 8 덱(12) element delete. Last(deque* deq) { /* 연결 덱에서 마지막 원소를 삭제하고

5. 8 덱(12) element delete. Last(deque* deq) { /* 연결 덱에서 마지막 원소를 삭제하고 반환 */ deq. Node* temp; element item; if (deq->length==0) { /* 연결 덱이 공백인 경우 */ printf("Deque is emptyn"); exit(1); } else { item = deq->last->data; temp = deq->last; if (deq->last->llink = NULL) { /* 원소가 1개인 경우 */ deq->first = NULL; deq->last = NULL; } else { /* 원소가 2개 이상인 경우 */ deq->last = deq->last->llink; deq->last->rlink = NULL; } deq->length--; free(temp); /* 삭제된 노드를 반환 */ return item; } }

5. 8 덱(13) void remove. First(deque* deq) { /* 연결 덱에서 첫 번째 원소를

5. 8 덱(13) void remove. First(deque* deq) { /* 연결 덱에서 첫 번째 원소를 삭제 */ deq. Node* temp; if (deq->length==0) { /* 연결 덱이 공백인 경우 */ printf("Deque is emptyn"); exit(1); } else { temp = deq->first; if (deq->first->rlink = NULL) { /* 원소가 1개인 경우 */ deq->first = NULL; deq->last = NULL; } else { /* 원소가 2개 이상인 경우 */ deq->first = deq->first->rlink; deq->first->llink = NULL; } deq->length--; free(temp); /* 삭제된 노드를 반환 */ } }

5. 8 덱(14) void remove. Last(deque* deq) { /* 연결 덱에서 마지막 원소를 삭제

5. 8 덱(14) void remove. Last(deque* deq) { /* 연결 덱에서 마지막 원소를 삭제 */ deq. Node* temp; if (deq->length==0) { /* 연결 덱이 공백인 경우 */ printf("Deque is emptyn"); exit(1); } else { temp = deq->last; if (deq->last->llink = NULL) { /* 원소가 1개인 경우 */ deq->first = NULL; deq->last = NULL; } else { /* 원소가 2개 이상인 경우 */ deq->last = deq->last->llink; deq->last->rlink = NULL; } deq->length--; free(temp); /* 삭제된 노드를 반환 */ } }

5. 8 덱(15) element peek. First(deque* deq) { /* 연결 덱에서 첫 번째 원소를

5. 8 덱(15) element peek. First(deque* deq) { /* 연결 덱에서 첫 번째 원소를 검색해서 반환 */ if (deq->length==0) { /* 연결 덱이 공백인 경우 */ printf("Deque is emptyn"); exit(1); } else return deq->first->data; } element peek. Last(deque* deq) { /* 연결 덱에서 마지막 원소를 검색해서 반환 */ if (deq->length==0) { /* 연결 덱이 공백인 경우 */ printf("Deque is emptyn"); exit(1); } else return deq->last->data; } int main() { deque* deq; deq = create. Deque(); … }

5. 8 덱(16) u 덱을 이용한 스택의 구현(1) l 스택의 연산 : 덱의 함수를

5. 8 덱(16) u 덱을 이용한 스택의 구현(1) l 스택의 연산 : 덱의 함수를 호출하는 함수 호출 명령문 deque* create. Stack() { /* 공백 덱으로 스택을 생성 */ deque* stack; stack = create. Deque(); return stack; } int is. Stack. Empty(deque* stack) { /* 스택이 공백인가를 검사 */ return (is. Empty(stack)); } void push(deque* stack, element item) { /* 스택에 원소 삽입 */ insert. Last(stack, item); }

5. 8 덱(17) u 덱을 이용한 스택의 구현(2) element peek(deque* stack) { /* 스택의

5. 8 덱(17) u 덱을 이용한 스택의 구현(2) element peek(deque* stack) { /* 스택의 톱 원소를 검색 */ if (stack->length==0) { /* 스택(연결 덱)이 공백인 경우 */ printf("Stack is emptyn"); exit(1); } else { return peek. Last(stack); } } element pop(deque* stack) { /* 스택의 톱 원소를 삭제하고 반환 */ if (stack->length==0) { /* 스택(연결 덱)이 공백인 경우 */ printf("Stack is emptyn"); exit(1); } else { return delete. Last(stack); } }

5. 8 덱(18) u 덱을 이용한 스택의 구현(3) void remove(deque* stack) { /* 스택의

5. 8 덱(18) u 덱을 이용한 스택의 구현(3) void remove(deque* stack) { /* 스택의 톱 원소를 삭제 */ if (stack->length==0) { /* 스택(연결 덱)이 공백인 경우 */ printf("Stack is emptyn"); exit(1); } else { remove. Last(stack); } }