排序算法

1、直接插入排序

def insert(alist):
    n = len(alist)
    for i in range(1, n):
        for j in range(i, 0, -1):
            if alist[j-1] > alist[j]:
                alist[j-1], alist[j] = alist[j], alist[j-1]
    return alist

alist = [4, 5, 2, 3, 1]
alist = insert(alist)
print(alist)

2、希尔排序

def shell(alist):
    n = len(alist)
    gap = n // 2
    while gap > 0:
        for i in range(1, n):
            for j in range(i, 0, -gap):
                if alist[j-gap] > alist[j]:
                    alist[j-gap], alist[j] = alist[j], alist[j-gap]
        gap //= 2
    return alist

alist = [4, 5, 2, 1, 3]
alist = shell(alist)
print(alist)

3、直接选择排序

def select(alist):
    n = len(alist)
    for i in range(n):
        min_i = i
        for j in range(i+1, n):
            if alist[min_i] > alist[j]:
                min_i = j
        alist[i], alist[min_i] = alist[min_i], alist[i]
    return alist

alist = [4, 5, 2, 1, 3]

alist = select(alist)

print(alist)

4、堆排序

def maxheap(alist):

    for i in range(len(alist)//2-1):
        heapify(alist, i)
        
def heapify(alist, i):
    left = 2*i+1
    right = 2*i+2
    largest = i
    if left < n and alist[left]>alist[largest]:
        largest = left
    if right < n and alist[right]>alist[largest]:
        largest = right
    if largest != i:
        swap(alist, i, largest)
        heapify(alist, largest)
        
def swap(alist, i, j):
    alist[i], alist[j] = alist[j], alist[i]
    
def heapsort(alist):
    global n
    n = len(alist)
    maxheap(alist)
    for i in range(n-1, 0, -1):
        swap(alist, 0, i)
        n -= 1
        heapify(alist, 0)
    return alist

alist = [4, 5, 2, 1, 3]
alist = heapsort(alist)
print(alist)

5、冒泡排序

def bubble(alist):
    n = len(alist)
    for i in range(n-1):
        for j in range(n-1-i):
            if alist[j]>alist[j+1]:
                alist[j], alist[j+1] = alist[j+1], alist[j]
                
    return alist

alist = [4, 5, 2, 1, 3]
alist = bubble(alist)

print(alist)

6、快速排序

def quick(alist, first, last):
    if first>=last:
        return
    
    mid_value = alist[first]
    low = first
    high = last
    
    while low<high:
        while low<high and alist[high]>=mid_value:
            high -= 1
        alist[low] = alist[high]
        
        while low<high and alist[low]<mid_value:
            low += 1
        alist[high] = alist[low]
        
        alist[low] = mid_value
        
    quick(alist, first, low-1)
    quick(alist, low+1, last)
    
    return alist

alist = [4, 5, 2, 1, 3]
n = len(alist)
alist = quick(alist, 0, n-1)
print(alist)

7、归并排序

def merge(alist):
    n = len(alist)
    if n <= 1:
        return alist
    mid_index = n // 2
    
    left_list = merge(alist[:mid_index])
    right_list = merge(alist[mid_index:])
    
    left_point, right_point = 0, 0
    result = []
    
    while left_point < len(left_list) and right_point < len(right_list):
        if right_list[right_point] < left_list[left_point]:
            result.append(right_list[right_point])
            right_point += 1
        else:
            result.append(left_list[left_point])
            left_point += 1
            
    result += left_list[left_point:]
    result += right_list[right_point:]
    
    return result


alist = [4, 5, 2, 1, 3]
alist = merge(alist)
print(alist)

各种排序算法比较