Transcript Document

강의 내용 (열 한번째)
 오늘 강의 내용(6월 13일)
6장 큐
 큐의 순차 표현, 배열을 이용한 큐의 표현
 큐의 연결 표현, 링크드 리스트를 이용한 큐의 표현
 우선 순위 큐 (Priority Queue) / 덱 (deque)
 기말고사
 6월 20일 (월) 오후 4:00, 1101A
 4장, 5장, 6장
 숙제: 프로그래밍 리포트 #2 마감일
 P227, 5장 연습 문제 19번
 마감일 : 6월 13일
 연습문제 5장 6,8,10,11
© DBLAB, SNU
미로 문제 (1)

미로
예

m Ⅹ n 미로를 maze(m+2, n+2)
배열로 표현
사방을
1로 둘러싸서 경계
위치에 있을 때의 예외성(두
방향만 존재)을 제거
© DBLAB, SNU
미로 문제 (2)

현재 위치 : maze[i][j]

이동 방향

북, 동, 남, 서 순서 (시계 방향)
북
(i-1, j)
서
(i, j-1)
(i, j)
(i+1, j)
남
© DBLAB, SNU
동
(i, j+1)
미로 문제 (3)


이동 방향 배열 : move[4, 2]
i
j
(dir)
[0]
[1]
북[0]
-1
0
동[1]
0
1
남[2]
1
0
사[3]
0
-1
다음 위치계산 : maze[nexti,nextj]
 i + move[dir, 0]
next_j  j + move[dir, 1]
next_i

방문한 경로를 mark[m+2, n+2]에 저장
한

번 시도했던 위치로는 다시 이동하지 않음
지나온 경로의 기억 <i, j, dir>을 스택에 저장
스택의
최대 크기 : m * n
© DBLAB, SNU
미로 경로 발견 알고리즘 (1)
mazePath( )
maze[m+2, n+2];// m × n 크기의 미로 표현
// 행 0과 m+1, 열 0과 n+1은 1로 초기화
// 입구는 maze[1, 1], 출구는 maze[m, n]
mark[m+2, n+2]; // 방문 위치를 표시할 배열로 모든 원소를 0으로 초기화
// dir = {0(북), 1(동), 2(남), 3(서)}
stack[m×n];
top ← -1; // 3원소 쌍 <i, j, dir>을 저장하는 stack을 초기화
push(stack, <1, 1, 1>); //입구 위치 (1,1), 이동 방향은 동(1)으로 초기화
while (not isEmpty(stack)) do {
// 스택의 공백 여부를 검사
<i, j, dir> ← pop(stack);
// 스택의 톱 원소를 제거
while (dir ≤ 3) do {
// 시도해 볼 방향이 있는 한 계속 시도
next_i ← i + move[dir, i];
// 다음 시도할 행(i)을 설정
next_j ← j + move[dir, j];
// 다음 시도할 열(j)을 설정
if (next_i = m and next_j = n) // 미로 경로 발견
then {
print("The path is as follows.");
print(path in stack); // 스택에 저장된 경로 출력
print(i, j); print(m, n);
return;
}
© DBLAB, SNU
미로 경로 발견 알고리즘 (2)
if (maze[next_i, next_j] = 0 and
// 이동 가능 여부 검사
mark[next_i, next_j] = 0) // 시도해 보지 않은 위치인지 검사
then {
mark[next_i, next_j] ← 1;
push(stack, <i, j, dir>);
// 이동한 위치를 스택에 기록
<i, j, dir> ← <next_i, next_j, 0>;
}
else dir ← dir + 1; // 다음 이동할 방향을 설정
}
}
print("There is no path"); //미로 경로가 없는 경우
end mazePath()
© DBLAB, SNU
6장 큐
© DBLAB, SNU
순서
큐 추상 데이타 타입
 6.2 큐의 순차 표현
 6.3 배열을 이용한 큐의 구현
 6.4 큐의 연결 표현
 6.5 리스트를 이용한 큐의 구현
 6.6 큐의 응용
 6.7 우선 순위 큐
 6.8 덱
 6.1
