3.1. Sorting - 3.1.6 Merge Sort

2024. 1. 20. 23:34ใ†CS - Roadmap.sh/3. Common Algorithms

CS - 3. Common Algorithms - 3.1. Sorting - 3.1.6 Merge Sort

 

๐Ÿ’กMerge sort is a divide and conquer algorithm. It divides the input array into two halves, calls itself for the two halves, and then merges the two sorted halves. The merge() function is used for merging two halves. The merge(arr, l, m, r) is key process that assumes that arr[l..m] and arr[m+1..r] are sorted and merges the two sorted sub-arrays into one.

 

๋ณ‘ํ•ฉ ์ •๋ ฌ์€ ๋ถ„ํ•  ๋ฐ ์ •๋ณต ์•Œ๊ณ ๋ฆฌ์ฆ˜์ž…๋‹ˆ๋‹ค. ์ด ํ•จ์ˆ˜๋Š” ์ž…๋ ฅ ๋ฐฐ์—ด์„ ๋‘ ๊ฐœ์˜ ๋ฐ˜์œผ๋กœ ๋‚˜๋ˆ„๊ณ , ๋‘ ๊ฐœ์˜ ๋ฐ˜์— ๋Œ€ํ•ด ์Šค์Šค๋กœ๋ฅผ ํ˜ธ์ถœํ•œ ๋‹ค์Œ ์ •๋ ฌ๋œ ๋‘ ๊ฐœ์˜ ๋ฐ˜์„ ๋ณ‘ํ•ฉํ•ฉ๋‹ˆ๋‹ค. merge() ํ•จ์ˆ˜๋Š” ๋‘ ๊ฐœ์˜ ๋ฐ˜์ชฝ์„ ๋ณ‘ํ•ฉํ•˜๋Š” ๋ฐ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. merge(arr, l, m, r)๋Š” ๋ฐฐ์—ด[l..m]๊ณผ ๋ฐฐ์—ด[m+1..r]์ด ์ •๋ ฌ๋˜์–ด ์žˆ๋‹ค๊ณ  ๊ฐ€์ •ํ•˜๊ณ  ์ •๋ ฌ๋œ ๋‘ ๊ฐœ์˜ ํ•˜์œ„ ๋ฐฐ์—ด์„ ํ•˜๋‚˜๋กœ ๋ณ‘ํ•ฉํ•˜๋Š” ํ•ต์‹ฌ ํ”„๋กœ์„ธ์Šค์ž…๋‹ˆ๋‹ค.

 

์ •๋ ฌ Sorting ์˜ ๋งˆ์ง€๋ง‰ Merge sort ๋ณ‘ํ•ฉ ์ •๋ ฌ์ž…๋‹ˆ๋‹ค.

 

๋ณ‘ํ•ฉ ์ •๋ ฌ์€ ํ€ต์ •๋ ฌ๊ณผ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ ๋ถ„ํ• ์ •๋ณต ๋ฐฉ์‹์˜ ์ •๋ ฌ ์•Œ๊ณ ๋ฆฌ์ฆ˜์ž…๋‹ˆ๋‹ค.

์ฃผ์–ด์ง„ ๋ฌธ์ œ๋ฅผ ์ž‘์€ ๋ถ€๋ถ„์œผ๋กœ ๋‚˜๋ˆˆ ๋’ค ๊ฐ๊ฐ์„ ํ•ด๊ฒฐํ•˜๊ณ , ์ด๋ฅผ ๋‹ค์‹œ ํ•ฉ์ณ์„œ ์ „์ฒด ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•˜๋Š” ๋ฐฉ์‹์„ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

 

๋ณ‘ํ•ฉ ์ •๋ ฌ์˜ ๋™์ž‘ ๊ณผ์ •์€ ์ด๋ ‡์Šต๋‹ˆ๋‹ค.

 

1. ์ฃผ์–ด์ง„ ๋ฐฐ์—ด์„ ์ ˆ๋ฐ˜์”ฉ ๋‚˜๋ˆ•๋‹ˆ๋‹ค.

์ด๋ฅผ ์žฌ๊ท€์ ์œผ๋กœ ๋ฐ˜๋ณตํ•˜์—ฌ ๋ฐฐ์—ด์˜ ๊ธธ์ด๊ฐ€ 1์ด ๋  ๋•Œ ๊นŒ์ง€ ๋‚˜๋ˆ•๋‹ˆ๋‹ค.

๊ธธ์ด๊ฐ€ 1์ธ ๋ฐฐ์—ด์€ ์ž์—ฐ์Šค๋Ÿฝ๊ฒŒ ์ •๋ ฌ๋œ ์ƒํƒœ๋กœ ๊ฐ„์ฃผํ•ฉ๋‹ˆ๋‹ค.

 

2. ์ด๋ ‡๊ฒŒ ๋‚˜๋ˆˆ ๋ฐฐ์—ด๋“ค์„ ๋‹ค์‹œ ํ•ฉ์น˜๋ฉด์„œ ์ •๋ ฌํ•ฉ๋‹ˆ๋‹ค.

์ด๋ฅผ ๋ณ‘ํ•ฉ(Merge)๋ผ๊ณ  ํ•˜๋ฉฐ, ์ด ๊ณผ์ •์—์„œ ์‹ค์ œ ์ •๋ ฌ์ด ์ด๋ฃจ์–ด ์ง‘๋‹ˆ๋‹ค.

์ด๋ฅผ ์žฌ๊ท€์ ์œผ๋กœ ๋ฐ˜๋ณตํ•˜์—ฌ ์ „์ฒด ๋ฐฐ์—ด์ด ์ •๋ ฌ๋  ๋–„๊นŒ์ง€ ์ˆ˜ํ–‰ํ•ฉ๋‹ˆ๋‹ค.

 

 

In Python

 

def merge_sort(arr):
    if len(arr) <= 1:
        return arr

    mid = len(arr) // 2
    left = arr[:mid]
    right = arr[mid:]

    return merge(merge_sort(left), merge_sort(right))

def merge(left, right):
    result = []
    i = j = 0

    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1

    result.extend(left[i:])
    result.extend(right[j:])
    return result

 

 

๋ณ‘ํ•ฉ ์ •๋ ฌ์€ ํ•ญ์ƒ O(n log n)์˜ ์‹œ๊ฐ„ ๋ณต์žก๋„๋ฅผ ๊ฐ€์ง‘๋‹ˆ๋‹ค.

์ด๋Š” ๊ฐ ๋‹จ๊ณ„์—์„œ n๊ฐœ์˜ ์›์†Œ๋ฅผ ๋‹ค๋ฃจ๊ณ , ์ „์ฒด ๋‹จ๊ณ„์˜ ์ˆ˜๊ฐ€ log n์ด๊ธฐ ๋–„๋ฌธ์ž…๋‹ˆ๋‹ค.

 

๋ณ‘ํ•ฉ ์ •๋ ฌ์€ ์•ˆ์ •์ ์ธ ์ •๋ ฌ ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด๋ฏ€๋กœ ๋™์ผํ•œ ๊ฐ’์— ๋Œ€ํ•ด ์›๋ž˜์˜ ์ˆœ์„œ๊ฐ€ ์œ ์ง€๋˜๋Š” ๊ฒƒ์ด ์ค‘์š”ํ•œ ์ƒํ™ฉ์—์„œ ์œ ์šฉํ•ฉ๋‹ˆ๋‹ค.

๋˜ํ•œ ๋ฐ์ดํ„ฐ์˜ ํฌ๊ธฐ๊ฐ€ ํฌ๊ฑฐ๋‚˜, ์™ธ๋ถ€ ์ •๋ ฌ์ด ํ•„์š”ํ•œ ๊ฒฝ์šฐ์—๋„ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ๋ณ‘ํ•ฉ ์ •๋ ฌ์€ ์ถ”๊ฐ€์ ์ธ ๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„์„ ํ•„์š”๋กœ ํ•˜๋Š”๋ฐ, ์ด๋Š” ๋ณ‘ํ•ฉ ๊ณผ์ •์—์„œ ์ƒˆ๋กœ์šด ๋ฐฐ์—ด์„ ์ƒ์„ฑํ•˜๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค. 

๋”ฐ๋ผ์„œ ๋ฉ”๋ชจ๋ฆฌ๊ฐ€ ์ œํ•œ์ ์ธ ์ƒํ™ฉ์—์„œ๋Š” ์‚ฌ์šฉํ•˜๊ธฐ ์–ด๋ ค์šธ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. 

 

 

 

์œ„์—์„œ 

'๋ณ‘ํ•ฉ ์ •๋ ฌ์€ ์•ˆ์ •์ ์ธ ์ •๋ ฌ ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด๋ฏ€๋กœ ๋™์ผํ•œ ๊ฐ’์— ๋Œ€ํ•ด ์›๋ž˜์˜ ์ˆœ์„œ๊ฐ€ ์œ ์ง€๋˜๋Š” ๊ฒƒ์ด ์ค‘์š”ํ•œ ์ƒํ™ฉ์—์„œ ์œ ์šฉํ•ฉ๋‹ˆ๋‹ค.'

๋ผ๋Š” ๋ง์„ ํ–ˆ์Šต๋‹ˆ๋‹ค.

 

