各排序以及python代码实现

一、总述
一般是内部排序。

稳定排序：冒泡排序，插入排序，归并排序，基数排序
不稳定排序：选择排序，快速排序，希尔排序，堆排序

二、冒泡排序
每一次都将最大（小）的数沉到末尾。

def Bubble_sort(num):
	if len(num)<=1:
		return num
	for i in range(1,len(num)):
		for j in range(0,len(num)-i):
			if num[j]>num[j+1]:
				num[j],num[j+1] = num[j+1],num[j]
		print('第',i,'趟排序后：',num)
	return num

三、快速排序
以第一个数为基准，设置high和low指针。在low小于high的情况下：从high开始，往前移动，找到小于基准的数，与基准数交换；从low开始往后移动，找到大于基准的数，与基准数交换。这样就以基准数为分割点，基准数之前的数比他小，之后的数比他大。对于基准数前后的子数组，再进行快速排序。

def Quik_sort(num):
    if len(nums)<=1:
            return nums
        
        pivotkey = nums[0]
        left = []
        right = []
        for i in range(1,len(nums)):
            if nums[i]<=pivotkey:
                left.append(nums[i])
            else:
                right.append(nums[i])
        return Solution.MySort(left)+[pivotkey]+Solution.MySort(right)

四、简单选择排序
和冒泡排序的思想比较接近。从第一个位置到倒数第二个位置，每次从他之后的数中选择最小的与他交换。

def Select_sort(num):
    if len(num)<=1:
        return num
    
    for i in range(len(num)-1):
        min_index = i
        for j in range(i+1,len(num)):
            if num[j]<num[min_index]:
                min_index = j
        if i!=min_index:
            num[i],num[min_index] = num[min_index],num[i]
    
    return num

五、堆排序
堆排序使用完全二叉树的排序。有大根堆和小根堆，大根堆是左右结点的元素都比根小，小根堆是左右结点的元素都比根大。完全二叉树有个特点：当前元素的左孩子下标=当前元素坐标2+1；当前元素的右孩子下标=当前元素坐标2+2。
下面的代码是构建大顶堆，从左到右，从下到上，依次调整。

def adjust_Tree(num,start,end):
    temp = num[start]
    #指到左结点
    i = 2*start+1
    while i<end:
        #左结点和右结点哪个大
        if i+1<end and num[i]<num[i+1]:
            i += 1
        #现在i指向的是左右结点中大的那一个
        #如果i指向的结点的值大于根结点，根结点等于该值，start重新定位到i
        if num[i]>temp:
            num[start] = num[i]
            start = i
        #如果根结点就是最大的，不用进行下一步
        else:
            break
        i = i*2+1
     
    #被换下来的值给当前定位的值
    num[start] = temp
    
def Heap_sort(num):
    if len(num)<=1:
        return num
    
    #从最后一个非叶子结点一次向前，保证根部最大
    for i in range(len(num)//2)[::-1]:
        #构建大顶堆
        adjust_Tree(num,i,len(num))

    for i in range(1,len(num))[::-1]:
        #顶部和尾部交换
        num[0],num[i] = num[i],num[0]
        #其余的接着构建大顶堆
        adjust_Tree(num,0,i)
        
    return num

六、直接插入排序
将新来的数，插入到已经排好序的数组中。

def Insert_sort(num):
    if len(num)<=1:
        return num
    res = [num[0]]
    
    for i in range(1,len(num)):
        j = 0
        while j<len(res):
            if num[i]<=res[j]:
                break
            j += 1
        res.insert(j,num[i])
            
    return res

七、希尔排序（缩小增量排序）
先将整个待排记录序列分割为若干子序列，分别进行直接插入排序，待整个记录“基本有序”时，再对全体记录进行直接插入排序。

def Shell_sort(num):
    l = len(num)
    if l<=1:
        return num
    gap = l//2  #增量
    
    while gap>0: #增量逐渐减小
        for i in range(gap,l):
            #一趟希尔排序
            while i>=gap and num[i]<=num[i-gap]:
                num[i],num[i-gap] = num[i-gap],num[i]
                i -= gap
                
        gap = gap//2

八、归并排序
将两个或两个以上的有序数组组合成新的有序数组。

def merge(num,left,mid,right):

    temp = []
    i = left
    j = mid+1
    while i<=mid and j<=right:
        if num[i]<=num[j]:
            temp.append(num[i])
            i += 1
        else:
            temp.append(num[j])
            j += 1
    if i<=mid:
        temp += num[i:mid+1]
    if j<=right:
        temp += num[j:right+1]
    
    num[left:right+1] = temp
    
def sort(num,left,right):
    if left==right:
        return
    #先分为两部分，对两部分进行排序
    mid = left+(right-left)//2
    sort(num,left,mid)
    sort(num,mid+1,right)
    #合并排序后的两个子数组
    merge(num,left,mid,right)
    
def merge_sort(num):
    if len(num)<=1:
        return num
    sort(num,0,len(num)-1)
    
    return num