© DBLAB, SNU
큐 추상 데이타 타입(1)

큐(queue)


한쪽 끝(rear)에서는 삽입(enqueue)만, 또 다른
끝(front)에서는 삭제(dequeue)만 하도록 제한되어 있는
유한 순서 리스트(finite ordered list)
선입선출, First-In-First-Out(FIFO) 리스트
 큐에서 제일 먼저 삽입된 원소가 제일 먼저 삭제될 원소가 됨

선착순 서버, first-come-first-serve (FCFS) 시스템
 서비스를 받기 위한 대기 행렬로 볼 수 있음

큐의 작동 구조
삭제
삽입
front
© DBLAB, SNU
rear
큐 추상 데이타 타입(2)

큐에서의 삽입과 삭제

f
f : front, r : rear
r
r
f
f
r
f
r
f
r
f
r
A
A B
A B C
A B C D
B C D
C D
삽입(A)
삽입(B)
삽입(C)
삽입(D)
삭제
삭제

큐의 응용 사례

운영 체제 : 작업 큐를 통한 제출 순서에 따른 작업 스케줄
 서비스를 기다리는 작업들의 대기 상태를 나타내는 데 적절
© DBLAB, SNU
큐 추상 데이타 타입(3)

큐 추상 데이타 타입(ADT Queue)
ADT Queue
데이타 : 0개 이상의 원소를 가진 유한 순서 리스트
연산 :
queue ∈ Queue; item ∈ Element;
createQ() ::= create an empty queue;
enqueue(queue, item) ::= insert item at the rear of queue;
isEmpty(queue) ::= if (queue is empty) then return true
else return false;
dequeue(queue) ::= if (isEmpty(queue)) then return error
else {delete and return the front item of queue};
delete(queue) ::= if (isEmpty(queue)) then return error
else {delete the front item of queue};
peek(queue) ::= if (isEmpty(queue)) then return error
else {return the front item of queue};
End Queue
© DBLAB, SNU
큐의 순차 표현(1)

1차원 배열



큐를 표현하는 가장 간단한 방법
Q[n]을 이용한 순차 표현
순차 표현을 위한 변수
 n : 큐에 저장할 수 있는 최대 원소 수
 두 인덱스 변수 front, rear
 초기화 : front = rear = -1 (공백큐)
 공백큐 : front = rear
 만원 : rear = n-1
© DBLAB, SNU
큐의 순차 표현(2)

큐의 연산자(1)
createQ()
// 공백 큐(q[])를 생성
q[n];
front ← -1;
// 초기화
rear ← -1;
end createQ()
isEmpty(q)
// 큐(q)가 공백인지를 검사
if (front = rear) then return true
else return false;
end isEmpty()
enqueue(q, item)
// 큐(q)에 원소를 삽입
if (rear=n-1) then queueFull() // 큐(q)가 만원인 상태를 처리
rear ← rear + 1;
q[rear] ← item;
end enqueue()
© DBLAB, SNU
큐의 순차 표현(3)

큐의 연산자(2)
dequeue(q)
// 큐(q)에서 원소를 삭제하여 반환
if (isEmpty(q)) then queueEmpty() // 큐(q)가 공백인 상태를 처리
else {
front ← front + 1;
return q[front];
};
end dequeue()
delete(q)
// 큐(q)에서 원소를 삭제
if (isEmpty(q)) then queueEmpty() // 큐(q)가 공백인 상태를 처리
front ← front + 1;
end delete()
peek(q)
// 큐(q)에서 원소를 검색
if (isEmpty(q)) then queueEmpty() // 큐(q)가 공백인 상태를 처리
else return q[front+1];
end peek()
© DBLAB, SNU
큐의 순차 표현(4)

