python数据结构与算法-排序算法

1.冒泡排序

• 对一个列表中两两相邻的数据进行比对，如果有n个数据，那么就需要比对n-1项。
• 如果一个项是最大值，那么他就会通过比对，然后交换位置，一直交换到最后一个正确的位置，就类似于冒泡一样。
• 一共需要比对O(n)轮，每轮比对O(n)个数据，所以时间复杂度为O(n^2)
  

def maopao_sort(alist):
	for i in range(len(alist)-1,0,-1):
		j = i
		for j in range(0,j):
			if alist[j]>alist[j+1]:
				alist[j],alist[j+1]=alist[j+1],alist[j]
			else:
				continue

2.选择排序

• 选择排序提高了冒泡排序的性能，每次遍历后选择当前列表中的一个最大项（最小项），放在队尾（队首）位置。
• 第一次遍历使最大项（最小项）归位，第二次遍历使次大项（次小项）归位，一共遍历n-1次。
  

def search_sort(alist):
	length=len(alist)
	for i in range(length):
		max = 0 
		for j in range(i):
			if alist[j]>alist[max]:
				max=j
		alist[j],alist[max]=alist[max],alist[j]

3.插入排序

• 从第一个元素开始，改元素被认为已经排好序
• 取下一个元素，在已经排序好的序列中项前扫描
• 若在已排序的元素中有元素大于新元素，统一移向新元素下一位置（右边）
• 重复步骤3直到找到小于或等于新元素的的位置
• 插入新元素到该位置后
• 重复2-5步骤
  

def insert_sort(alist):
    n = len(alist)
    if n == 1:
        return alist
    else:
        for i in range(1,n):
            j = i
            target = alist[i]
            while j>0 and alist[j]<alist[j-1]:
                alist[j] = alist[j-1]
                j = j-1
            alist[j] = target
        return alist

4.希尔排序

• 希尔排序是插入排序的优化版，又称为缩小增量排序。将列表分为n个组，然后对各组相对应的元素进行比较大小并交换位置。
• 分为n/2个组，重复上一步操作，直到每一组只包含一个元素，然后停止。
  
  

def shll_sort(alist):
	n = len(alist)
	gap = n//2 #定义初始步长，要取整数，否则下面for循环会报错'float' object cannot be interpreted as an integer
	while gap>0:#按步长进行插入排序
		for i in range(gap,n):
			j = i
			while j>=gap and alist[j-gap]>alist[j]:
				alist[j-gap],alist[j]=alist[j],alist[j-gap]
				j=j-gap 
		gap = gap//2#得到新的步长,注意是在while后面的缩进

5.归并排序

• 顾名思义，归并排序就是将列表中的元素先全部分为单个子元素，然后再两两合并为一组并从小到大排序；结束后再两个组两个组的互相合并为一组并排序；直到最终合并为一个组并排序，得到最终排序序列。如下图所示：

语言理解起来可能较困难，可以直接通过此视频了解：
5分钟了解归并排序

def merge(arr, low, mid, high):
    # low 和 high 为整个数组的第一个和最后一个位置索引，mid 为中间位置索引
    # i 和 j 为指针，最初位置分别为两个有序序列的起始位置
    # ltmp 用来存放合并后的序列
    i = low
    j = mid+1
    ltmp = []
    while i <= mid and j <= high:  # 只要左右两边都有数
        if arr[i] < arr[j]:        # 当左边的数小于右边的数
            ltmp.append(arr[i])    # 将左边的数存入 ltmp
            i += 1                 # 左边的指针往右移一位
        else:                      # 当右边的数小于左边的数
            ltmp.append(arr[j])    # 将右边的数存入 ltmp
            j += 1                 # 右边的指针往右移一位
    # 上面的 while 语句执行完后，左边或者右边没有数了
    while i <= mid:                # 当左边还有数的时候
        ltmp.append(arr[i])        # 将左边剩下的数全部存入 ltmp
        i += 1
    while j <= high:               # 当右边还有数的时候
        ltmp.append(arr[j])        # 将右边剩下的数全部存入 ltmp
        j += 1
    arr[low:high+1] = ltmp         # 将排序后的数组写回原数组


def merge_sort(arr, low, high):       # low 和 high 为整个数组的第一个和最后一个位置索引
    if low < high:                    # 至少有两个元素
        mid = (low + high) // 2
        merge_sort(arr, low, mid)     # 把左边递归分解
        merge_sort(arr, mid+1, high)  # 把右边递归分解
        merge(arr, low, mid, high)    # 做归并

6.快速排序

• 选定一个中心轴pivot
• 将大于中心轴pivot的放在其右边
• 将小于中心轴pivot的放在其左边
• 分别对pivot左右子序列重复前3步操作

语言理解起来可能较困难，可以直接通过此视频了解：
5分钟了解快速排序

def partition(alist, left, right):
    # 归位操作，left，right 分别为数组左边和右边的位置索引
    midvalue = alist[left]
    while left < right:
        while left < right and alist[right] >= midvalue:  # 从右边找比 tmp 小的数，如果比 tmp 大，则移动指针
            right -= 1                             # 将指针左移一个位置
        alist[left] = alist[right]                     # 将右边的值写到左边的空位上
        while left < right and alist[left] <= midvalue:   # 从左边找比 tmp 大的数，如果比 tmp 小，则移动指针
            left += 1                              # 将指针右移一个位置
        alist[right] = alist[left]                     # 将左边的值写到右边的空位上
    alist[left] = midvalue                                # 把 tmp 归位
    return left                   # 返回 left，right 都可以，目的是便于后面的递归操作对左右两部分进行排序


def quick_sort(alist, left, right):          # 快速排序
    if left < right:
        mid = partition(alist, left, right)
        quick_sort(alist, left, mid-1)       # 对左半部分进行归位操作
        quick_sort(alist, mid+1, right)      # 对右半部分进行归位操作
    return alist

收工，
归并排序没有自己写，直接复制粘贴的，明天补上。