pythonデータ構造の複数のソートアルゴリズム

#      
def selection_sort(my_list):
    i = 0
    while i < len(my_list):
        min_index = i
        j = i + 1
        while j < len(my_list):
            if my_list[j] < my_list[min_index]:
                min_index = j   #                  

            j += 1
        if my_list[min_index] != my_list[i]:  #                        ，     
            my_list[min_index], my_list[i] = my_list[i], my_list[min_index]

        i += 1



#      
def bubble_sort(my_list):
    n = len(my_list)
    swapped = False
    while n > 1:
        i = 1
        while i < n:
            if my_list[i] < my_list[i - 1]:
                my_list[i], my_list[i - 1] = my_list[i - 1], my_list[i]
                swapped = True
            i += 1
        n -= 1          


#      
def insert_sort(my_list):
    num = 1
    while num < len(my_list):
        i = num - 1
        need_item = my_list[num]
        while i >= 0:
            if need_item < my_list[i]:
                my_list[i + 1] = my_list[i]
                i -= 1
            else:
                break
        my_list[i + 1] = need_item
        num += 1


# ========================    =====================
def quick_sort(my_list):
    quick_helper(my_list, 0, len(my_list) - 1)


def quick_helper(lyst, left, right):
    """      """
    if left < right:  #                2
        boudary = get_boundary_postion(lyst, left, right)  #         
        quick_helper(lyst, left, boudary - 1)  #       
        quick_helper(lyst, boudary + 1, right)  #       


def get_boundary_postion(lyst, left, right):
    """
            
    :param lyst:        
    :param left:     
    :param right:     
    return:         
    """
    middle = (left + right) // 2  #        '//'   
    datum_point = lyst[middle]  #           
    lyst[middle] = lyst[right]  #              
    lyst[right] = datum_point
    boudary = left  #               
    for i in range(left, right):
        if lyst[i] < datum_point:  #               
            lyst[boudary], lyst[i] = lyst[i], lyst[boudary]  #               
            boudary += 1
    #                         ，
    #                    ,       
    lyst[boudary], lyst[right] = lyst[right], lyst[boudary]  
    return boudary


# ==================    ======================
def merge_sort(my_list):
    """       """
    copy_lyst = my_list.copy()
    merge_helper(my_list, copy_lyst, 0, len(my_list)-1)


def merge_helper(lyst, copy_lyst, left, right):
    """    """
    if left < right:
        middle = (left + right) // 2
        merge_helper(lyst, copy_lyst, left, middle)
        merge_helper(lyst, copy_lyst, middle+1, right)
        merge_(lyst, copy_lyst, left, middle, right)


def merge_(lyst, copy_lyst, left, middle, right):
    """
        
    :param lyst --    
    :param copy_lyst --                
    :param left  --    
    :param middle --  
    :param right --    
    """
    i1 = left  #          ,
    i2 = middle + 1  #          
    for i in range(left, right + 1):
        if i1 > middle:
            copy_lyst[i] = lyst[i2]
            i2 += 1
        elif i2 > right:
            copy_lyst[i] = lyst[i1]
            i1 += 1
        elif lyst[i1] < lyst[i2]:  #            
            copy_lyst[i] = lyst[i1]
            i1 += 1
        else:
            copy_lyst[i] = lyst[i2]
            i2 += 1

    for i in copy_lyst:
        lyst[i] = copy_lyst[i]




num = [1, 3, 4, 2, 1]
merge_sort(num)
print(num)

実はpythonを使ってソートアルゴリズムを実現する以上、2つの位置交換を実現する機能の中で、pythonが書いた交換方式ではなく、下位の方式を使うべきです.

def swapped(lyst, index1, index2):
    temp = lyst[index1]
    lyst[index1] = lyst[index2]
    lyst[index2] = temp