순차 표현의 문제점

Rear=n-1인 경우
 만원이지만, 반드시 n개의 원소가 큐에 있지는 않음
 큐의 앞에서 삭제로 인해 비 공간이 생길 수 있음
 빈공간을 없애기 위해 앞쪽으로 이동, front‧rear 재설정
  시간, 연산의 지연 문제
 실제로 큐가 만원인 경우
 배열의 크기를 확장해야 함

원형 큐(circular queue)


순차 표현의 문제점 해결 위해 배열 Q[n]을 원형으로 운영
원형 큐의 구현





초기화 : front = rear = 0 (공백큐)
공백큐 : front = rear
원소 삽입 : rear를 하나 증가시키고, 그 위치에 원소 저장
만원 : rear를 하나 증가시켰을 때, rear = front
(실제 front 공간 하나가 비지만, 편의를 위해 그 공간을 희생)
© DBLAB, SNU
큐의 순차 표현(5)

원형 큐의 여러 상태
...
[n-2]
[n-1]
[0]
[1]

...
[2]
a1
[n-1]
a0
[1]
...
[n-2]
[0]
[2]
a n-3
[n-2]
a n-2 [n-1]
a1
a0
[1]
[0]
front = [0]
rear = [0]
front = [0]
rear = [2]
front = [0]
rear = [n-1]
(a) 공백 원형 큐
(b) 2개의 원소 저장
(c) 만원 원형 큐
1차원 배열을 원형으로 유지하는 방법

mod(modulus) 연산자 이용
 삽입을 위해 먼저 rear를 증가시킬 때 : rear  (rear+1) mod n
 rear 값은 n-1 다음에 n이 되지 않고, 다시 0으로 되돌아감
 삭제를 위해 front를 증가시킬 때 : front  (front+1) mod n
 rear와 마찬가지로, front 값은 n-1 다음에 0이 되어 원형으로 순환
© DBLAB, SNU
큐의 순차 표현(6)

원형 큐에서의 enqueue와 dequeue 연산
enqueue(q, item)
// 원형 큐(q)에 item을 삽입
rear ← (rear+1) mod n;
// 원형 큐(q) 인덱스
if (front = rear) then queueFull(); // 큐(q)가 만원인 상태를 처리
q[rear] ← item;
end enqueue()
dequeue(q)
// 원형 큐(q)에서 원소를 삭제하여 반환
if (front = rear) then queueEmpty() // 큐(q)가 공백인 상태를 처리
else {front ← (front+1) mod n;
// 원형 인덱스
return q[front]
};
end dequeue()
© DBLAB, SNU
배열을 이용한 큐의 구현(1)

큐 ADT의 구현 방법



Java에서 지원하는 interface : 메소드에 대한 선언만 함
실제 구현 : 메소드를 사용하는 클래스에 위임
Queue interface 정의
public interface Queue {
boolean isEmpty(); // 큐가 공백인가를 검사
void enqueue(Object x); // 원소 x를 삽입
Object dequeue(); // 원소를 삭제하고 반환
void remove(); // 원소를 삭제
Object peek(); // 원소값만 반환
}
© DBLAB, SNU
배열을 이용한 큐의 구현(2)

