๋ฌธ์ ์ ๋ํ ์๊ณ ๋ฆฌ์ฆ์ ์ด๋ค ์์ผ๋ก ๋ถ์ํ ์ง ์ด๋ฏธ ์๊ณ ์๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ๋ถ์ํ๋ ์๊ฐ
Unsorted List ์์ record ํ๋๋ฅผ ์ ํํด์ Sorted List์ ๋ฃ๋๋ค. ๋ฐฉ๋ฐ๋ฅ์ 1๋ถํฐ 100๊น์ง ์ ํ์ ธ์๋ ์ซ์๊ฐ ์๊ณ ์นด๋ ์ซ์๊ฐ ์๋ณด์ธ๋ค๊ณ ๊ฐ์ ํ์. ๋ง์ฝ ๋๊ฐ ์ ๋ ฌํด์ 1๋ถํฐ 100๊น์ง ์ ๋ ฌํด์ ๊ฐ์ ธ์ค๋ผ๊ณ ํ๋ฉด ์ด๋ป๊ฒ ํ ๊ฒ ์ธ๊ฐ? ๋๋ถ๋ถ ์์์ ์นด๋ ํ๋๋ฅผ ์ ํํ๋๋ฐ ์ด๋ ์ด๋ฏธ ์ ๋ ฌ๋ ๊ฐ์ด๊ณ ๋ค์ ์นด๋๊ฐ ์ฒซ ๋ฒ์งธ ์ซ์๋ณด๋ค ํฌ๋ฉด ์ค๋ฅธ์ ์์ผ๋ฉด ์ผ์์ผ๋ก ๋ฃ๋๋ค. ๊ฐ์ ๋ฐฉ๋ฒ์ผ๋ก ์์น์ํค๋ฉด ์ผ์๊ณผ ์ค๋ฅธ์์ ์นด๋๊ฐ ์ ๋ ฌ๋ผ์ ์์นํ ๊ฒ์ด๋ค. ๋
ธ๋์์ Sorted List์ด๊ณ ์ค๋ฅธ์ชฝ์ Unsorted List์ด๋ค. Bar๊ฐ ๊ทธ ์ฌ์ด๋ฅผ ๊ตฌ๋ถํ๋ค๊ณ ํ๋ฉด ๋งจ ์ผ์ชฝ์ ์๋ Element๋ Sorted List์ ์ํ๊ณ ์ด๋ ๊ฒ ์์ํ๊ฒ ๋๋ค. ์์์ Element๋ฅผ Unsorted List์์ ํ๋ ์ ํํ๊ฒ ๋๋๋ฐ Bar์์ ๊ฐ์ฅ ๊ฐ๊น์ด ์๋ ํํฌ์ Element๊ฐ ์ ํ์ด ๋๊ณ ๊ทธ๊ฒ์ Sorted List์ ์ด๋๋ก ๋ค์ด๊ฐ์ผ ํ๋์ง ๊ณ์ ๊ฒฐ์ ํ๊ฒ ๋๋ค. ํ์ง๋ง ๋ ๋ฒ์งธ ์ดํ๋ก Sorted List์์๋ ์ ๋ ฌ์ ์ด๋ป๊ฒ ํ ๊ฒ์ธ๊ฐ! ์ด๋ Comparison ๋ฐฉ๋ฒ์ ํํด์ ํด๋น ์์น์ Change ํ๊ฒ ๋๋ค.
์ด๋ ๊ฒ ์์ด๋์ด๋ฅผ ํตํด์ ์๊ณ ๋ฆฌ์ฆ์ ๋ง๋ค์ด์ผ ํ๋ค. ๋ญ๊ฐ ์ ์ฐจ์ ์ด๊ณ ๋
ผ๋ฆฌ์ ์ด๊ณ ๋ช
ํํ๊ฒ ๊ธฐ์ ์ ํด์ผ ํ๋ค. ํฌ์ธํธ๋ ํ๋์ฉ ํ๋์ฉ Pick์ ์ฎ๊ฒจ ๊ฐ๋ ๊ฒ๊ณผ Sorted List๋ก ์ ์ฐพ์์ Insert ํ๋ ๊ฒ ์ด ๋๊ฐ์ง์ด๋ค. Example: Insertion Sort. ์ผ๋จ Insertํด์ผํ Element๋ฅผ ๋ณต์ฌํด์ Key๋ผ๋ ๋ณ์์ ๋ฃ๋๋ค. ๊ทธ๋ฆฌ๊ณ Key๊ฐ ์์นํ Index๋ j์ ์ ์ฅํด์ j๋ณด๋ค ์์ j-1 ๋ถํฐ ์์ํด์ 1๋ฒ์งธ Index๊น์ง ์ด๋ํ๋ค. ๋น๊ต๋ฅผ ํ๋ค๊ฐ ํด๋น Element๊ฐ Key๊ฐ๋ณด๋ค ํฌ๋ค๋ฉด ๊ณ์ Change๋ฅผ ์งํํ๋ค. i๊ฐ 0์ด ๋๋ฉด ์ ์ผ ์์ Element๋ผ๋ ๊ฒ์ด๋ฏ๋ก while ๋ฌธ์ ํ์ถ์กฐ๊ฑด์ผ๋ก ์ ์ด๋๋๋ค. Key๊ฐ๊ณผ Element๋ฅผ ๋น๊ตํด์ Key๊ฐ์ด Element๋ณด๋ค ์์ ๋์ i = 0์ด ๋์์ ๋ ๋น ์ ธ๋๊ฐ๊ฒ ๋๋ ์กฐ๊ฑด์ ์ค์ ํ๋ฉด ๋๋ค.
Insertion sort
j = 2 ์ผ๋ Key๊ฐ์ ๋ณต์ฌ๋ฅผ ํ๊ณ A[j]๋ฅผ Sorted Array์ ๋ฃ์ด์ผ ํ๋ค. i๋ j-1๋ถํฐ ์์ํด์ผ ํ๊ณ i๊ฐ 1์ฉ ๊ฐ์๋ฅผ ํด์ผ ํ๋ค. ๋ง์ฝ Key๊ฐ Element๋ณด๋ค ํฌ๋ค๋ฉด i+1 ์์น์ i์ ๊ฐ์ ๋ฃ๋๋ค. ํ์ง๋ง ์ฌ๊ธฐ์ i๊ฐ 0๋ณด๋ค ์ปค์ผํ๋ค๋ ์กฐ๊ฑด ๋ํ AND ์กฐ๊ฑด์ผ๋ก ๋ฃ์ด์ผ ํ๋ค. ์๋ํ๋ฉด i๊ฐ 0๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ๊ฒฝ์ฐ์๋ ์ํ์ด ๋๋ค๋ฉด ๋ฒ์๋ฅผ ๋ฒ์ด๋๋ ์ฑ๋ฆฝํ๊ธฐ ๋๋ฌธ์ด๋ค. While์ด ๋๋ฌ์ ๋ Key๊ฐ์ i+1 ์ธ๋ฑ์ค ์์น์ ์ง์ด๋ฃ์ด์ผ ํ๋ค.
<ALgorithm>
์๊ณ ๋ฆฌ์ฆ์ด๋ ๋ฌธ์ ๋ฅผ ํธ๋ ๋ฐฉ๋ฒ์ธ๋ฐ, ์ด ์์
์์ ํ๋ ๊ฒ์ 1. ์๊ณ ๋ฆฌ์ฆ์ ๋์์ธํ๊ณ 2. ์๊ณ ๋ฆฌ์ฆ์ ๋ถ์ํ๋ ๊ฒ์ด๋ค. ์๋ก์ด ๋ฌธ์ ๋ฅผ ์ฃผ๊ณ ์๊ณ ๋ฆฌ์ฆ์ ๋์์ธํด๋ด~ ์ ์์
์ด ์๋๋ผ ์ด๋ฏธ ์กด์ฌํ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋ํ ๋ถ์์ ์งํํ๋ ๊ฒ์ด ์ฃผ๋ชฉ์ ์ด ๋๋ค. ์๊ณ ๋ฆฌ์ฆ์ด๋ ๋๊ฐ์ง๋ก ๋๋๋ค. 1. Correctness์ 2. Efficient์ธ๋ฐ ์ฃผ๋ก Time ๊ณผ Storage ์ธก๋ฉด์์ ์ด์ผ๊ธฐํ๋ ค๊ณ ํ๋ค.
Design paradigm
incremental ๋์์ธ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ๋ค๊ณ ์๊ธฐ๋ฅผ ํ๋ค. Divide-and-conquer approach๋ผ๊ณ ๋ถ๋ฆฐ๋ค. Merge sort๋ฅผ ๋ณด๋ฉด ์ ๋ฐ์ผ๋ก Divideํ๊ณ ๋ฐ๋ฐ์ ๋ค์ ๋ฐ์ผ๋ก ๋๋๊ณ ๊ณ์ Divideํด ๋๊ฐ๋ค. Element๊ฐ ํ๋๊ฐ ๋ ๋๊น์ง Divide๋ฅผ ์งํํ๊ณ ์ด๋ฅผ ๊ฐ๊ฐ Merge๋ฅผ ํ๋ฉด์ ์ ๋ ฌํ๊ฒ ๋๋ค. ํฐ ๋ฌธ์ ๋ฅผ ์ฌ์ด์ฆ๊ฐ ์์ ๋ฌธ์ ๋ก ๋๋๊ณ ๋๋์ด์ง ๊ฒ์ Conquer(Merge)๋ฅผ ์งํํ๋ค. 1๋ถํฐ j-1๊น์ง์ Sorted ๋ SubArray๊ฐ ์๊ณ j๋ฅผ ํ๋๋ ์ง์ด๋ฃ์ด์ ๋ค์ j-1๊ฐ์ ๋น๊ต๋ฅผ ์งํํ๋ค. Divide -> Conquer -> Merge
Other Design paradigms
Brute force ๋ฐฉ์์ ๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ๋ค ๊ณ ๋ คํด์ ์งํํ๋ ๋ฐฉ์์ด๊ธฐ ๋๋ฌธ์ Paradigm์ด๋ผ๊ณ ์๊ธฐํ๊ธฐ๋ ์ด์ง ์ ๋งคํ ๊ฐ์ด ์๋ค!!!
Correctness, ์ณ์์ ํ๋จํ๋ ๊ฒ์ด๊ณ Efficiency๋ Time complexity์ ๋ํด์ ์๊ฐํด๋ณด๋ ๊ฒ์ด๋ค. Storage ๋ถ๋ถ๋ ์๊ธฐํ๊ฒ ๋ ๊ฒ
Correctness
์๊ณ ๋ฆฌ์ฆ์ด correctํ๋ค๋ ๊ฒ์ ๋ชจ๋ Input instance์ ๋ํด์ correct output์ ๋ง๋ค๊ณ ๋ฉ์ถฐ์ผ ํ๋ค. Halt!!) Input instance๊ฐ ํ๋๊ฐ ์๋๋ผ ๊ต์ฅํ ๋ง๋ค. ์๋ฅผ ๋ค์ด ์ํ์ ๊ฒฝ์ฐ ๋ชจ๋ ์์ฐ์์ ๋ํด์, ๋ชจ๋ ์ ์์ ๋ํด์ ๋ฑ๋ฑ ์กฐ๊ฑด์ฒ๋ผ ๋์ผํ๊ฒ ์ ์ฉ์ด ๋๋ค. ์ฃผ์ด์ง ๋ฌธ์ ๋ฅผ Solveํ ์ ์์ด์ผ ํ๋ค.
Loop invariant
Insertion ์๊ณ ๋ฆฌ์ฆ์ด ์ณ๋ค๋ ๊ฒ์ ์ฆ๋ช
ํด์ผ ํ๋ค. ์ด๋ป๊ฒ ์ฆ๋ช
ํ ๊น? ๊ต๊ณผ์์์ Loop invariant๋ฅผ ์ฌ์ฉํด์ ํ์๋ค. Incremental Approach ์ฒ๋ผ ๋
ํนํ ๋ฐฉ์์ ์ธ๊ธํ๋ ๊ฒ์ด์ง ๋ชจ๋ ์ฑ
์์ ๋์ผํ๊ฒ ์๊ธฐํ๋ ๊ฒ์ ์๋๋ผ๋ ๊ฒ์ ์๊ณ ์์ด์ผ ํจ. invariants๋ ๋ณํ์ง ์์์ ์๋ฏธํ๊ณ loop์ ๋๋ฉด์ ๋ณํ์ง ์๋ ์ฑ์ง์ ์ด์ผ๊ธฐ ํ๋ค. Loop์ด ๋์๊ฐ๋๋ผ๋ ๋ฌด์์ธ๊ฐ ๋ณํ์ง๋ง ๋ณํ์ง ์๋ ์ด๋ค ์ฑ์ง์ด ์๊ณ ๊ทธ๊ฒ์ ์ด์ฉํ๋ ๊ฒ์ด๋ค. condition์ด๋ relationship์ธ๋ฐ loop์ด ํ๋ฒ ๋์๊ฐ๋๋ผ๋ ๋ณํ์ง ์๋ ์กฐ๊ฑด๊ณผ ๊ด๊ณ๋ฅผ ์ด์ผ๊ธฐ ํ๋ค.
Loop invariant
1. Initialization. ์ฒซ ๋ฒ์งธ loop์ด ๋์๊ฐ๊ธฐ ์ ์ True์๋ ์ด๋ค ๊ฒ์ ์ด์ฉํ์.
2. Maintenance
3. Termination
Loop์ด ๋์๊ฐ๊ธฐ ์ , ์ค, ํ ๋ชจ๋ True์ธ ๊ฒฝ์ฐ๋ฅผ ์ด์ฉํ๋ค๋ ๊ฒ์ด๋ค.
Correctness of insertion sort
loop invariant. for loop์ด ๋์๊ฐ ๋ ๋ง๋ค 1๋ถํฐ j-1๊น์ง์ ๋ฐฐ์ด์ ์๋๋ถํฐ sorted๋์ด ์๋ค๋ ๊ฒ์ด๋ค. j๊ฐ 2๋ถํฐ ์์ํ๋๋ฐ j๊ฐ 1์ผ ๋ ๊ทธ ํ๋๋ ์๋ ๋ฐฐ์ด์ Element์ด๊ณ Sorted๋ ์ํ์ด๋ค. ๋ค์ j = 3์ ๊ฒฝ์ฐ j =1 , 2 ์ ๊ฐ์ Element์ ์ํ๋ฉฐ Sorted ๋ฐฐ์ด์ด๋ผ๋ ์ . Initialization์ผ ๋๋ j = 2์ธ ๊ฒฝ์ฐ์ด๊ณ Maintenance๋ informallyํ๊ฒ ์ฆ๋ช
์ด ๋์๋ค. ๋ฐ๋ณต๋ฌธ์ Body์ ์ํ๋ ๊ฒ์ด๋ผ๊ณ ๋ณด๋ฉด ๋๋ค. A[j-1], A[j-2], A[j-3]์ผ๋ก ๊ณ์ ์ด๋ํด๋๊ฐ๋ ๊ทธ ๊ณผ์ ์ด๋ค. ๋ง์ง๋ง์ผ๋ก Termination์ j = n+1์ผ ๋ ๋๋๊ฒ ๋๋ค. 1๋ฒ์งธ index๋ถํฐ n๋ฒ์งธ index๊น์ง ๋ชจ๋ ๋ฐฐ์ด์ Element์ด๊ณ Sorted ๋ ๋ฐฐ์ด์ด ๋ง์กฑ๋๋ฏ๋ก Correctnessํ๋ค๋ ๊ฒ์ด๋ค.
Efficiency
์๊ณ ๋ฆฌ์ฆ์ ์ํํ๊ธฐ ์ํ resource, ์๊ฐ๊ณผ ๋ฉ๋ชจ๋ฆฌ์ ๊ดํ ๋ฌธ์ ๋ฅผ ๋ค๋ฃฌ๋ค. ์ฃผ๋ก Input size์ function์ ํ์ํ๋ค. (n์ ๋ํ ํํ) ๋ฉ๋ชจ๋ฆฌ ์ฌ์ด์ฆ๋ ์๊ฐ์ ๋นํด ์ค์ํ๊ฒ ์ฌ๊ฒจ์ง์ง ์๋๋ค. ์ผ๋ฐ์ ์ผ๋ก Time๋ณด๋ค๋ ๋ ์ค์ํ๊ณ ์ฃผ๋ก Time์ ๋ํด์ ์ด์ผ๊ธฐํ๊ฒ ๋๋ค.
Efficiency
์๊ณ ๋ฆฌ์ฆ์ด ํ๋์จ์ด์์ ๋์๊ฐ์ผ ํ๋๋ฐ ์ด๋ค ํ๋์จ์ด์ธ์ง ๋ชจ๋ธ์ ๋ํด์ ์์์ผ ํ๋ค. Random access machine ๋ชจ๋ธ๋ก ์ผ๋ฐ์ ์ผ๋ก ๋ง๋ค์ด์ง ํ๋์จ์ด๋ฅผ ์ด์ผ๊ธฐ ํ๋ค. ๊ธฐ๋ณธ์ ์ผ๋ก RAM์ ๋์์ operation์ด ์ผ์ด๋์ง ์๊ณ Pipeline์ ๋ฐฉ์์ ๋ฐ๋ฅด์ง ์๋๋ค. ํ๋์ Process๊ฐ ์๊ณ Memory์ Instance๊ฐ Sequentialํ๊ฒ ์ํ๋๋ค๋ ๋ง์ด๋ค. ์ผ๋ฐ์ ์ธ ์ปดํจํฐ์ Instruction์ ๊ฐ์ง๊ณ ์๋ค๋ ๊ฒ์ด๋ค. Arith, Data move, Control Instruction๋ค์ด ์๋ ๊ฒ ๋ฉ๋ชจ๋ฆฌ Hierachy๋ฅผ ์๊ฐํ์ง ์๊ณ ๊ต์ฅํ ๋จ์ํ ๋ชจ๋ธ์์ ์๋ํ๋ค๊ณ ๊ฐ์ ํ๋ฉด ๋๋ค.
Efficiency
Input ์ฌ์ด์ฆ์์ ์ผ๋ง๋งํผ์ ์๊ฐ์ด ๊ฑธ๋ฆฌ๋์ง ์ธก์ ํ ํ์๊ฐ ์๋ค. n๊ฐ์ Element๊ฐ ์์ ๋ sortํ๋ฉด ์ด๋ป๊ฒ ๋๋ ๊ฒ์ธ์ง๋ฅผ ํํํ๋ค. ๋ ๊ฐ์ Integer๋ฅผ ๊ณฑํ๋ ๊ฒฝ์ฐ,, Word๊ฐ ๊ต์ฅํ ๊ธธ๋ค๊ณ ๊ฐ์ ํ๋ฉด Constant time์ด ๊ฑธ๋ฆฐ๋ค๊ณ ๋ณด๊ธฐ ํ๋ค๋ค. ์ด๋ฐ ๊ฒฝ์ฐ total number of bit๋ก ํํ์ ํ๋ค. n bit x n bit์ผ๋๋ ๋ค๋ฅด๊ฒ ํํํ๋ค๋ ๊ฒ์ ์๊ณ ์์ผ๋ฉด ๋๋ค. Graph์ ๊ฒฝ์ฐ๋ Vertice์ Edge์ ๊ฐ์๋ก ํํํ๋ฏ๋ก ํด๋น ์ ๋ณด๊ฐ ์ค์ํ๋ค.
Efficiency
Primitive ํ Operation๋ค์ด ํ์ํ๋ค. Step๋ค์ Machine ์ independentํ๋ค. ๋
๋ฆฝ์ ์ด๋ผ๋ ๊ฒ. pseudocode๋ฅผ ์์ฑํ๋ฉด ๊ฐ๊ฐ์ line๋ค์ constant time์ด ๊ฑธ๋ฆฐ๋ค๊ณ ๊ฐ์ ์ ํ๋ ๊ฒ์ด๋ค. ๊ทธ๋ ๋ค๊ณ ๋์ผํ ์๊ฐ์ ์๋๋ค.
Time complexity Analysis
Worst-case๋ฅผ ๊ฐ์ง๊ณ ๋ณดํต Time complexity๋ฅผ ๊ตฌํ๊ฒ ๋๋ค. ์ต์
์ ๊ฒฝ์ฐ ์ด ์ต๋ ์ด ์๊ฐ๋งํผ ๊ฑธ๋ฆฐ๋ค๋ ๊ฒ์ด๋ค . Average case์ ๊ฒฝ์ฐ๋ ์๋ฏธ ์๋๋ฐ ์ด๋ ๋๋ถ๋ถ์ ๊ฒฝ์ฐ์ ๋ํ Time์ ๋ํ ์์ ์ด๋ฏ๋ก ๊ณต์ ํ๊ฒ ๋ณผ ์ ์๋ ์๋ฃ๊ฐ ๋ ์ ์๋ค. Input์ด ํ์ ๋ ๊ฒ์ด ์๋๋ฏ๋ก ํต๊ณํ์ ์ผ๋ก ์ด๋ป๊ฒ ๋ถํฌ๊ฐ ๋์ด์๋์ง์ ๋ฐ๋ผ ๋ค๋ฅด๊ธฐ ๋๋ฌธ์ด๋ค. Best-case๋ ์๋ฏธ๊ฐ ์๋ค. Cheat์ด๋ผ๊ณ ํํ์ ํ๋ค. ๋ง๋ก๋ ์กด์ฌํ์ง๋ง ์๊ณ ๋ฆฌ์ฆ์์๋ ์กด์ฌํ์ง ์๋๋ค.
Time complexity Analysis
Worst case์ ๊ฒฝ์ฐ upper bound( ์ด๊ฒ๋ณด๋ค๋ ์ค๋๊ฑธ๋ฆฌ์ง ์์ด) ๋ฅผ ์ค์ ํ ์ ์๋ค. ์ด๋ค ์๊ณ ๋ฆฌ์ฆ์ ๊ฒฝ์ฐ worst๋งํผ ์์ข์ ์๋ ์๊ธฐ ๋๋ฌธ. ๊ฐ๊ฐ์ Input์ด ํ๋ฅ ์ ์ผ๋ก ์ผ์ด๋ ๊ฒฝ์ฐ๋ฅผ ๊ณ ๋ คํ๊ธฐ ๋๋ฌธ์ ์ํ์ ์ธ ๊ณ์ฐ์ด ํ์ํ๊ฒ ๋๋ค.
Analysis of insertion-sort
8๊ฐ์ line์ผ๋ก ์ด๋ฃจ์ด์ ธ ์๊ณ C1~C8 ๊ฐ๊ฐ์ ์๊ฐ๋งํผ ์๊ฐ์ด ๊ฑธ๋ฆฐ๋ค๊ณ ํ๋ค. time์ ๋ช ๋ฒ ์คํ๋๋ ๊ฐ๋ฅผ ๊ณ ๋ คํ๊ฒ ๋๋ค.
Analysis of insertion-sort
cost์ time์ ๊ณฑํด์ ๋ํ๊ฒ ๋๋ค. ๋ณ์๋ tj์ ํด๋นํ๋๋ฐ, Best case์ ๊ฒฝ์ฐ๋ ํ ๋ฒ๋ง ๋น๊ตํ๋ฉด์ ๋๋๊ฒ ๋๋ค. ๊ฐ๊ฐ์ While loop์์ ํ ๋ฒ์ฉ๋ง ์คํํ๊ฒ ๋๋ ๊ฒฝ์ฐ๋ฅผ ์๋ฏธํ๋ค. ์ฆ tj = 1์ผ ๋๋ฅผ ์๋ฏธํ๋ค. T(n) = O(n) Worst์ ๊ฒฝ์ฐ ๋น๊ต๊ฐ ๋ชจ๋ ์งํ๋๋ ๊ฒฝ์ฐ์ด๋ค. tj = i ๊ฐ ๋๋ฏ๋ก n(n+1)/2์ด๋ฉด O(n^2)๊ฐ ๋๋ค. Average case๋ฅผ ์ ํํ๊ฒ ๊ตฌํ๋ ค๋ฉด ์ํ์ ์ธ ์์์ด ํ์ํ๋ค. ํ์ง๋ง ๋๋ต์ ์ผ๋ก ์๊ฐํด๋ณด๋ฉด n^2/2 ์ ๊ฒฝ์ฐ์ด๋ฏ๋ก ์ด ์ญ์ O(n^2)๊ฐ ๋๋ค. Intuition ์ง๊ด์ ์ผ๋ก ์ดํด๋ณผ๋ ๋์จ ์์น์ด๋ค.
Analysis of merge sort
master theorem, Theorem ์ 3๊ฐ์ case๊ฐ ์กด์ฌํ๊ณ ์ด๋ case์ ์ํ๋์ง ๊ตฌํ๋ฉด ์ฝ๊ฒ ์ ํํ ์ ์๋ค. Insertion sort์ ๋น๊ตํด๋ณด๋ฉด
Time complexity๋ ๋น ๋ฅด๋ค. Merge๋ ๋ณต์กํ๊ธฐ ๋๋ฌธ์ input size๊ฐ ์์ผ๋ฉด insertion์ด ์ข ๋ ๋น ๋ฅด๋ค. ํ์ง๋ง ์ ์ ์ปค์ง๋ค๋ณด๋ฉด mergesort๊ฐ
ํจ์ฌ ๋นจ๋ผ์ง๋ค. ์ผ๋ฐ์ ์ผ๋ก merge๊ฐ insertion๋ณด๋ค ๋น ๋ฅด๋ค๊ณ ํ ์ ์๋ค.
Recurrence for merge sort
4์ฅ์์ ๋ค๋ฃฐ ๋ด์ฉ
Keyword
๋ฌธ์ ๊ฐ ์ฃผ์ด์ง๋ฉด Design Paradigm์ ๊ฒฐ์ ์ ํด์ผ ํ๋ค. ๊ธฐ์กด์ Paradigm๋ง์ ์ด์ฉํ ํ์ ์์ด ์ฐฝ์์ ์ผ๋ก ๊ตฌํํ ์ ์๋ค.
Data Structure๋ฅผ ์ด๋ค ๊ฒ์ ์ฌ์ฉํ ์ง ๊ฒฐ์ ์ ํ๊ฒ ๋๋ค. ์๊ณ ๋ฆฌ์ฆ์ ๋ถ์ํ๊ธฐ ์ํด์ Correctness๋ฅผ ์ฆ๋ช
ํ๊ณ Efficiency๋ฅผ ๊ณ์ฐํ๊ฒ ๋๋ค.
worst์ Average๊ฐ ์๊ณ Best case๋ ๊ณ ๋ คํ์ง ์์ ๊ฒ์ด๋ค.
'๐ Major Study (Bachelor) > ๐จ Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
์๊ณ ๋ฆฌ์ฆ 3์ฃผ์ฐจ ๋ชฉ์์ผ ๊ฐ์ (0) | 2022.03.17 |
---|---|
์๊ณ ๋ฆฌ์ฆ 3์ฃผ์ฐจ ์์์ผ ๊ฐ์ (0) | 2022.03.14 |
์๊ณ ๋ฆฌ์ฆ 2์ฃผ์ฐจ ๋ชฉ์์ผ (0) | 2022.03.10 |
์๊ณ ๋ฆฌ์ฆ 2์ฃผ์ฐจ ์์์ผ ๊ฐ์ (0) | 2022.03.09 |
์๊ณ ๋ฆฌ์ฆ 1์ฃผ์ฐจ ์์์ผ (0) | 2022.02.28 |