数据结构之排序

常用的数据结构及特征

快速排序法

一 、实例分析算法思路：
假设有一个数组 alist = [54,26,17,77,31,44,55,20], 按照升序排列

• 找到基准数： 一般取待排序序列的第一个，作为基准数
• 目标： 交换后， 基准数左边的数要全部小于基准数， 其右边的数要全部大于基准数
  步骤如下：
  1.序列第一个数作为排序基准数：54
  2.从后往前找到比基准数小的数进行对换，循环找到20小于54，则20和54对换位置，否则右边下标前移，继续循环判断 <-----
  alist = [20,26,17,77,31,44,55,54]
  3.从前往后找到比基准数大的进行对换，23小于54，左边下标后移，继续循环找到17小于54，左边下标后移，继续循环找到77大于54，则,77和54对换位置，否则左边下标后移，继续循环判断 ----->
  alist = [20,26,17,54,31,44,55,77]
  4.从后往前找到比基准数小的数进行对换 <-----
  alist = [20,26,17,44,31,54,55,77]
  至此，以基准数分为3部分，左边的都比其小，右边的都比其大，第一次以45为基准数的排序完成
  {20,26,17,44,31} {54} {55,77}
  5.对于这两部分{20,26,17,44,31}， {55,77}再通过递归快速排序。
  二 、算法实现

def quick_sort(alist,start,end):
	if start > end:
		return alist
	reference = alist[start]
	low = start
	high = end
	while start < end:
		while start < end and alist[high] >= reference:
			high -= 1
		alist[low] = alist[high]
		while start < end and alist[low] < reference:
			low += 1
		alist[high] = alist[low]
	alist[low] = reference
	quict_sort(alist,0,low-1)
	quick_sort(alist,low+1,end)
	return alist
if __name__ =="__main__":
	alist =  [54,26,17,77,31,44,55,20]
	result = quick_sort(alist,0,len(alist)-1)
	print(result)

注： 快速排序的最好的情况（每次数据划分得很均匀）时间复杂度为O（nlogn），最坏的情况（需排序的数据为正序或逆序排列时）复杂度为O（n^2）。

冒泡排序法

一、实例排序步骤分析
假设有一个数组 alist = [5,8,6,3,9,2,1,7], 按照升序排列
我们需要 拿第一个和第二个 对比，如果第一个比第二个大那么就换位置，如果小就不换。接下来拿第二个和第三个…这样依次下去比到最后 我们把这些数中最大的一个放在了右边， 然后再重复以上的方式，就把这些数中第二个大的放在了倒数第二位，依次下去…
二、算法实现

def Bubble_sort(alist):
	n = len(alist)
	for i in range(n-1):
		count = 0
		for j in range(n-1-i):
			if alist[j] > alist[j+1]:
				alist[j],alist[j+1] = alist[j+1],alist[j]
				count += 1
		if count == 0:
			break
		return alist
if __name__ == "__main__":
    alist =  [5,8,6,3,9,2,1,7]
    result = Bubble_sort(alist)
    print(result) 

注：冒泡算法的时间复杂度O(n^2)

选择排序法

一、实例分析算法思路
假设有一个数组 alist = [54,26,93,17,77,31,44,55]，按照升序排序
第一轮依次比较相邻两个元素，将最小的一个元素的索引和值记录下来，然后和第一个元素进行交换。
　　如上面的数组中，首先比较的是54和26，记录比较小是26，它的索引是1；接着比较26和93，记录比较小的索引还是1；直到最后得到最小值是17，它的索引是3；然后索引3和0互相交换， alist = [17,26,93,54,77,31,44,55]

第二轮比较的时候，由于第一轮已经找出了一个最小的数17，所以，就不用再管它了，它已经处于“有序区”，接下来，才是第二轮的正式工作的开始，即按照第一轮的方法，找出“无序区”中最小的一个元素，让它和索引1位置的数进行交换，即像上文中“原理”中提到的那样——每一轮比较得出最小的那个值，然后依次和每轮“无序区”中参与比较的第一个值进行交换。同理类推~
二、算法实现

def select_sort(alist):
	for i in range(len(alist)-1):
		min_index = i
		for j in range(i+1,len(alist)):
			if alist[min_index] > alist[j]:
				min_index = j
			if min_index != i:
				alist[min_index],alist[i] = alist[i],alist[min_index]
	return alist
if __name__ == "__main__":
    alist = [54,26,93,17,77,31,44,55]
    result = select_sort(alist)
    print(result)

插入排序法

一、实例分析算法思路
假设有一个数组 alist = [5,2,4,6,1,3]，按照升序排序
对于一个数组，我们从第二个数字开始，将其认为是新增加的数字，这样第二个数字只需与其左边的第一个数字比较后排好序；在第三个数字，认为前两个已经排好序的数字为手里整理好的牌，那么只需将第三个数字与前两个数字比较即可；以此类推，直到最后一个数字与前面的所有数字比较结束，插入排序完成。

二、算法实现

def insert_sort(alist):
	for j in range(1,len(alist)):
		i = j
		while i > 0:
			if alist[i] > alist[i-1]:
				alist[i],alist[i-1] = alist[i-1],alist[i]
			else:
				break
			i -= 1
	return alist
if __name__ == "__main__":
	alist = [5,2,4,6,1,3]
	result = insert_sort(alist)
	print(result)

归并排序法

一、实例分析算法思路
假设有一个数组 alist = [54,26,93,17,77,31,44,55]，按照升序排序
归并排序法，首先是分解
[54,26,93,17,77,31,44,55]
[54,26,93,17] [77,31,44,55]
[54,26] [93,17] [77,31] [44,55]
[54] [26] [93] [17] [77] [31] [44] [55]
再比较列表数字大小进行合并
[26,54] [17,93] [31,77] [44,55]
[17,26,54,93] [31,44,55,77]
[17,26,31,44,54,55,77,93]
二、算法实现

def merge_sort(nums):
    n = len(nums)
    if n <= 1:
        return nums
    mid = n // 2
    left_li = merge_sort(nums[0:mid])
    right_li = merge_sort(nums[mid:])
    result = []
    left_point,right_point = 0,0
    while left_point < len(left_li) and right_point < len(right_li):
        if left_li[left_point] < right_li[right_point]:
            result.append(left_li[left_point])
            left_point += 1
        else:
            result.append(right_li[right_point])
            right_point += 1
    result += left_li[left_point:]
    result += right_li[right_point:]
    return result


if __name__ == "__main__":
    alist = [54,26,93,17,77,31,44,55]
    result = merge_sort(alist)
    print(result)