배열을 이용하여 원형 큐를 구현하는 ArrayQueue
클래스 정의(1)
public class ArrayQueue implements Queue {
// 배열을 이용한 Queue interface의 구현
private int front;
// 큐의 삭제 장소
private int rear;
// 큐의 삽입 장소
private int count; // 큐의 원소 수
private int queueSize;
// 큐(배열)의 크기
private int increment;
// 배열의 확장 단위
private Object[] itemArray; // Java 객체 타입의 큐 원소를 위한 배열
public ArrayQueue() {
// 무인자 큐 생성자
front = 0;
// 초기화
rear = 0;
count = 0;
queueSize = 50; // 초기 큐 크기
increment = 10; // 배열의 확장 단위
itemArray = new Object[queueSize];
}
public boolean isEmpty(){
return (count == 0);
}
© DBLAB, SNU
배열을 이용한 큐의 구현(3)

배열을 이용하여 원형 큐를 구현하는 ArrayQueue
클래스 정의(2)
public void enqueue(Object x) {
// 큐에 원소 x를 삽입
if (count == queueSize) queueFull();
itemArray[rear] = x; // 원소를 삽입
rear = (rear + 1) % queueSize;
count++;
} // end enqueue( )
public void queueFull() {
// 배열이 만원이면 increment만큼 확장
int oldsize = queueSize;
// 현재의 배열 크기를 기록
queueSize += increment;
// 새로운 배열 크기
Object[] tempArray = new Object[queueSize]; //확장된크기의임시배열
for (int i = 0; i < count; i++) {
// 임시 배열로 원소들을 그대로 이동
tempArray[i] = itemArray[front];
front = (front + 1) % oldsize
}
itemArray = tempArray;
// 배열 참조 변수를 변경
front = 0;
rear = count;
} // end queueFull()
© DBLAB, SNU
배열을 이용한 큐의 구현(4)

배열을 이용하여 원형 큐를 구현하는 ArrayQueue
클래스 정의(3)
public Object dequeue( ){// 큐에서 원소를 삭제해서 반환
if (isEmpty()) return null;
// 큐가 공백일 경우
// 큐가 공백이 아닌 경우
Object item = itemArray[front];
front = (front + 1) % queueSize;
count --;
return item;
} //end dequeue()
public Object remove( ){// 큐에서 원소를 삭제
if (isEmpty()) return null; // 큐가 공백일 경우
// 큐가 공백이 아닌 경우
front = (front + 1) % queueSize;
count --;
} //end remove()
public Object peek( ) { // 큐에서 원소값을 반환
if (isEmpty()) return null;
else return itemArray[front];
} // end peek()
} //end ArrayQueue class
© DBLAB, SNU
6.4 큐의 연결 표현(1)

연결리스트로 표현된 큐


여러 개의 큐를 동시에 필요로 하는 경우에 효율적
연결 큐(linked queue)의 구조
 단순 연결 리스트를 두 개의 포인터 변수 front, rear로 관리
 초기화 : front = rear = null (공백큐)
 큐의 공백 여부 : front 또는 rear가 null인지 검사를 통해 알 수 있음
rear
front
data
link
null
© DBLAB, SNU
큐의 연결 표현(2)

연결 큐에서의 삽입, 삭제, 검색 연산 구현(1)
enqueue(q, item)
// 연결 큐(q)에 item을 삽입
newNode ← getNode();
// 새로운 노드를 생성
newNode.data ← item;
newNode.link ← null;
// 삽입되는 노드의 link 필드는 항상 null
if (rear = null) then {
// 큐(q)가 공백인 경우
rear ← newNode;
front ← newNode;
}
else {
rear.link ← newNode;
rear ← newNode;
}
end enqueue()
dequeue(q)
// 큐(q)에서 원소를 삭제하고 값을 반환
if (front = null) then queueEmpty(); // 큐(q)가 공백인 경우
else {
oldNode ← front;
item ← front.data;
front ← front.link;
if (front = null) then rear ← null; // 삭제로 인해 큐(q)가 공백이 된 경우
retNode(oldNode);
return item;
}
end dequeue()
© DBLAB, SNU
큐의 연결 표현(3)

연결 큐에서의 삽입, 삭제, 검색 연산 구현(2)
delete(q)
// 큐(q)에서 원소를 삭제
if (front = null) then queueEmpty(); // 큐(q)가 공백인 경우
else {
oldNode ← front;
front ← front.link;
if(front = null) then rear ← null; // 삭제로 인해 큐(q)가 공백이 된 경우
retNode(oldNode);
}
end delete()
peek(q)
// 큐(q)의 front 원소를 검색
if (front = null) then queueEmpty(); // 큐(q)가 공백인 경우
else return (front.data);
end peek()
© DBLAB, SNU
큐의 연결 표현(4)

