二、python中的常见算法
冒泡排序
效率:O(n2)
原理:
比较相邻的元素,如果第一个比第二个大,就交换他们两个;
对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。做完以后,最后的元素会是最大的数,这里可以理解为走了一趟;
针对所有的元素重复以上的步骤,除了最后一个;
持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较,最后数列就是从大到小一次排列;
demo:
```cpp
def bubble_sort(data):
"""
冒泡排序
:param data:
:return:
"""
for i in range(len(data)-1): # 趟数
for j in range(len(data)-i-1): # 遍历数据,依次交换
if data[j]>data[j+1]: # 当较大数在前面
data[j],data[j+1]=data[j+1],data[j] #交换两个数的位置
if __name__=='__main__':
import random
data_list=list(range(30))
random.shuffle(data_list)
print("pre:",data_list)
bubble_sort(data_list)
print("after:",data_list)
#结果:
#pre: [22, 11, 19, 16, 12, 18, 20, 28, 27, 4, 21, 10, 9, 7, 1, 6, 5, 29, 8, 0, 17, 26, 13, 14, 15, 24, 25, 23, 3, 2]
#after: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
优化版本:当某一趟走完以后发现并没有进行数据交换,那么此时的数列已经排列好了,没有必要在进行下去。例如:极端情况下,数列本来已经排序好的,我们只需要走一趟即可完成排序。
def bubble_sort(data):
"""
冒泡排序优化版
:param data:
:return:
"""
for i in range(len(data)-1): # 趟数
exchange=False # 交换标志
for j in range(len(data)-i-1): # 遍历数据,依次交换
if data[j]>data[j+1]: # 当较大数在前面
data[j],data[j+1]=data[j+1],data[j] # 交换两个数的位置
exchange = True # 改变标志
if not exchange: # 如果某一趟没有进行交换,代表排序完成
break
return i # 返回次数的趟数
if __name__=='__main__':
data_list=list(range(30))
print("pre:",data_list)
num =bubble_sort(data_list)
print("after:",data_list,'趟数:',num+1)
#结果:
#pre: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
#after: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29] 趟数: 1
选择排序
效率:O(n2)
原理:
每一次从待排序的列表中选出一个元素,并将其与其他数依次比较,若列表中的某个数比选中的数小,则交换位置,把所有数比较完毕,则会选出最小的数,将其放在最左边(这一过程称为一趟);
重复以上步骤,直到全部待排序的数据元素排完;
demo:
def select_sort(data):
"""
选择排序
:param data: 待排序的数据列表
:return:
"""
for i in range(len(data)-1): #趟数
min_index=i # 记录i趟开始最小的数的索引,我们从最左边开始
for j in range(i+1,len(data)): # 每一次趟需要循环的次数
if data[j] < data[min_index]: # 当数列中的某一个数比开始的数要小时候,更新最小值索引位置
min_index=j
data[i],data[min_index]=data[min_index],data[i] # 一趟走完,交换最小值的位置,第一趟最小
if __name__=='__main__':
import random
data_list=list(range(30))
random.shuffle(data_list) # 打乱列表数据
print("pre:",data_list)
select_sort(data_list)
print("after:",data_list)
#结果:
#pre: [20, 11, 22, 0, 18, 21, 14, 19, 7, 23, 27, 29, 24, 4, 17, 15, 5, 10, 26, 13, 25, 1, 8, 16, 3, 9, 2, 28, 12, 6]
#after: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
插入排序
效率:O(n2)
原理:
以从小到大排序为例,元素0为第一个元素,插入排序是从元素1开始,尽可能插到前面。
插入时分插入位置和试探位置,元素i的初始插入位置为i,试探位置为i-1,在插入元素i时,依次与i-1,i-2······元素比较,如果被试探位置的元素比插入元素大,那么被试探元素后移一位,元素i插入位置前移1位,直到被试探元素小于插入元素或者插入元素位于第一位。
重复上述步骤,最后完成排序
demo:
def insert_sort(data):
"""
插入排序
:param data: 待排序的数据列表
:return:
"""
for i in range(1, len(data)): # 无序区域数据
tmp = data[i] # 第i次插入的基准数
for j in range(i, -1, -1):
if tmp < data[j - 1]: # j为当前位置,试探j-1位置
data[j] = data[j - 1] # 移动当前位置
else: # 位置确定为j
break
data[j] = tmp # 将当前位置数还原
if __name__=='__main__':
import random
data_list=list(range(30))
random.shuffle(data_list) # 打乱列表数据
print("pre:",data_list)
insert_sort(data_list)
print("after:",data_list)
#结果:
#pre: [7, 17, 10, 16, 23, 24, 13, 11, 2, 5, 15, 29, 27, 18, 4, 19, 1, 9, 3, 21, 0, 14, 12, 25, 22, 28, 20, 6, 26, 8]
#after: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
快速排序
效率:平均O(nlogn)
原理:
从数列中随机挑选出一个数作为基数;
重新排列数列,使得比基数小的元素在左边,比基数大元素在右边,相等的元素放左边或者右边都可以,最后使得该基数在处于数列中间位置,这个称为分区操作;
递归上述操作,完成排序,如下如;
demo:
#!/usr/bin/env python3
#_*_ coding:utf-8 _*_
#Author:wd
def quick_sort(data,left,right):
"""
快速排序
:param data: 待排序的数据列表
:param left: 基准数左边元素的索引
:param right: 基准数右边元素的索引
:return:
"""
if left < right:
mid = partition(data,left,right) # 分区操作,mid代表基数所在的索引
quick_sort(data,left,mid-1) # 对基准数前面进行排序
quick_sort(data,mid+1,right) # 对基准数后面进行排序
def partition(data,left,right):
tmp=data[left] # 随机选择的基准数,从最左边开始选
while left < right:
while left < right and data[right] >= tmp: # 右边的数比基准数大
right-=1 # 保留该数,然后索引指针往左移动
data[left]=data[right] # 否则此时右边数比基数小,则将该数放到基准位置
while left < right and data[left] <= tmp: # 右边的数比基准数小
left+=1 # 此时保持该数位置不动,索引指针往前移动
data[right]=data[left] # 否则此时左边的数比基数大,则将该数放到右边
data[left] = tmp # 最后将基准数量放回中间
return left # 返回基准数位置
if __name__=='__main__':
data_list=[1,3,21,6,50,33,34,58,66]
quick_sort(data_list,0,len(data_list)-1)
print(data_list)
###结果:[1, 3, 6, 21, 33, 34, 50, 58, 66]
堆排序
堆定义:本质是一个完全二叉树,如果根节点的值是所有节点的最小值称为小根堆,如果根节点的值是所有节点的最大值,称为大根堆。
效率:O(nlogn)
原理:
将待排序数据列表建立成堆结构(建立堆);
通过上浮(shift_up)或下沉(shift_down)等操作得到堆顶元素为最大元素(已大根堆为例);
去掉堆顶元素,将最后的一个元素放到堆顶,重新调整堆,再次使得堆顶元素为最大元素(相比第一次为第二大元素);
重复3操作,直到堆为空,最后完成排序;
demo:
def sift(data, low, high):
"""
调整堆函数
:param data: 带排序的数据列表
:param low: 值较小的节点的位置,可以理解为是根节点
:param high:值较大的节点的位置
:return:
"""
i = low
j = 2 * i # 父节点i所对应的左孩子
tmp = data[i] # 最较小节点的值
while j <= high:
if j < high and data[j] < data[j + 1]: # 如果右孩子比左孩子大则把j指向右节点
j += 1 # 指向右节点
if tmp < data[j]: # 如果此时位置较小的节点值比该节点值小,则将该节点上浮最为新的父节点,并调整该节点双亲
data[i] = data[j]
i = j # 调整该节点的双亲的位置
j = 2 * i
else:
break # 否则代表本次调整已经完成,并且节点i已经无值
data[i] = tmp # 最后将被调整节点的值放到i节点上(空出的位置)
def heap_sort(data):
"""
堆排序
:param data: 待排序的数据列表
:return:
"""
n = len(data)
for i in range(n // 2 - 1, -1, -1):
sift(data, i, n - 1)
# 构建堆
for i in range(n - 1, -1, -1): # 调整过程,从最后一个元素开始交换
data[0], data[i] = data[i], data[0] # 交换
sift(data, 0, i - 1) # 开始调整
if __name__ == '__main__':
import random
data_list = [1, 3, 21, 6, 50, 33, 34, 58, 66]
random.shuffle(data_list) # 打乱列表数据
print("pre:", data_list)
heap_sort(data_list)
print("after:", data_list)
#结果:
#pre: [66, 3, 58, 34, 1, 33, 21, 6, 50]
#after: [1, 3, 6, 21, 33, 34, 50, 58, 66]
归并排序
效率:O(nlogn)
空间复杂度:O(n)
原理:
申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列;
设定两个指针,最初位置分别为两个已经排序序列的起始位置;
比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置;
重复步骤3直到某一指针达到序列尾;
将另一序列剩下的所有元素直接复制到合并序列尾。
demo:
def merge(data, low, mid, high):
"""
合并函数
:param data: 数据列表
:param low: 列表开头位置
:param mid: 分割中间位置
:param high: 列表最后位置
:return:
"""
i = low # 第一个指针
j = mid + 1 # 第二个指针
tmp = [] # 临时存放的列表
while i <= mid and j <= high: # 分割的列表当两边都有数才进行
if data[i] < data[j]:
tmp.append(data[i])
i += 1 # 低的指针往右移动
else:
tmp.append(data[j]) # 右边大,存右边的数
j += 1 # 同时指针右移动
while i <= mid: # 左边分割有剩下
tmp.append(data[i])
i += 1
while j <= high: # 右边有剩下
tmp.append(data[j])
j += 1
data[low:high + 1] = tmp # 最后将tmp中的数写入到原来的列表中
def merge_sort(data, low, high):
"""
归并排序
:param data: 待排序的数据列表
:param low: 数据列表开始位置
:param high: 数据列表结束位置
:return:
"""
if low < high: # 至少有两个元素才进行
mid = (low + high) // 2 # 分割
merge_sort(data, low, mid) # 递归分割上一部分
merge_sort(data, mid + 1, high) # 递归分割下一部分
merge(data, low, mid, high) # 合并
if __name__ == '__main__':
import random
data_list = [1, 3, 21, 6, 50, 33, 34, 58, 66]
random.shuffle(data_list) # 打乱列表数据
print("pre:", data_list)
merge_sort(data_list, 0, len(data_list) - 1)
print("after:", data_list)
#结果:
#pre: [21, 3, 33, 58, 34, 66, 1, 6, 50]
#after: [1, 3, 6, 21, 33, 34, 50, 58, 66]
希尔排序
效率:与增量有关,O(n1+£)其中<0£<1,如增量为2k-1 复杂度为O(n3/2)
原理:
先取一个小于n的整数d1作为第一个增量,把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。
先在各组内进行直接插入排序;
取第二个增量d2<d1重复上述的分组和排序,直至所取的增量 =1( < …<d2<d1),即所有记录放在同一组中进行直接插入排序为止。
def shell_sort(data):
"""
希尔排序
:param data:待排序的数据列表
:return:
"""
d1 = len(data) // 2 # 设置分割大小为d1,
while d1 > 0:
for i in range(d1, len(data)):
tmp = data[i] # 当前分割元素位置
j = i - d1 # 上一个分割元素位置
while j >= 0 and tmp < data[j]: # 上一个元素分割位置比当前分割位置要大,则需要调整位置
data[j + d1] = data[j] # 后移动当前分割元素位置
j -= d1 # 往前移d1
data[j + d1] = tmp
d1 //= 2 # 继续分割
if __name__ == '__main__':
import random
data_list = [1, 3, 21, 6, 50, 33, 34, 58, 66]
random.shuffle(data_list) # 打乱列表数据
print("pre:", data_list)
shell_sort(data_list)
print("after:", data_list)
#结果:
#pre: [3, 66, 58, 34, 33, 50, 6, 21, 1]
#after: [1, 3, 6, 21, 33, 34, 50, 58, 66]
python学习交流群【1121607128】在学的进群一起交流,资料自己群文件下载
学习资料: