?(Key) : ???? ???? ??? ???? ??

1
?? (1)

• ?? ??
• ??? ?? ??? ??? ? ???? ??
• ?(Key) ???? ???? ??? ???? ??
• ?? ?? (Sequential Search)
• ??? ???? ???? ??? ?? ????? ???? ???? ???? ?

2
??? ???

• ??? ? ?? ??? ???
• (1) ???? ??? ??
• (2) ???? ???? ???? ???? ??
• ?? ??
• (1) ?? ?? (internal methods)
• ??? ???? ??? ???? ??? ?? ??? ??? ??? ? ?? ? ??
• (2) ?? ?? (external methods)
• ? ???? ??

3
?? ?? (1)

• ??? ???? i?? ??? ??? ???? ?? ?? ??? i1? ??? ??
  ??? ???? ???.

void insert(element e, element a, int i) / e?
??? ??? a1i? ???? ?? ??? a1i1? ????
??. ?? a? ??? i2 ??? ??? ??? ??? ??? ??.
/ a0 e while(e.key ltai.key)
ai1 ai i--
ai1 e
??? ???? ??
4
?? ?? (2)
void insertionSort(element a, int n) /
a1n? ??? ? ???? ?? / int j for(j
2 j lt n j) element temp
aj insert(temp, a, j-1)
?? ??

• insert(e, a, i)? ??? ?? ?? ? i1? ???? ?
• insert? ??? O(i)
• insertionSort? ???
• i j-1 1,2,...,n-1? ? insert? ??
• ??? O( ) O(n2)

5
?? ?? (3)

• ?? ??? ??? ?
• n 5, ?? ? ?? 5, 4, 3, 2, 1
• ?? ???? ????? ??? ???? ??? ??? ??? ??? ?? ??? ???
  ????? ??

6
?? ?? (4)

• n 5, ?? ? ??? 2, 3, 4, 5, 1? ??
• j 2, 3, 4? ?? ?? O(1)
• j 5? ?? ?? O(n)
• insertionSort? ???
• ?? n(?? ??, n30)? ?? ?? ?? ?? ??

7
?? ?? (5)

• ?? ??? ??
• ?? ?? ??
• insert(???? 7.4)?? ??? ?? ?? ?? ?? ?? ??? ??
• ?? ???? ???? ?? ??? ???
• ??? ?? ??? ??? ??
• ?? ?? ??
• ???? ???? ?? ?? ?? ???? ??
• ?? ??? ???? ??? ??? ?? ??? 0
• insert?? ??? ?? ??? ??? ??

8
? ?? (1)

• ?? ??? ?? ?? ?? ??
• ? ??(Quick Sort) ??
• (1) ??? ??? ? ??(pivot??) ???? ??
• (2) ??? ????? ?? ??
• ??? ?? ??? ??? ??? ?? ????? ?? ??
• ??? ??? ??? ??? ??? ?? ????? ?? ??
• (3) ? ??? ????? ??
• ??? ??? ???? ????? ?? ????? ????

9
? ?? (2)
void quickSort(element a, int left, int
right) / aleftright? ??? ? ???? ????.
aleft.key? ???? ??? ????. aleft.key
aright1.key?? ????. / int pivot, i, j
element temp if(left lt right)
i left j right 1 pivot
aleft.key do / ?????? ???? ?????
????? left? right ???
????? ?? ??? out-of-order
???? swap?? / do i
while(ai.key lt pivot) do j--
while(aj.keky gt pivot) if(i lt
j) SWAP(ai, aj,temp) while(i lt
j) SWAP(aleft, aj,temp)
quickSort(a, left, j-1)
quickSort(a, j1, right)
? ??
10
? ?? (3)

• ? (26, 5, 37, 1, 61, 11, 59, 15, 48, 19)? ?? 10??
  ???? ? ???? ? ??? ???? ??

R1
R2
R3
R4
R5
R6
R7
R8
R9
R10
left
right
26
5
37
1
61
11
59
15
48
19
1
10
11
5
19
1
15
26
59
61
48
37
1
5
1
5
11
19
15
26
59
61
48
37
1
2
1
5
11
19
15
26
59
61
48
37
4
5
1
5
11
15
19
26
59
61
48
37
7
10
1
5
11
15
19
26
48
37
59
61
7
8
1
5
11
15
19
26
37
48
59
61
10
10
1
5
11
15
19
26
37
48
59
61
quickSort? ??? ???? ??? ?? ???? ???? ??? ??????
???
11
? ?? (4)