연결큐의 특징





삽입, 삭제로 인한 다른 원소들의 이동이 필요 없음
연산이 신속하게 수행
여러 개의 큐 운영시에도 연산이 간단
링크 필드에 할당하는 추가적인 저장 공간 필요
k개의 큐를 사용



큐0, 큐1, 큐2, …, 큐k-1
각 큐에 대한 front와 rear : 배열 front[i], rear[i]를 사용
초기화
 front[i]  null; 0≤i<k
 rear[i]  null; 0≤i<k
© DBLAB, SNU
큐의 연결 표현(5)

k개의 큐에서의 삽입, 삭제, 검색 연산 구현(1)
enqueue(i, item)
// 큐 i에 item을 삽입
newNode ← getNode();
newNode.data ← item;
newNode.link ← null;
if (front[i] = null) then { // 큐 i가 공백인 경우
front[i] ← newNode;
rear[i] ← newNode;
}
else {
// 큐 i가 공백이 아닌 경우
rear[i].link ← newNode;
rear[i] ← newNode;
}
end enqueue()
dequeue(i)
// 큐 i에서 원소를 삭제하고 값을 반환
if (front[i] = null) then queueEmpty(); // 큐 i가 공백인 경우
else {
oldNode ← front[i];
item ← front[i].data;
front[i] ← front[i].link;
if(front[i] = null) then rear[i] ← null; // 큐 i가 공백이 된 경우
retNode(oldNode); // 노드를 가용 공간 리스트에 반환
return item;
}
end dequeue()
© DBLAB, SNU
큐의 연결 표현(6)

k개의 큐에서의 삽입, 삭제, 검색 연산 구현(2)
delete(i)
// 큐 i에서 원소를 삭제
if (front[i] = null) then queueEmpty();
else {
oldNode ← front[i];
front[i] ← front[i].link;
if(front[i] = null) then rear[i] ← null;
retNode(oldNode);
}
end delete()
peek(i)
// 큐 i에서 원소 값을 검색
if (front[i] = null) then queueEmpty();
else return (front[i].data);
end peek()
© DBLAB, SNU
리스트를 이용한 큐의 구현(1)

먼저 노드의 구조를 결정 : ListNode 클래스
public class ListNode {
Object data;
ListNode Link;
}
© DBLAB, SNU
리스트를 이용한 큐의 구현(2)

큐를 구현한 연결 리스트 표현
front
rear
count
n
data
link
data
X1
X2
link
…
data
link
Xn
null
공백이 아닌 큐를 구현한 연결 리스트 표현
front
front
rear
count
null
null
0
공백 큐를 구현한 연결 리스트 표현
© DBLAB, SNU
rear
count
1
data
link
X1
null
하나의 노드를 가진 큐의 연결 리스트 표현
리스트를 이용한 큐의 구현(3)

