如何写代码：
01.提炼问题 要明确需求
02.分析问题 -->动脑子 产出：思路报告 即我是怎么想到的
03.落实到代码
04.实例测试 看看能否满足需求 如果不能那么请debug
05.时间和空间复杂度
目的：
算法的入门篇 10种排序算法和3种查找算法
参考：
《数据结构和算法 python语言描述》
查找：
01.线性查找
def seq_find(array,target):
found = False
for ele in array:
if ele == target:
found = True
return found
02.二分查找
def binary_search(array,target)
found = False
start = 0
end = len(array) -1
while first <= last and not found:
middle = (start+end) //2
if array[middle] == target:
found = True
else:
if array[middle] > target:
end = middle -1
else:
start = middle + 1
return found
03.hash查找
hash查找知道时间复杂度是1就可以了吧？常用的hash取余的算法 还是解决冲突的算法 没必要了
排序：01-04是简单的排序 05-07是复杂排序 08-10是线性排序
01.插入排序
提炼问题：很明确,要求我们通过插入的方式实现排序,重点在插入
分析问题：首先第一个元素是有序的,那么只需要将后续的元素插入到合适的位置即可;
后续元素如何处理呢？比如pos=k的元素 只需要将该元素的值提炼出来 依次和前边的元素pos-1进行比较，直至pos>0或者lst[pos-1]< value of k
代码：
def insert_sort(lst):
for index in range(1,len(lst)):
pos = index
val = lst[index]
while pos >0 and val < lst[pos-1]:
lst[pos] = lst[pos-1]
pos = pos -1
lst[pos] = val
测试:
array = [25,67,54,33,20,78,65,49,17,56,44]
insert_sort(array)
print array
时间和空间复杂度：O(n**2) O(1)
02.冒泡排序
提炼问题：像冒泡一样 相邻元素两两比较 直至最大的到最后
分析问题：以N个元素的列表为例，需要进行N-1次冒泡，第一次冒泡需要N-1次比较 第二次冒泡需要比较N-2次 第N-1次需要比较1次
代码：
def bubble_sort(lst):
pass_num = len(lst)-1
for num in range(pass_num,0,-1):
for i in range(num):
if lst[i] > lst[i+1]:
lst[i],lst[i+1] = lst[i+1],lst[i]
测试:
array = [25,67,54,33,20,78,65,49,17,56,44]
bubble_sort(array)
print array
时间和空间复杂度：O(n**2) O(1)
03.选择排序
提炼问题：重在选择
分析：假设index=0的元素值最大,遍历一遍 选出最大的放到末尾 如此遍历N次
代码：
def insert_sort(lst):
for index in range(1, len(lst)):
pos = index
val = lst[index]
while pos > 0 and val < lst[pos - 1]:
lst[pos] = lst[pos - 1]
pos = pos - 1
lst[pos] = val
测试：
array = [25, 67, 54, 33, 20, 78, 65, 49, 17, 56, 44]
insert_sort(array)
print array
时间和空间复杂度：O(n**2) O(1)
04.
如何写代码：
01.提炼问题 要明确需求
02.分析问题 -->动脑子 产出：思路报告 即我是怎么想到的
03.落实到代码
04.实例测试 看看能否满足需求 如果不能那么请debug
05.时间和空间复杂度
目的：
算法的入门篇 10种排序算法和3种查找算法
参考：
《数据结构和算法 python语言描述》
查找：
01.线性查找
def seq_find(array,target):
found = False
for ele in array:
if ele == target:
found = True
return found
02.二分查找
def binary_search(array,target)
found = False
start = 0
end = len(array) -1
while first <= last and not found:
middle = (start+end) //2
if array[middle] == target:
found = True
else:
if array[middle] > target:
end = middle -1
else:
start = middle + 1
return found
03.hash查找
hash查找知道时间复杂度是1就可以了吧？常用的hash取余的算法 还是解决冲突的算法 没必要了
排序：01-04是简单的排序 05-07是复杂排序 08-10是线性排序
01.插入排序
提炼问题：很明确,要求我们通过插入的方式实现排序,重点在插入
分析问题：首先第一个元素是有序的,那么只需要将后续的元素插入到合适的位置即可;
后续元素如何处理呢？比如pos=k的元素 只需要将该元素的值提炼出来 依次和前边的元素pos-1进行比较，直至pos>0或者lst[pos-1]< value of k
代码：
def insert_sort(lst):
for index in range(1,len(lst)):
pos = index
val = lst[index]
while pos >0 and val < lst[pos-1]:
lst[pos] = lst[pos-1]
pos = pos -1
lst[pos] = val
测试:
array = [25,67,54,33,20,78,65,49,17,56,44]
insert_sort(array)
print array
时间和空间复杂度：O(n**2) O(1)
02.冒泡排序
提炼问题：像冒泡一样 相邻元素两两比较 直至最大的到最后
分析问题：以N个元素的列表为例，需要进行N-1次冒泡，第一次冒泡需要N-1次比较 第二次冒泡需要比较N-2次 第N-1次需要比较1次
代码：
def bubble_sort(lst):
pass_num = len(lst)-1
for num in range(pass_num,0,-1):
for i in range(num):
if lst[i] > lst[i+1]:
lst[i],lst[i+1] = lst[i+1],lst[i]
测试:
array = [25,67,54,33,20,78,65,49,17,56,44]
bubble_sort(array)
print array
时间和空间复杂度：O(n**2) O(1)
03.选择排序
提炼问题：重在选择
分析：假设index=0的元素值最大,遍历一遍 选出最大的放到末尾 如此遍历N次
代码：
def insert_sort(lst):
for index in range(1, len(lst)):
pos = index
val = lst[index]
while pos > 0 and val < lst[pos - 1]:
lst[pos] = lst[pos - 1]
pos = pos - 1
lst[pos] = val
测试：
array = [25, 67, 54, 33, 20, 78, 65, 49, 17, 56, 44]
insert_sort(array)
print array
时间和空间复杂度：O(n**2) O(1)
04.希尔排序
不是重点 不写了 有空再补上吧
05.归并排序
提炼问题：8 4 2 1
分析：两两合并 然后递归
代码：
def merge(list_l,list_r):
point_l = 0
point_r = 0
res = []
while point_l < len(list_l) and point_r < len(list_r):
if list_l[point_l] < list_r[point_r]:
res.append(list_l[point_l])
point_l += 1
else:
res.append(list_r[point_r])
point_r += 1
res += list_l[point_l:]
res += list_r[point_r:]
return res
def merge_sort(lst):
if len(lst) <= 1:
return lst
middle = len(lst)//2
left = merge_sort(lst[:middle])
right = merge_sort(lst[middle:])
return merge(left,right)
array = [25,67,54,33,20,78,65,49,17,56,44]
print merge_sort(array)
06.快速排序
代码：
# -*- coding:utf-8 -*-
def quick_sort(lst):
quick_sort_rec(lst,0,len(lst)-1)
def quick_sort_rec(lst,first,last):
if first < last:
split_point = partition(lst,first,last)
quick_sort_rec(lst,first,split_point-1)
quick_sort_rec(lst,split_point+1,last)
def partition(lst,first,last):
pivot_value = lst[first]
left_mark = first + 1
right_mark = last
done = False
while not done:
while left_mark <= right_mark and lst[left_mark] <= pivot_value:
left_mark = left_mark + 1
while lst[right_mark] >= pivot_value and right_mark >= left_mark:
right_mark = right_mark - 1
if right_mark < left_mark:
done = True
else:
temp = lst[left_mark]
lst[left_mark] = lst[right_mark]
lst[right_mark] = temp
temp = lst[first]
lst[first] = lst[right_mark]
lst[right_mark] = temp
return right_mark
array = [54, 26, 93, 17, 77, 31, 44, 55, 20]
quick_sort(array)
print array
07.堆排序
留到二叉树部分
08-10.基数排序、桶排序、计数排序 基本用不到 用到再聊吧 桶排序可能会有
