ν‹°μŠ€ν† λ¦¬ λ·°

728x90

<λͺ©μ°¨>

    πŸ“ μ •λ ¬ (Sorting)

    βœ”οΈ 데이터λ₯Ό νŠΉμ •ν•œ 기쀀에 λ”°λΌμ„œ μˆœμ„œλŒ€λ‘œ λ‚˜μ—΄ν•˜λŠ” 것

    βœ”οΈ μ΄μ§„ 탐색(Binary Search)의 μ „μ²˜λ¦¬ 과정이 λ˜κΈ°λ„ ν•œλ‹€. 

     

    πŸ“ νŒŒμ΄μ¬μ˜ μ •λ ¬ 라이브러리

    βœ”οΈ λ³‘ν•© μ •λ ¬(merge sort)을 기반으둜 λ§Œλ“€μ–΄μ‘ŒμœΌλ©°, 퀡 μ •λ ¬λ³΄λ‹€λŠ” λŠλ¦¬μ§€λ§Œ μ΅œμ•…μ˜ κ²½μš°μ—λ„ μ‹œκ°„ λ³΅μž‘λ„ O(NlogN)을 보μž₯ν•œλ‹€λŠ” νŠΉμ§•μ„ 가진닀. 

     

    πŸ“Œ [Python] νŠœν”Œμ„ μ›μ†Œλ‘œ ν•˜λŠ” 리슀트 μ •λ ¬ (tistory.com)

     

    πŸ“ Comparisons Sorting Algorithm (비ꡐ 방식 μ •λ ¬ μ•Œκ³ λ¦¬μ¦˜)

    πŸ“„ 버블 μ •λ ¬ (Bubble Sort)

    βœ”οΈ in-place sort둜 μΈμ ‘ν•œ 두 개의 데이터λ₯Ό λΉ„κ΅ν•΄κ°€λ©΄μ„œ 정렬을 μ§„ν–‰ν•œλ‹€. βœ”οΈ κ°€μž₯ 큰 값을 λ°°μ—΄μ˜ 맨 끝으둜 μ΄λ™μ‹œν‚€κΈ°λ•Œλ¬Έμ— μ •λ ¬ν•˜κ³ μž ν•˜λŠ” μ›μ†Œμ˜ 개수 λ§ŒνΌμ„ λ‘λ²ˆ λ°˜λ³΅ν•˜κ²Œ λœλ‹€. - Time Complexity : O(N^2)- Space Complexity : O(1)

     

    πŸ“„ 선택 μ •λ ¬ (Selection Sort)

    βœ”οΈ λ§€λ²ˆ "κ°€μž₯ μž‘μ€ 것을 선택"ν•΄μ„œ μ•žμ˜ 데이터와 λ°”κΏ”μ€€λ‹€. 

         → κ°€μž₯ μž‘μ€ 데이터λ₯Ό 선택해 맨 μ•žμ— μžˆλŠ” 데이터와 λ°”κΎΈκ³ , κ·Έλ‹€μŒ μž‘μ€ 데이터λ₯Ό 선택해 μ•žμ—μ„œ 두 번째 데이터와 λ°”κΎΈλŠ” 과정을 N - 1 번 λ°˜λ³΅ν•œλ‹€. 

     

    - Time Complexity : O(N^2)

       → μ†ŒμŠ€ μ½”λ“œ μƒμœΌλ‘œ κ°„λ‹¨ν•œ ν˜•νƒœμ˜ 2쀑 반볡문이 μ‚¬μš©λ¨

    - Space Complexity : O(1)

     

    πŸ“Œ python code

     

    πŸ“„ μ‚½μž… μ •λ ¬ (Insertion Sort)

    ν•„μš”ν•  λ•Œλ§Œ μœ„μΉ˜λ₯Ό λ°”κΎΈλ―€λ‘œ '데이터가 거의 μ •λ ¬λ˜μ–΄ μžˆμ„ λ•Œ' 훨씬 νš¨μœ¨μ μ΄λ‹€. 

     

    기본적으둜 μ‹œκ°„ λ³΅μž‘λ„λŠ” O(N^2)μ΄μ§€λ§Œ, ν˜„μž¬ 리슀트의 데이터가 거의 μ •λ ¬λ˜μ–΄ μžˆλŠ” μƒνƒœλΌλ©΄ μ΅œμ„ μ˜ 경우 O(N)의 μ‹œκ°„ λ³΅μž‘λ„λ₯Ό κ°–κ²Œλœλ‹€. 

     

    πŸ“„ λ³‘ν•© μ •λ ¬ (Merge Sort)

     

    πŸ“„ νž™ μ •λ ¬ (Heap Sort)

     

    πŸ“„ ν€΅ μ •λ ¬ (Quick Sort)

    기쀀을 μ„€μ •ν•œ λ‹€μŒ 큰 μˆ˜μ™€ μž‘μ€ 수λ₯Ό κ΅ν™˜ν•œ ν›„ 리슀트λ₯Ό 반으둜 λ‚˜λˆ„λŠ” λ°©μ‹μœΌλ‘œ λ™μž‘ν•œλ‹€. 

     

    ν”Όλ²— (Pivot) : κ΅ν™˜μ— μ‚¬μš©λ˜λŠ” 'κΈ°μ€€'

    → 피벗을 μ„€μ •ν•˜κ³  리슀트λ₯Ό λΆ„ν• ν•˜λŠ” 방법에 λ”°λΌμ„œ μ—¬λŸ¬ 가지 λ°©μ‹μ˜ 퀡 μ •λ ¬λ‘œ ꡬ뢄할 수 μžˆλ‹€. 

     

    ν˜Έμ–΄ λΆ„ν•  (Hoare Partition) : λ¦¬μŠ€νŠΈμ—μ„œ 첫 번째 데이터λ₯Ό ν”Όλ²—μœΌλ‘œ μ •ν•œλ‹€. 

    1. 리슀트의 μ™Όμͺ½μ—μ„œλΆ€ν„° 피벗보닀 큰 데이터λ₯Ό μ„ νƒν•˜κ³  였λ₯Έμͺ½μ—μ„œλΆ€ν„° 피벗보닀 μž‘μ€ 데이터λ₯Ό 선택해 κ΅ν™˜ν•œλ‹€. 
    2. 1λ²ˆμ„ 반볡 μˆ˜ν–‰ν•˜λ‹€κ°€ 두 데이터가 μ—‡κ°ˆλ¦΄ 경우 μž‘μ€ 데이터와 ν”Όλ²—μ˜ μœ„μΉ˜λ₯Ό λ³€κ²½ν•΄μ€€λ‹€. 
    3. μ™Όμͺ½μ˜ λ¦¬μŠ€νŠΈμ™€ 였λ₯Έμͺ½μ˜ λ¦¬μŠ€νŠΈμ— λŒ€ν•΄ 퀡 정렬을 μˆ˜ν–‰ν•΄μ€€λ‹€. → μž¬κ·€ν•¨μˆ˜
    4. ν˜„μž¬ 리슀트의 데이터 κ°œμˆ˜κ°€ 1개인 경우 μž¬κ·€ν•¨μˆ˜λ₯Ό μ’…λ£Œν•œλ‹€. 

    평균 μ‹œκ°„ λ³΅μž‘λ„λŠ” O(NlogN)이닀. ν•˜μ§€λ§Œ '이미 데이터가 μ •λ ¬λ˜μ–΄ μžˆλŠ” 경우'μ—λŠ” 맀우 느리게 λ™μž‘ν•¨μ— μ£Όμ˜ν•΄μ•Όν•œλ‹€. 

     

    array = [5, 7, 9, 0, 3, 1, 6, 2, 4, 8]
    
    def quick_sort(array):
        # λ¦¬μŠ€νŠΈκ°€ ν•˜λ‚˜ μ΄ν•˜μ˜ μ›μ†Œλ§Œμ„ λ‹΄κ³  μžˆλ‹€λ©΄ μ’…λ£Œ
        if len(array) <= 1:
            return array
    
        pivot = array[0] # 피벗은 첫 번째 μ›μ†Œ
        tail = array[1:] # 피벗을 μ œμ™Έν•œ 리슀트
    
        left_side = [x for x in tail if x <= pivot] # λΆ„ν• λœ μ™Όμͺ½ λΆ€λΆ„
        right_side = [x for x in tail if x > pivot] # λΆ„ν• λœ 였λ₯Έμͺ½ λΆ€λΆ„
    
        # λΆ„ν•  이후 μ™Όμͺ½ λΆ€λΆ„κ³Ό 였λ₯Έμͺ½ λΆ€λΆ„μ—μ„œ 각각 정렬을 μˆ˜ν–‰ν•˜κ³ , 전체 리슀트λ₯Ό λ°˜ν™˜
        return quick_sort(left_side) + [pivot] + quick_sort(right_side)
    
    print(quick_sort(array))

     

    πŸ“ non-Comparisons Sorting Algorithm

    πŸ“„ κ³„μˆ˜ μ •λ ¬ (Counting Sort)

    λ°μ΄ν„°μ˜ 크기 λ²”μœ„κ°€ μ œν•œλ˜μ–΄ μ •μˆ˜ ν˜•νƒœλ‘œ ν‘œν•œν•  수 μžˆμ„ λ•Œλ§Œ μ‚¬μš© κ°€λŠ₯ν•˜λ‹€. 

    → λ°μ΄ν„°μ˜ κ°œμˆ˜κ°€ 맀우 λ§Žλ”λΌλ„ λΉ λ₯΄κ²Œ λ™μž‘ν•œλ‹€. 

    일반적으둜 κ°€μž₯ 큰 데이터와 κ°€μž₯ μž‘μ€ λ°μ΄ν„°μ˜ 차이가 1,000,000을 λ„˜μ§€ μ•Šμ„ λ•Œ 효과적으둜 μ‚¬μš©ν•  수 μžˆλ‹€. 

    λ™μΌν•œ 값을 κ°€μ§€λŠ” 데이터가 μ—¬λŸ¬ 개 λ“±μž₯ν•  λ•Œ μ ν•©ν•˜λ‹€. 

     

    1. κ°€μž₯ 큰 데이터와 κ°€μž₯ μž‘μ€ λ°μ΄ν„°μ˜ λ²”μœ„κ°€ λͺ¨λ‘ λ‹΄κΈΈ 수 μžˆλŠ” ν•˜λ‚˜μ˜ 리슀트(λ“±μž₯ 횟수λ₯Ό 기둝)λ₯Ό μƒμ„±ν•œλ‹€. 
    2. μ •λ ¬ν•  데이터λ₯Ό λŒλ©΄μ„œ 각 λ°μ΄ν„°μ˜ λ“±μž₯ 횟수λ₯Ό κΈ°λ‘ν•œλ‹€. 
    3. λ“±μž₯ 횟수λ₯Ό κΈ°λ‘ν•œ 리슀트λ₯Ό λŒλ©΄μ„œ 좜λ ₯ν•œλ‹€. 

     

    λ°μ΄ν„°μ˜ κ°œμˆ˜κ°€ N, 데이터 쀑 μ΅œλŒ“κ°’μ΄ K일 λ•Œ, κ³„μˆ˜ 정렬은 μ΅œμ•…μ˜ κ²½μš°μ—λ„ μˆ˜ν–‰ μ‹œκ°„ O(N + K)λ₯Ό 보μž₯ν•œλ‹€. 

     

    λ°μ΄ν„°μ˜ νŠΉμ„±μ„ νŒŒμ•…ν•˜κΈ° μ–΄λ ΅λ‹€λ©΄ 퀡 정렬을 μ΄μš©ν•˜λŠ” 것이 μœ λ¦¬ν•˜λ‹€. 

     

    # λͺ¨λ“  μ›μ†Œμ˜ 값이 0보닀 ν¬κ±°λ‚˜ κ°™λ‹€κ³  κ°€μ •
    array = [7, 5, 9, 0, 3, 1, 6, 2, 9, 1, 4, 8, 0, 5, 2]
    
    # λͺ¨λ“  λ²”μœ„λ₯Ό ν¬ν•¨ν•˜λŠ” 리슀트 μ„ μ–Έ(λͺ¨λ“  값은 0으둜 μ΄ˆκΈ°ν™”)
    count = [0] * (max(array) + 1) # μ΅œμ†Œκ°’μ΄ 0이 아닐 경우 max(array) - min(array) + 1
    
    # 각 데이터에 ν•΄λ‹Ήν•˜λŠ” 인덱슀의 κ°’ 증가
    for i in range(len(array)):
        count[array[i]] += 1
    
    # λ¦¬μŠ€νŠΈμ— 기둝된 μ •λ ¬ 정보 확인
    for i in range(len(count)):
        for j in range(count[i]):
            print(i, end=' ')

     

    πŸ“„ λ ˆλ”•μŠ€ μ •λ ¬ (Radix Sort)

     


    Ref.

    - 이것이 취업을 μœ„ν•œ μ½”λ”© ν…ŒμŠ€νŠΈλ‹€ with 파이썬

     

     

    728x90
    λŒ“κΈ€
    곡지사항
    μ΅œκ·Όμ— 올라온 κΈ€