연결 리스트로 큐를 구현한 ListQueue 클래스(1)
public class ListQueue implements Queue {
// 연결 리스트를 이용한 Queue interface의 구현
private ListNode front;
// 큐에서의 front 원소
private ListNode rear;
// 큐에서의 rear 원소
private int count;
// 큐의 원소 수
public ListQueue() {
// 공백 큐를 생성
front = null;
rear = null;
count = 0;
}
public boolean isEmpty() {
return (count == 0);
}
© DBLAB, SNU
리스트를 이용한 큐의 구현(4)

연결 리스트로 큐를 구현한 ListQueue 클래스(2)
public void enqueue(Object x) {
// 큐에 원소 x를 삽입
ListNode newNode = new ListNode();
newNode.data = x;
newNode.link = null;
if (count == 0) { // 큐(리스트)가 공백인 경우
front = rear = newNode;
} else {
rear.link = newNode;
rear = newNode;
}
count++;
} // end enqueue()
public Object dequeue() {
// 큐에서 원소를 삭제하고 반환
if (count == 0) return null;
Object item = front.data;
front = front.link;
if (front == null) { // 리스트의 노드를 삭제 후 공백이 된 경우
rear = null;
}
count-- ;
return item;
} // end dequeue()
© DBLAB, SNU
리스트를 이용한 큐의 구현(5)

연결 리스트로 큐를 구현한 ListQueue 클래스(3)
public void remove() {
// 큐에서 원소를 삭제
if (count == 0) return null;
front = front.link;
if (front == null) { // 리스트의 노드를 삭제 후 공백이 된 경우
rear = null;
}
count-- ;
} // end remove()
public Object peek() {
if (count == 0) return null;
else return front.data;
} // end peek()
} // end ListQueue class
© DBLAB, SNU
우선 순위 큐(1)

우선 순위 큐(priority queue)

원소에 부여된 우선 순위에 따라 우선 순위가 가장 높은
원소부터 삭제하는 자료 구조

스택과 큐도 우선 순위 큐의 일종
 스택 : 삽입 시간이 가장 짧은 원소에 가장 높은 우선 순위를
부여한 우선 순위 큐
 큐 : 삽입 시간이 가장 오래된 원소에 가장 높은 우선 순위를
부여한 우선 순위 큐

원소의 우선 순위 표현과 연산
 보통 우선 순위 key 값을 사용
 삭제시 : 우선 순위가 가장 높은 원소가 제일 먼저 삭제
 삽입 : 우선 순위와 관계없이 임의의 순서로 언제나 수행
© DBLAB, SNU
우선 순위 큐(2)

우선 순위 큐(priority queue) 추상 데이타 타입
ADT PriorityQueue
데이타 :
우선순위를 가진 0개 이상의 원소로 된 수집(collection)
연산 :
pQ ∈ PriorityQueue; item ∈ Element;
createQ() ::= create an empty priority queue;
length(pQ) ::= return the number of items in pQ;
insert(pQ, item) ::= insert the item into pQ;
delete(pQ) ::= if (isEmpty(pQ)) then return error
else {delete the item with the highest priority from pQ};
End PriorityQueue
© DBLAB, SNU
우선 순위 큐(3)

원소들의 비교 연산

우선 순위 큐의 전체 순서(total order) 관계 성립
 1) 반사적(reflexive) 성질 : ki ≤ ki
 2) 반대칭(antisymmetric) 성질 : k1 ≤ k2 이고 k2 ≤ k1 이면, k1 = k2
 3) 이행적 성질(transitive) : k1 ≤ k2 이고 k2 ≤ k3 이면, k1 ≤ k3


우선 순위 큐의 모든 원소 : 우선 순위에 따라 일렬로 정렬
Java에서의 우선 순위 큐


우선 순위 큐의 응용 예
우선 순위 큐의 구현
 정렬된 연결 리스트로 구현
 무정렬 배열을 이용한 구현

범용 Java우선 순위 큐 프로그램
© DBLAB, SNU
Java에서의 우선순위 큐

인터페이스 PQmethods의 정의
public interface PQmethods {
// 우선순위 큐가 구현해야 될 메소드들의 선언
int currentSize();
// 현재 우선순위 큐에 저장되어 있는 원소 수를 반환
void insert(e);
// 우선순위 큐에 원소 e를 삽입
PriorityKey delete();
// 우선순위 큐에서 원소를 삭제하여 반환
}

PriorityQ 클래스의 메소드 호출 형식
pQ = new PriorityQ(); // 공백 우선순위 큐 pQ의 생성
n = pQ.currentSize(); // 정수 변수 n에 현재 우선순위 큐의 원소 수를 지정
pQ.insert(e); // 우선순위 큐 pQ에 원소 e를 삽입
e = pQ.delete(); // 우선순위 큐 pQ에서 우선순위가 제일 높은 원소를 삭제하여 반환
© DBLAB, SNU
우선순위 큐의 응용 예

