1.冒泡排序
- 又称交换排序法，原理是：从第一个元素开始，比较相邻元素的大小，若大小顺序有误，则对调顺序后再进行下一个元素的对比。如此扫描过一次之后就可确保最后一个元素位于正确的顺序，接着再进行第二次扫描，直到所有元素的排序关系为止。这里看出是对一个序列进行移动交换操作，它的时间复杂度为O(n^2)。
其示意图如下图所示：
冒泡排序
''' 冒泡排序 '''
def bubble_sort(list):
n = len(list)
count = 0
for j in range(n-1):
for i in range(n-1-j):
if list[i] > list[i+1]:
list[i],list[i+1] = list[i+1],list[i]
count += 1
if count == 0:
return
#list有n个数，需要进行n-1次排序
#从左往右排序，第一次排序移动n-2次，第二次排序移动n-3次...
if __name__ == '__main__':
list = [65,12,33,72,5,8,45,28]
print(list)
bubble_sort(list)
print(list)
2.插入排序
- 从数据最左拿一个元素，然后与第二个元素比较进行排序，组成新的序列，再将新的序列与第三个元素比较进行排序，重复上述操作最后得到正序或者倒序的数据。这里可以看成是两个序列，将旧序列最左的元素添加到新序列中并进行排序。
其示意图为：
插入排序
''' 插入排序 '''
def insert_sort(list):
n = len(list)
for j in range(1,n):
i = j
while i > 0:
if list[i] < list[i-1]:
list[i],list[i-1] = list[i-1],list[i]
i -= 1
else:
break
# i代表能蹭循环起始值
# i=j 执行从右边的无序序列中取出第一个元素，即i位置，插入前面正确的位置
if __name__ == '__main__':
list = [65, 12, 33, 72, 5, 8, 45, 28]
print(list)
insert_sort(list)
print(list)
3.选择排序
- 从序列最左边拿出一个元素作为初始值，与右边序列的每个值进行对比，若右边的值小于初始值，交换元素，直到整个右边的元素对比完毕；然后取出右边序列最左边元素作为初始值，重复上述步骤，最后组成新的序列。
其示意图为：
选择排序
''' 选择排序 '''
def select_sort(list):
n = len(list)
for j in range(0,n-1):
min_index = j
for i in range(j+1,n):
if list[min_index] > list[i]:
min_index = i
list[j],list[min_index] = list[min_index],list[j]
#将最左边的的值作为初始值与右边的值进行对比，当右边的值小于初始值，交换元素，直到整个右边对比完
#将对比的结果作为最左边的值，从第二位开始，重复第一步的步骤
if __name__ == '__main__':
list = [65, 12, 33, 72, 5, 8, 45, 28]
print(list)
select_sort(list)
print(list)
4.希尔排序
- 选取一个步长，例如 1 2 3 4 5 6，步长为2的话，会把数组分成1 3 5，2 4 6，这样分开之后对每部分进行直接插入排序，下一步缩小步长继续上述步骤，直至步长为1。
其示意图如下图所示：
希尔排序
''' 希尔排序 '''
def shell_sort(list):
n = len(list)
gap = n // 2
while gap > 0:
for j in range(gap,n):
i = j
while i > 0:
if list[i] < list[i-gap]:
list[i],list[i-gap] = list[i-gap],list[i]
i -= gap
else:
break
if __name__ == '__main__':
list = [65, 12, 33, 72, 5, 8, 45, 28]
print(list)
shell_sort(list)
print(list)
5.快速排序
它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
其示意图如下图所示：
快速排序
# 快速排序-分而治之
def quickSort(list):
# 基线条件：为空或只包含一个元素的数组是“有序”的
if len(list) < 2:
return list
else:
pivot = list[0]
# 由所有小于基准值的元素组成的子数组
low = [i for i in list[1:] if i <= pivot]
# 由所有大于基准值的元素组成的子数组
high = [i for i in list[1:] if i > pivot]
return quickSort(low) + [pivot] + quickSort(high)
if __name__ == '__main__':
list = [65, 12, 33, 72, 5, 8, 45, 28]
print(list)
list = quickSort(list)
print(list)
6.归并排序
- 把长度为n的输入序列分成两个长度为n/2的子序列；对这两个子序列分别采用归并排序；将两个排序好的子序列合并成一个最终的排序序列。
其示意图如下图所示：
归并排序
'''归并排序'''
def merge_sort(list):
n = len(list)
if n <= 1:
return
mid = n//2 #拆分序列
#left采取归并排序后形成的有序的新的列表
left_list = merge_sort(list[:mid])
#right采取归并排序后形成的有序的新的列表
rigth_list = merge_sort(list[mid:])
#将两个子序列合并成一个新的整体
left_point,right_point = 0,0
result = []
while left_point < len(left_list) and right_point < len(rigth_list):
if left_list[left_point] < rigth_list[right_point]:
result.append(left_list[left_point])
left_point += 1
else:
result.append(rigth_list[right_point])
right_point += 1
result += left_list[left_point]
result += rigth_list[right_point]
return result
if __name__ == '__main__':
list = [65, 12, 33, 72, 5, 8, 45, 28]
print(list)
merge_sort(list)
print(list)
7.二分法查找
''' 二分法查找 '''
def binary_search(list,item): #二分法查找,递归
n = len(list)
if n > 0:
mid = n // 2
if list[mid] == item:
return True
elif item < list[mid]:
return binary_search(list[:mid],item)
else:
return binary_search(list[mid+1:],item)
return False
def binary_search_(list,item): #二分查找,非递归
n = len(list)
first = 0
last = n-1
while first <= last:
mid = (first+last)//2
if list[mid] == item:
return True
elif item < list[mid]:
last = mid-1
else:
first = mid+1
return False
if __name__ == '__main__':
list = [5,8,12,28,33,45,65,72]
print(binary_search(list,33))
print(binary_search(list,99))
print(binary_search_(list,33))
print(binary_search_(list,99)) 