정렬(Sort) 2

내용

Merge sort algorithm

Quick sort algorithm

Binary search tree

 Merge Sort
• 이미 정렬된 두 개의 배열을 정렬하여 하나로 만듦

• Recursive 및 non-recursive 알고리즘을 이용하

여 응용

• 알고리즘 : 주어진 배열 A, B로부터 C를 만듦

a. A 와 B에서 작은 값을 선택하여 C로 이동

b. A 또는 B가 empty이면 empty가 아닌 값들을 순서대

로 C로 이동
 Merge Two Sorted Lists
• 초기

A = (2, 5, 6), B = (1, 3, 8, 9, 10) ⇒C = ()

• A 와 B에서 작은 값을 선택하여 C로 이동

a. A = (2, 5, 6), B = (3, 8, 9, 10) ⇒C = (1)

b. A = (5, 6), B = (3, 8, 9, 10) ⇒ C = (1, 2)

c. A = (5, 6), B = (8, 9, 10) ⇒ C = (1, 2, 3)

d. A = (6), B = (8, 9, 10) ⇒ C = (1, 2, 3, 5)

e. A = (), B = (8, 9, 10) ⇒ C = (1, 2, 3, 5, 6)

• A 또는 B가 empty이면 empty가 아닌 값들을 순서대로 C로

이동

a. A = (), B = () ⇒ C = (1, 2, 3, 5, 6, 8, 9, 10)

 Merge Two Sorted Lists

• |A|=m, |B|=n 이면

– 값을 배열 C로 옮기는데 O(1)

– 총 정렬 시간은 O(n + m)
 Merge Sort
• 정렬이 안된 배열

a. 배열을 2로 나누어 부 배열의 크기가 1이 될 때까지 나

눔

b. 크기가 1인 두 배열을 merge하여 정렬된 크기가 2인

배열로 만듦

c. 위 과정을 원래의 배열의 크기가 얻어질 때까지 반복

• Complexity: O(n log n)

 Merge Sort

MergeSort(A[], m, n){
if (A[m : n]의 원소수 > 1) then {
divide A[m : n] into A[m : mid] and A[mid+1 : n];
MergeSort(A[], m, mid);
MergeSort(A[], mid+1, n);
Merge(A[], m, mid, n);
}
}

 Merge Sort
list sorted[];
Merge(A[], left, mid, right){
i = left; j=mid+1; k=left
while(i<=mid && j<=right){
if(A[i]<=A[j])
sorted[k++]=A[i]; i++;
else
sorted[k++]=A[j]; j++;
}
if(i>mid) sorted[k...,right] ← A[j...right]
else sorted[k...,mid] ← A[i...mid]

A[left...right]<-sorted[left...right];
}

 Merge Sort

[8, 3, 13, 6, 2, 14, 5, 9, 10, 1, 7, 12, 4]

[8, 3, 13, 6, 2, 14, 5] [9, 10, 1, 7, 12, 4]

[8, 3, 13, 6] [2, 14, 5] [9, 10, 1] [7, 12, 4]

[8, 3] [13, 6] [2, 14] [5] [9, 10] [1] [7, 12] [4]
[8] [3] [13] [6] [2] [14] [9] [10] [7] [12]
 Merge Sort

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13,14]

[2, 3, 5, 6, 8, 13, 14] [1, 4, 7, 9, 10,12]

[3, 6, 8, 13] [2, 5, 14] [1, 9, 10] [4, 7, 12]

[3, 8] [6, 13] [2, 14] [5] [9, 10] [1] [7, 12] [4]
[8] [3] [13] [6] [2] [14] [9] [10] [7] [12]
 Merge sort
• t(n) : 크기 n의 배열의 merge sort에 소요되는 시간

– t(0) = t(1) = c, c : 상수

– n > 1이면

t(n) = t(ceil(n/2)) + t(floor(n/2)) + dn, d : 상수

• n = 2k 이라 가정하면

– t(n) = O(n log n) = O(nk)

 Quick Sort
• 주어진 배열에서 하나의 키를 선택하여 그 키
를 중심(pivot)이라고 함

• Pivot를 기준으로 배열의 값을 두 subarray로

나눔(divide)

• 그리고, pivot은 정렬될 위치에 move

• 두 subarray의 각각에 대해 pivot를 정하여

다시 배열을 나눔
 Quick Sort
QuickSort(A[], m, n){

// 배열 A[]의 부분 배열 A[m : n]을 오름차순으로 정렬

if (m ≥ n) then return; // 원소 수가 1개 이하면 복귀

p ← partition(A, m, n); // p : pivot의 인덱스

QuickSort(A[], m, p-1);

QuickSort(A[], p+1, n);

}
 Quick Sort
the first element the first element
greater than pivot smaller than pivot
0 1 n-1

X : pivot swap

new pivot X’ X

X’ X

·
·
·
sorted X

 Quick Sort
void QuickSort(int list[], int left, int right) {
int pivot, i, j;
int temp;
if (left < right) {
i = left; j = right + 1;
pivot = list[left];
do {
do{
i++;
} while (list[i] < pivot);

do {
j--;
} while (list[j] > pivot);

if (i < j)
SWAP(list[i], list[j], temp);
} while (i < j);

SWAP (list[left], list[j], temp);

quicksort(list, left, j - 1);
quicksort(list, j + 1, right);
}
}

 Quick Sort
a[]= (26,5,37,1,61,11,59,15,48,19)

R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 left right
26 5 37 1 61 11 59 15 48 19 0 9
11 5 19 1 15 26 59 61 48 37 0 4
1 5 11 19 15 26 59 61 48 37 0 1
1 5 11 19 15 26 59 61 48 37 3 4
1 5 11 15 19 26 59 61 48 37 6 9
1 5 11 15 19 26 48 37 59 61 6 7
1 5 11 15 19 26 37 48 59 61 9 9
1 5 11 15 19 26 37 48 59 61
 Quick Sort
• T(n): average time to sort N elements

T(N) ≤ c· N + 2·T(N /2)

≤ c· N + 2(c· N /2 + 2·T(N/4))

≤ 2·c· N + 4·T(N /4)

···

≤ c· N ·log N + N ·T(1)

2
= O(N ·log N)

• worst case: O(N 2), 이미 정렬된 경우

 Binary Search Tree
• 이진 정렬 트리와 중위 우선 순회 방법을 사용한 정렬 방법

- 이진정렬트리(binary sort tree) : 키 값이 중복되는 원소를 허용한다는

점만 다르고 이진 탐색트리와 동일

• 방법

– 배열을 이진 정렬 트리에 삽입

• 동일한 키값의 원소 허용

• 루트와 같은 키값은 오른쪽 서브트리에 삽입

– Indorder 탐색 방법으로 원소를 하나씩 검색하여 원래의 배열에 저장

– 시간 복잡도 : O(nlogn)
 Binary Search Tree

• 배열 a[]의 binary tree 구성을 이용

• left subtree의 node는 parent 보다 작은 값을

right subtree의 node는 큰 값을 갖음

• 구성된 binary tree의 infix order는 정렬된 배열을

구성
 Binary Search Tree
SearchTree Insert( ElementType X, SearchTree T ){

if( T == NULL ) {

/* Create and return a one-node tree */

SearchTree T;
T = malloc( sizeof( struct BTreeNode ) );

if( T == NULL )

FatalError( "Out of space!!!" );

// make T empty
else {

T = MakeEmpty( NULL );
T->Element = X;

T->Left = T->Right = NULL;

// insert a set of data into T

}

} else if( X < T->Element )

for( i = 0; i < gaesoo; i++ )

T->Left = Insert( X, T->Left );

T = Insert( a[i], T ); else if( X > T->Element )

T->Right = Insert( X, T->Right );

return T;

}
 Binary Search Tree
A[] = {50, 17, 66, 19, 5, 60, 92, 80, 1, 13 }
50

17 66
60 92
5 19
1 13 80
 Binary Search Tree
50,17,66,19,5,60,92,80,1,13 50

50,17,66,19,5,60,92,80,1,13 50
17
50
50,17,66,19,5,60,92,80,1,13
17 66
50
50,17,66,19,5,60,92,80,1,13 17 66
19
 Binary Search Tree
50
50,17,66,19,5,60,92,80,1,13
17 66
5 19

50
50,17,66,19,5,60,92,80,1,13 17 66
5 19 60
 Binary Search Tree
50
50,17,66,19,5,60,92,80,1,13
17 66
5 19 60 92
50
17 66
50,17,66,19,5,60,92,80,1,13 5 19 60 92

80
 Binary Search Tree
50
50,17,66,19,5,60,92,80,1,13
17 66
5 19 60 92
1
50 80
50,17,66,19,5,60,92,80,1,13
17 66
5 19 60 92
1 13
80
 Binary Search Tree

• Tree construction

– Worst case : O(N2), skewed binary tree

– Best case : O(h∙N), complete binary tree

 정리

• Sorting algorithm

– Binary search tree

– Quick sort

– Merge sort

• Worst case complexity : O(n log n)