우선 순위 큐 정렬 메소드

우선 순위 큐 정렬(priority queue sorting)을 구현
void pQsort(PriorityKey[] a) {
// 배열 a[]의 원소들을 우선순위 값에 따라 오름차순으로 정렬
int i;
// 정수 인덱스 변수
int n = a.length;
// 정렬할 배열 a[]의 길이
PriorityQ pQ = new PriorityQ();
// PriorityQ는 뒤에서 정의된 우선순위 큐 클래스로서
// 여기서는 원소가 없는 PriorityQ 객체 pQ를 생성
for (i = 0; i < n; i++)
// 배열 a[]의 원소를 전부 우선순위 큐 pQ에 삽입
pQ.insert(a[i]);
for (i = n-1; i >= 0; i--)
// 우선순위 큐 pQ의 모든 원소를 다시 배열 a[]에 삽입
a[i] = pQ.delete();
} // end pQsort()
© DBLAB, SNU
덱(1)

덱(deque : double-ended queue)



스택과 큐의 성질을 종합한 순서 리스트
삽입과 삭제가 리스트의 양끝에서 임의로 수행될 수 있는
자료구조
스택이나 큐 ADT이 지원하는 연산을 모두 지원
© DBLAB, SNU
덱(2)

덱의 추상 데이타 타입(ADT)
createDeque() ::= create an empty deque;
insertFirst(Deque,e) ::= insert new element e at the beginning of Deque;
insertLast(Deque,e) ::= insert new element e at the end of Deque;
isEmpty(Deque) ::= if Deque is empty then return true
else return false;
deleteFirst(Deque) ::= if isEmpty(Deque) then return null
else remove and return the first element of Deque;
deleteLast(Deque) ::= if isEmpty(Deque) then return null
else remove and return the last element of Deque;
removeFirst(Deque) ::= if isEmpty(Deque) then return null
else remove the first element of Deque;
removeLast(Deque) ::= if isEmpty(Deque) then return null
else remove the last element of Deque;
peekLast(Deque) ::= return the last element of Deque;
peekFirst(Deque) ::= return the first element of Deque;
© DBLAB, SNU
덱(3)

공백 덱에 대한 일련의 연산 수행
연산
insertFirst(Deque,3)
insertFirst(Deque,5)
deleteFirst(Deque)
insertLast(Deque,7)
deleteFirst(Deque)
deleteLast(Deque)
insertFirst(Deque,9)
insertLast(Deque,7)
insertFirst(Deque,3)
insertLast(Deque,5)
deleteLast(Deque)
deleteFirst(Deque)
© DBLAB, SNU
덱(Deque)
(3)
(5, 3)
(3)
(3, 7)
(7)
()
(9)
(9, 7)
(3, 9, 7)
(3, 9, 7, 5)
(3, 9, 7)
(9, 7)
덱(4)

스택과 큐 ADT 연산에 대응하는 덱의 연산

스택 ADT 연산에 대응하는 연산
스택 연산

덱 연산
createStack()
createDeque()
push(S,e)
insertLast(Deque,e)
isEmpty(S)
isEmpty(Deque)
pop(S)
deleteLast(Deque)
remove(S)
removeLast(Deque)
peek(S)
peekLast(Deque)
큐 ADT 연산에 대응하는 연산
큐 연산
© DBLAB, SNU
덱 연산
createQ()
createDeque()
enqueue(Q,e)
insertLast(Deque,e)
isEmpty(Q)
isEmpty(Deque)
dequeue(Q)
deleteFirst(Deque)
remove(Q)
removeFirst(Deque)
peek(Q)
peekFirst(Deque)