Python数据结构实现_排序算法

排序算法（英语：Sorting algorithm）是一种能将一串数据依照特定顺序进行排列的一种算法。

1. 冒泡排序
   思想：从头开始，每次比较相邻两个元素的大小，将大的放在后面。每轮会将未排序的元素中的最大值放在右侧。
   

def bubble_sort(alist):
 	'冒泡排序'
    n = len(alist)
    
    for j in range(n, 1, -1):
     '''
     j可理解为：经过一次循环，第j个位置的数字是最佳排序
     先排好第n-1位（最后位）
     再排好第0位
     '''
        for i in range(1,j):      
            count = 0
            if alist[i] < alist[i-1]:
                alist[i], alist[i-1] = alist[i-1], alist[i]
                count += 1
        if count == 0:
            return alist
    return alist

2. 选择排序
   思想：在未排序序列中找到最小元素，放到排序序列的起始位置，不断迭代。（也可以是最大）
   从无序中找最值，每次筛出的都是有顺序的值。

def selection_sort(alist):
	'选择排序'
    n = len(alist)
    for j in range(n-1):
        '''
        j代表无序组最小位置
        一直排到倒数第二位
        '''
        min_index = j    
   	 for i in range(j+1, n):
	        if alist[min_index] > alist[i]:
	            min_index = i
	        if min_index != j:
	            alist[j],alist[min_index] = alist[min_index],alist[j]    
   return alist

3. 插入排序
   从无序中依次取值，插入到有序的正确位置上。

def insert_sort(alist):
    '插入排序'
    n = len(alist)
    for j in range(1, n):
        # j是无序组第一位数
        for i in range(j, 0, -1):
       	# 有序组排序
            if alist[i] < alist[i-1]:
                alist[i], alist[i-1] = alist[i-1], alist[i]
            else:
                break
    return alist

4. 希尔排序
   插入排序是间隔为1的希尔排序

def shell_sort(alist):
    '希尔排序'
    n = len(alist)
    gap = n // 2 #除法取整
    while gap != 0:
        for j in range(gap, n):
         # j是无序组第一位数
            for i in range(j, gap-1, -1):
                'i 是从有序组最大值排序'
                if alist[i] < alist[i-gap]:
                    alist[i], alist[i-gap] = alist[i-gap], alist[i]
         gap = gap//2    
    return alist

5. 快速排序
   在序列中找到数字的位置。
   

def quick_sort(alist, start, end):
    '快速排序：每个数字找到它的最佳位置'
    if start >= end :  # 递归必须有基准条件
        return 
	
    mark = alist[start] # 要排序的值
    # 初始化
    low = start
    high = end
    while low != high:
        while low < high and alist[high] > mark:
            high -= 1
        alist[low] = alist[high]
        
        while low < high and alist[low] < mark:
            low += 1
        alist[high] = alist[low]
    alist[low] = mark    
    '不要返回alist，因为list为可修改类型，直接对list完成了一系列修改'
    quick_sort(alist,start,low-1) 
    quick_sort(alist,low+1,end)

quick_sort(alist,0,len(alist)-1)

mark即是每一次需要正确排序数字（这里每次以序列中第一个数字开始排序），一方面用于与alist[low]和alist[high]比较大小，另一方面用于储存数字，以免在移动值时被覆盖掉。