• quickSort? ??
• ??? ?? ??? O(n2)
• ? ???? ??? ??? ??? ??? ? ????
• ??? ???? ????? ??? ?? ??
• ??? n/2? ? ?? ?????? ???? ??? ??
• ??? n? ????? ? ???? ????? ? ??? ?? O(n)

T(n) cn 2T(n/2) ?? ?? c?
??? cn 2(cn/2 2T(n/4)) 2cn
4T(n/4) . .
. cnlog2n nT(1) O(nlog2n)

• ?? ?? ?? O(nlogn)

12
? ?? (7)

• ? ??? ?? ??
• ? ??? ??(recursion)? ???? ?? ?? ?? ??
• ???? ???? ??? ??
• ?? ?? ??? log n? ?? ?? ???? O(log n) ??
• ??? ??
• ??? ? ????, ??? n-1? ?? ?? ???? ??? 0? ??? ??????
  ???? ??? ??
• ?? ??? n? ?? ?? ???? O(n) ??
• ?? ?? ??? ?????? ?? ???? ?? ??? ????? ???? ? ??.

13
?? ?? (1)

• ??(Merging)
• ??? ??? ???? ??? ??? ???? ??

void merge(element initList, element
mergedList, int i, int m, int n) /
initList1m? initListm1n? ??? ???.
??? ??? ??? mergedListin?? ????./ int
j,k,t j m1 k i
while( i lt m j lt n) if
(initListi.key lt initListj.key)
mergeListk initListi
else mergeListk
initListj if (i gt m)
/ mergedListkn initListjn/
for(t j t lt n t)
mergeListt initListt else
/ mergedListkn initListim /
for(t i t lt m t)
mergeListpkt-i initListt
???? O(n-l1) n-l1 ??? ??? ?
14
?? ?? (2)

• ?? ?? ??(Iterative Merge Sort)
• ?? ???? ??? 1? n?? ??? ?????? ??
• ?? ?? ?? ??
• ??? ?? ?? ????? ??? ???? ??? 2? n/2?? ???? ???.
• n? ???? ??? ??? ??? 1
• ??? ?? ?? n/2?? ???? ?? ??? ???? n/4?? ????
  ???.
• ?? ??? ??? ?? ???? ?? ??? ????.
• ?? ??? ??? ?? ???? ?? ??? ????.

15
?? ?? (3)

• ?? ?? ??? ?
• ?? ??? (26, 5, 77, 1, 61, 11, 59, 15, 48, 19)

26
5
77
1
61
11
59
15
48
19
5 26
1 77
11 61
15 59
19 48
1 5 26 77
11 15 59 61
19 48
1 5 11 15
26 59 61 77
19 48
1 5 11 15
19 26 48 59
61 77
? ???? ???? ?????? ?? ??? ??? ?
16
?? ?? (4)

• ?? ??? ?? ?? ?? ??(pass)? ????.

void mergePass(element initList, element
resultList, int n, int s) / ??? s? ?????? ??
??? // initList???? resultList? ????. n?
initList? ?? ??? ???. for(i 1 i lt
n-2s1 i 2s) merge(initList,
mergedList, i, is-1, i2s-1)
if((is-1)ltn) merge(initList, mergedList, i,
is-1, n) else for(ji
j lt n j) mergedListj
initListj
?? ??
17
?? ?? (5)
void mergeSort(element a, int n) int s
1 / ?? segment ?? / element
extraMAX_SIZE while (sltn)
mergePass(a, extra, n, s) s
2 mergePass(extra , a, n , s)
s 2

• mergeSort ??
• i?? ?? ??? 2i-1? ???? ??
• ? ??? ???? ????.
• ??? ? ??? ??? ?? O(n)
• ? ?? ?? O(nlogn)

18
?? ?? (6)

• ?? ?? ?? (Recursive Merge Sort)
• ??? ???? ?? ??? ? ?? ???.
• left ?????? right ?????
• ??????? ????? ????.
• ??? ??????? ????.

19
?? ?? (7)

• ??? ?? ??? ?? ??? ??
• ?? ??? (26, 5, 77, 1, 61, 11, 59, 15, 49, 19)

26
5
77
1
61
11
59
15
48
19
5 26
11 59
5 26 77
11 15 59
19 48
1 61
1 5 26 61
77
11 15 19 48
59
1 5 11 15
19 26 48 59
61 77
20
?? ?? (7)

• ??? ?? ??? ?? ??? ??
• ? ?? ?????? ???
• left ,
  1 right
• ?? ?? link1n? ??
• ?? merge? ??? ? ???? ??? ??? ???? ??? ?? ???? ?
  ???? ?? ??? ??
• listi - ??? ??????? ??? i??? ?? ???
• ? ??? ???? ??? ??? ?? ???? ???? ?? ??? ?? ??? ???
  ?? s? ???? ?
• ??? ?? ?? O(n)
• ? ??? ?? ??? O(snlogn) ??? O(sn) ?? ?? ??
• ?? ??? ???? ?? ??? ????? ????? ??? ???? ??? ??

21
?? ?? (8)

• ?? ?? ?? ??

int rmergeSort(element a, int link, int left,
int right) // ??? ???? aleftright. ???
linki? ?? i? ?? 0??. // rmergeSort? ??? ???
??? ??? ???? ????. if(left gt right) return
left int mid (left right)/2
return listMerge(a, link, rmergeSort(a, link,
left, mid), //?? ?? ??
rmergeSort(a, link, mid1, right))
// ??? ?? ??
?? ?? ??

• rMergeSort? ??
• ?? ??? ?? ??
• ???
• ?? ?? O(nlogn)

22
?? ?? (9)
int listMerge(element a, int link, int
start1, int start2) // start1? start2?? ????
??? ??? ????. // link0? ?? ??? ????. ??? ???
??? ????. int last1, last2, lastResult0 //
?? ??? ??? ??? for(last1 start1, last2
start2 last1 last2 ) if(alast1 lt
alast2) linklastResult
last1 lastResult last1 last1
linklast1 else
linklastResult last2
lastResult last2 last2 linklast2
// ??? ????? ?? ??? ?? if(last1
0) linklastResult last2 else
linklastResult last1 return link0
??? ??? ??
23
?? ?? (10)

• ?? ??? ??
• ?? ?? ?? (Natural Merge Sort)
• ?? ??? ?? ?? ???? ?? ??? ??
• ?? ???? ?? ???? ?????? ??? ? ??? ?? ??? ???? ?

26
19
11 59
15 48
1 61
5 26
5 26 77
15 19 48
1 11 59 61
1 5 11 26
59 61 77
15 19 48
1 5 11 15
19 26 48 59
61 77
?? ?? ??
24
?? ?? (1)

• ?? ??? ???
• ??? ??? ?? ???? ?? ??? ??? ??
• ?? ??(heap sort)
• ??? ?? ?? ??? ??? ??
• ??? ?? ?? ??? ?? ?? ?? O(nlogn)
• ?? ???? ?? ??
• ??-?? ?? ??
• ??-??? ??? ??, ?? ?? O(nlogn) ?? ??
• adjust ?? ?? ?? ??? ???

25
?? ?? (3)
void heapSort(element a, int n) int i,
j element temp for(in/2 igt0 i--)
adjust(a,i,n) for(in-1
igt0i--) SWAP(a1,
ai1,temp) adjust(a, 1, i)

• ?? ??
• adjust? ????? ?? ? ?? ?? ??? ???.
• ??? ??? ???? ??? ???? ????.
• ?? ?? ?? ???? ??? ??? ??? ??? ???? ?
• ??? ??? ?? ? ??? ?????.
• ?? ?? ?? O(nlogn)

26
?? ?? (4)

• ?? ??? ??? ??
• ?? ??? (26, 5, 77, 1, 61, 11, 59, 15, 48, 19)

