备战秋招——记录自己学习的第三天（快速排序、归并排序、二分查找）

一、利用python实现快速排序

快速排序

快速排序（英语：Quicksort），又称划分交换排序（partition-exchange sort），通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
步骤为：
1.从数列中挑出一个元素，称为"基准"（pivot），
2.重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
3.递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

这样讲可能太抽象了。我们这样来说，假设数组alist = [55,45,65,78,42,32,15]，把第一个元素55看成基准元素，那么找到一个数组，55左边部分都比它小，右边部分都比它大。这里假设存在两根指针：low、high，low的起始位置指向的是55，high的起始位置指向15，即alis[low] = 55，alist[high] = 15。alist[high] <55，那么alist[low] = alist[high]，此时low指针右移，alist[low] = 45,他是小于55的，则指针右移，此时alist[65] > 55,那么alis[high] = alist[low]…………最后low和high两根重叠在一起，将55放进去。

接着，我们进行第二轮，将55左边的数看成一个数组，右边的数也看成一个数组……

直到最后，数组的长度小于等于1，也就是low和high一开始就是重合，这时候我们就得到了结果。

根据上面的步骤，我们能明显的看出，这些步骤可以用递归进行实现（即函数内部调用自身函数）下面用代码去实现：

def quick_sort(alist,first,last):

	"""创建递归函数，传入列表、low的起始索引、high的起始索引"""
	if first >= last: # 此时列表中有一个元素或者为空，就不需要排序了
		return
		
	mid_value = alist[first]   #设置起始位置的元素为要寻找位置的基准元素
	low = first  
	high = last
	
	while low < high:  # 即当索引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_sort(alist,first,low-1)# 对基准元素左边的子序列进行快速排序
	
	quick_sort(alist,low+1,last)# 对基准元素右边的子序列进行快速排序
	
if __name__ == "__main__":
    li = [45,25,12,86,42,14]
    quick_sort(li,0,len(li)-1)
    print(li)	

运行结果如下：
	[12, 14, 25, 42, 45, 86]

最优时间复杂度：O(nlogn)
最坏时间复杂度：O(n2)
稳定性：不稳定
例如：[1,0,0,0]

二、利用python实现归并排序

归并排序

归并排序是采用分治法的一个非常典型的应用。归并排序的思想就是先递归分解数组，再合并数组。

将数组分解最小之后，然后合并两个有序数组，基本思路是比较两个数组的最前面的数，谁小就先取谁，取了后相应的指针就往后移一位。然后再比较，直至一个数组为空，最后把另一个数组的剩余部分复制过来即可。

即将列表分成每个仅包含一个元素的小列表，然后两两比较，再两两合并…………

下面用代码去实现：

def merge_sort(alist):
	n = len(alist)
	
	if n <= 1:
		return alist #这里与快排不一样，快排传入的永远是一个列表，而归并传入的是一个个分割的列表
	mid = n//2
	
	#将左边的列表进行分割
	left_li = merge_sort(alist[:mid])
	#将右边的列表进行分割
	right_li = merge_sort(alist[mid:])
	
	#左右两边都设置一个指针
	left_pointer = 0
	right_pointer = 0
	result = [] #创建一个新的列表，用来存放打散的各个列表
	#设置终止条件
	while left_pointer < len(left_li) and right_pointer < len(right_li):
	
		if left_li[left_pointer] <= right_li[right_pointer]: #将小的元素添加进去，形成有序列表
			result.append(left_li[left_pointer])
			left_pointer += 1
		else:
			result.append(right_li[right_pointer])
			right_pointer += 1
	#将剩余部分添加进去，因为其中一个列表必定为空，两者先后顺序无所谓
	result += left_li[:left_pointer]
	result += right_li[right_pointer]
	return result
		
if __name__ == "__main__":
    alist = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    sorted_alist = merge_sort(alist)
    print(sorted_alist)	
		
执行结果如下：
[17, 20, 26, 31, 44, 54, 55, 77, 93]

最优时间复杂度：O(nlogn)
最坏时间复杂度：O(nlogn)
稳定性：稳定

三、二分查找

搜索
搜索是在一个项目集合中找到一个特定项目的算法过程。搜索通常的答案是真的或假的，因为该项目是否存在。 搜索的几种常见方法：顺序查找、二分法查找、二叉树查找、哈希查找

二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

下面用两种方式实现：
首先用递归方式实现二分查找：

def binary_search(alist,item):
	num = len(alist)
	if num >0:
		mid = num // 2
		if alist[mid] == item:
			return True
			
		elif alist[mid] > item:
			return binary_search(alist[:mid])
			
		elif alist[mid] > item:
			return binary_search(alist[mid+1:])
	return False
	
if __name__ == "__main__":
    li = [1,2,3,4,5,6]
    binary_search(li,5)
    print(binary_search(li,5))
运行结果如下：
True

再用非递归方式进行实现：

def binary_search(alist,item):
	num = len(alist)
	first_pointer = 0
	last_pointer = num-1
	while first_pointer < last_pointer:
		mid = (first_pointer + last_pointer) // 2
		if alist[mid] == item:
			return True
		elif alist[mid] < item
			first_pointer = mid+1
		else:
			last_pointer = mid-1
			
	```