๊ฐ„๋‹จํ•œ ์˜ˆ์‹œ๋ฅผ ๋“ค์ž๋ฉด

items = [(2, 'B'), (1, 'B'), (2, 'A'), (1, 'A')]

์ด๋Ÿฌํ•œ ๋ฉ”์ธํ‚ค(์ˆซ์žint)์™€ ๋ณด์กฐํ‚ค(๋ฌธ์žstr)๋กœ ๊ตฌ์„ฑ๋˜์–ด์žˆ๋Š” ํŠœํ”Œ์˜ ๋ฆฌ์ŠคํŠธ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค.

 

 ๋ณ‘ํ•ฉ์ •๋ ฌ์€ ์•ˆ์ •์ ์ธ ์ •๋ ฌ ์•Œ๊ณ ๋ฆฌ์ฆ˜ ์ด๋ฏ€๋กœ ์›๋ž˜์˜ ์ˆœ์„œ๊ฐ€ ์œ ์ง€๋˜์–ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ,

๋ญ์—ฌ??? [(1, 'B'), (1, 'A'), (2, 'B'), (2, 'A')] ์ด๊ฒŒ ๋‚˜์™€์•ผํ•˜๋Š”๋ฐ ์‹น ์ •๋ฆฌ๋˜์„œ ๋‚˜์™€๋ฒ„๋ ธ๋‹ค.

(์ข€๋” ๊ณต๋ถ€ํ•œ๋’ค ์ฐจํ›„ ์ถ”๊ฐ€)

 

 

 

 

๋ณ‘ํ•ฉ ์ •๋ ฌ์—์„œ์˜ '์•ˆ์ •์„ฑ'์ด๋ž€, ๋™์ผํ•œ ๊ฐ’์„ ๊ฐ€์ง„ ์›์†Œ๋“ค ์‚ฌ์ด์˜ ์ƒ๋Œ€์  ์ˆœ์„œ๊ฐ€ ์ •๋ ฌ ํ›„์—๋„ ์œ ์ง€๋œ๋‹ค๋Š” ๊ฒƒ ์ž…๋‹ˆ๋‹ค.

 

 

 

 

Appendix

LinkedList ์—์„œ์˜ Merge Sorting
๋ณ‘ํ•ฉ ์ •๋ ฌ์€ ์ˆœ์ฐจ์ ์ธ ๋น„๊ต๋ฅผ ํ†ตํ•ด ์ •๋ ฌํ•˜๊ธฐ ๋•Œ๋ฌธ์—, ์ˆœ์ฐจ ์ ‘๊ทผ์— ์šฉ์ดํ•œ LinkedList ์˜ ์ •๋ ฌ์ด ํ•„์š”ํ•  ๋•Œ ๋งค์šฐ ํšจ์œจ์ ์œผ๋กœ ๋™์ž‘ํ•˜๊ฒŒ ๋œ๋‹ค. ํ€ต ์†ŒํŠธ๋Š” ์ˆœ์ฐจ ์ ‘๊ทผ์ด ์•„๋‹Œ ์ž„์˜ ์ ‘๊ทผ์„ ํ†ตํ•ด ์ •๋ ฌ์„ ํ•˜๊ธฐ ๋•Œ๋ฌธ์— ์˜ค๋ฒ„ํ—ค๋“œ๊ฐ€ ๋ฐœ์ƒํ•˜์—ฌ ์„ฑ๋Šฅ์ด ์ข‹์ง€ ์•Š๋‹ค.

(https://velog.io/@haero_kim/%EC%95%88%EC%A0%95%EC%A0%81-%EA%B7%B8-%EC%9E%90%EC%B2%B4-Merge-Sort)

 

 

 

 

https://www.geeksforgeeks.org/merge-sort/

 

Merge Sort - Data Structure and Algorithms Tutorials - GeeksforGeeks

Like QuickSort , Merge Sort is a Divide and Conquer algorithm. It divides input array in two halves, calls itself for the two halves and then merges the two

www.geeksforgeeks.org

 

728x90

'CS - Roadmap.sh > 3. Common Algorithms' ์นดํ…Œ๊ณ ๋ฆฌ์˜ ๋‹ค๋ฅธ ๊ธ€

3.2. Recursion - 3.2.2 Non-Tail Recursion  (0) 2024.01.22
3.2. Recursion - 3.2.1 Tail Recursion  (0) 2024.01.21
3.1 Sorting - 3.1.5 Quick Sort  (0) 2024.01.16
3.1 Sorting - 3.1.4 Heap Sort  (0) 2024.01.15
3.1. Sorting - 3.1.3 Insertion Sort  (0) 2024.01.15