1
1
77
26
2
3
61
59
2
5
77
3
48
11
26
19
4
5
1
11
59
61
4
5
6
7
6
7
5
15
1
15
48
19
8
9
10
8
9
10
(a) ?? ???? ?? ??? ??? ??
(b) ?? ?? ??? ??? ? (heapSort ??? ??? for ??? ??
?? ?? ?? ??)
27
?? ?? (5)
1
1
61
59
48
59
48
26
2
2
3
3
15
11
26
19
15
11
1
19
4
5
4
5
6
7
6
7
5
1
5
(b) ????8 Sorted 61,77
(a) ????9 Sorted 77
8
9
8
1
26
1
48
19
11
2
3
19
26
2
3
15
1
5
4
5
15
11
1
5
4
5
6
6
7
(d) ????6 Sorted 48,59,61,77
(c) ????7 Sorted 59,61,77
28
?? ?? (6)
1
1
19
15
15
11
5
11
2
2
3
3
1
5
1
(f) ????5 Sorted 19,26,48,59,61,77
(e) ????5 Sorted 26,48,59,61,77
4
5
4
1
11
(g) ????3 Sorted 15,19,26,48,59,61,77
5
1
2
3
29
?? ?? ?? ?? (3)

• LSD(least-significant-digit-first) ??
• ?? ?? ?? ?? ??
• ?? ?? ?(? K2)? ?? 13?? ??? ??
• 3?? 2? ??, king?? queen? ??, ace?? king? ?? ????
• ?? ??? ??? ?? ??? ?? ??? ???? ??(K1)? ?? 4?? ???
  ??
• 4?? ???? ?? ? K2? ?? ???? ?
• 4?? ??? ??
• LSD? MSD?? ? ??
• ??? ??? ?? ??? ????? ??? ??? ???? ????? ?? ??.

30
?? ?? ?? ?? (4)

• ?? (radix) ??
• ?? ?? r? ???? ?? ?? ? ?? ??? ??
• r 10 ?? ???? ??
• r 2 ?? ???? ??
• ??-r ????? r?? ?(bin)? ??
• (why?) ????? ?? ???? R1,...,Rn? ?, ???? ?? ??-r?
  ???? ?? ? 0(r-1) ??? d?? ??? ?? ?? ??.
• ? ?? ???? ?? ? ???? ???? ???? ??? ???? ???? ????
  ?? ???? ????, ??? ??? ??

31
?? ?? ?? ?? (5)
int radixSort(element a, int link, int d, int
r, int n) int frontr, rearr
int i, bin, current, first, last first
1 for(i 1 i lt n i) linki i1
linkn 0 for(id-1 i gt0 i--)
for(bin 0 bin lt r bin)
frontbin 0 for(current first
current current linkcurrent)
bin digitacurrent, i, r)
if(frontbin 0) frontbin
current else linkrearbin
current rearbin
current for(bin bin
lt r bin) if(frontbin)
linklast frontbin last
rearbin linklast 0
return first  
LSD ?? ??
32
?? ?? ?? ?? (6)

• radixSort? ??
• ?? ?? ?? O(d(nr))
• d ??? ????? ? ??? ?? ??? O(nr)?
• d ?? ?? r? ??? ?? ? ?? ?? ???
• r? ??? ???? ?? ??? ????.

33
?? ?? ?? ?? (7)

• ?? ??? ?
• ??? 0, 999? ???? ?? (d3, r10)

a1
a2
a3
a4
a5
a6
a7
a8
a9
a10
179
208
306
93
859
984
55
9
271
33
(a) ?? ??
e1
e2
e3
e4
e5
e6
e7
e8
e9
e0
9
33
859
271
93
984
55
306
208
179
f0
f1
f2
f3
f4
f5
f6
f7
f8
f9
179
93
33
984
55
306
208
179
859
9
(b) ???-?? ?? (First-pass queues) ? ?? ??
34
?? ?? ?? ?? (8)
e1
e2
e3
e4
e5
e6
e7
e8
e9
e0
9
208
179
859
33
984
93
306
271
55
f0
f1
f2
f3
f4
f5
f6
f7
f8
f9
306
208
9
33
55
859
271
179
984
93
(c) ? ??-?? ?? (Second-pass queues) ? ?? ??
35
?? ?? ?? ?? (9)
e1
e2
e3
e4
e5
e6
e7
e8
e9
e0
93
55
33
271
306
208
9
179
859
984
f0
f1
f2
f3
f4
f5
f6
f7
f8
f9
9
33
55
93
179
208
271
306
859
984
(d) ? ??-?? ?? (Third-pass queues) ? ?? ??