算法总结

算法考点：

	01.递归:代码简洁
	02.循环:栈来模拟递归
	03.排序算法:快速排序、归并排序
	04.查找算法:二分查找
	05.回溯法:二维数组搜索路径
	06.动态规划DP:最优解
	07.贪婪算法:存在特殊选择的情况
	08.位运算:与或非、异或、左移、右移
	09.分治法：divide and conquer
查找:
	A.顺序查找
		def SeqSearch(array,target):
			found = False
			if not array:
				return found
			for i in range(len(array)):
				if array[i] == target:
					found = True
					return found
			return found
		array = [1,2,3,4,5,6,10,20]
		print SeqSearch(array,10)
	B.二分查找 要求信手拈来二分查找代码！
		# -*- coding:utf-8 -*-
		def BinSearch(array,target):
			found = False
			if not array:
				return found
			else:
				low = 0
				high = len(array)-1
				while low < high:
					mid = (low+high)/2
					if array[mid] < target:
						low = mid + 1
					elif array[mid] > target:
						high = mid -1
					else:
						found = True
						return found
				return  found
		array = [1,2,3,4,5,6,10,20]
		print BinSearch(array,15)
		#时间复杂度：O(log n) 空间:常量
	C.哈希表查找 O(1)时间和额外的空间来实现哈希表，除了此功能还能进行MD5校验
		哈希表定义 f(k)=K f叫哈希函数  形成的表叫哈希表,相当于给出列表给出寻址的地址了。为啥要映射呢。。因为k不适合做索引，而K适合做索引。
	D.二叉排序树查找:二叉搜索树
		
排序：
　　　　　　额外空间消耗、平均时间复杂度、最差时间复杂度比较各个算法
　　　　　　十种实现方式：
		比较排序：
			简单排序：插入<插入顾名思义,要点在插入的位置>、选择<选择出最小的元素,然后插入第i个位置>、冒泡<N轮扫描,每次都是把最大的元素后移>
			复杂排序：快速排序<递归处理左右区间进行排序>、归并排序<分治法>、堆排序、希尔排序
						def qsort_record(array,left,right):
							if left >=right :
								return
							left_index = left
							right_index = right
							stand = array[left]

							while left_index < right_index:
								#交替进行一下步骤:step1 右边开始找出一个小于stand的元素 然后放到left_index的位置
								#step2 左边开始找出一个小于stand的元素 然后放到right_index的位置
								while left_index<right_index and array[right_index] >= stand:
									right_index = right_index -1 #第一个不大于stad的元素
								if left_index < right_index:
									array[left_index] = array[right_index]

								while left_index<right_index and array[left_index] <= stand:
									left_index = left_index + 1 #第一个不小于stad的元素
								if left_index < right_index:
									array[right_index] = array[left_index]
							array[right_index] = stand             #此时左右标记相等,将stand放入该位置
							qsort_record(array,left,left_index-1)  #递归处理左区间
							qsort_record(array, left_index +1 ,right)#递归处理右区间

						def quick_sort(array):
							qsort_record(array,0,len(array)-1)
						arr = [1,2,3,4,5,6,9,8]
						quick_sort(arr)
						print arr


						def merge(left,right):
							result = []
							while left and right:
								if left[0] <= right[0]:
									result.append(left.pop(0))
								else:
									result.append(right.pop(0))
							if left:
								result = result + left
							if right:
								result = result + right
							return  result

						def merge_sort(arr):
							if len(arr) <= 1:
								return arr
							mid = len(arr)/2
							left = arr[:mid]
							right = arr[mid:]

							left = merge_sort(left)
							right = merge_sort(right)

							return  merge(left,right)

						print merge_sort([8,4,5,7,1,3,6,2])			
			
		计数排序：
			计数排序、桶排序、基数排序
			
		排序总结：
		
		排序算法      最坏的时间复杂度   平均情况时间复杂度  最好情况时间复杂度  空间复杂度  稳定性
		简单插入排序    O(n^2)                  O(n^2)            O(n)               O(1)      是
		二分插入排序    O(n^2)					O(n^2)            nlog n            O(1) 		是
		直接选择排序    O(n^2)					O(n^2)				O(n)			O(1)		否