如今不少的事件均可以用算法来处理，正在编程上，算法有着很首要的位置，将算法用函数封装起来，使顺序能更好的挪用，没有需求重复编写。
Python十年夜经典算法：
1、拔出排序
1.算法思维
从第二个元素开端以及后面的元素进行比拟，假如后面的元素比以后元素年夜，则将后面元素 后移，以后元素顺次往前，直到找到比它小或等于它的元素拔出正在厥后面，
而后抉择第三个元素，反复上述操作，进行拔出，顺次抉择到最初一个元素，拔出后即实现一切排序。
2.代码完成
def insertion_sort(arr):
#拔出排序
# 第一层for示意轮回拔出的遍数
for i in range(1, len(arr)):
# 设置以后需求拔出的元素
current = arr[i]
# 与以后元素比拟的比拟元素
pre_index = i - 1
while pre_index >= 0 and arr[pre_index] > current:
# 当比拟元素年夜于以后元素则把比拟元素后移
arr[pre_index + 1] = arr[pre_index]
# 往前抉择下一个比拟元素
pre_index -= 1
# 当比拟元素小于以后元素，则将以后元素拔出正在 厥后面
arr[pre_index + 1] = current
return arr2、抉择排序
1.算法思维
设第一个元素为比拟元素，顺次以及前面的元素比拟，比拟完一切元素找到最小的元素，将它以及第一个元素调换，反复上述操作，咱们找出第二小的元素以及第二个地位的元素调换，以此类推找出残余最小元素将它换到后面，即实现排序。
2.代码完成
def selection_sort(arr):
#抉择排序
# 第一层for示意轮回抉择的遍数
for i in range(len(arr) - 1):
# 将肇始元素设为最小元素
min_index = i
# 第二层for示意最小元素以及前面的元素一一比拟
for j in range(i + 1, len(arr)):
if arr[j] < arr[min_index]:
# 假如以后元素比最小元素小，则把以后元素角标志为最小元素角标
min_index = j
# 查找一遍后将最小元素与肇始元素调换
arr[min_index], arr[i] = arr[i], arr[min_index]
return arr3、冒泡排序
1.算法思维
从第一个以及第二个开端比拟，假如第一个比第二个年夜，则替换地位，而后比拟第二个以及第三个，逐步日后，通过第一轮后最年夜的元素曾经排正在最初，
以是反复上述操作的话第二年夜的则会排正在倒数第二的地位。，那反复上述操作n-1次便可实现排序，由于最初一次只有一个元素以是没有需求比拟。
2.代码完成
def bubble_sort(arr):
#冒泡排序
# 第一层for示意轮回的遍数
for i in range(len(arr) - 1):
# 第二层for示意详细比拟哪两个元素
for j in range(len(arr) - 1 - i):
if arr[j] > arr[j + 1]:
# 假如后面的年夜于前面的，则替换这两个元素的地位
arr[j], arr[j + 1] = arr[j + 1], arr[j]
return arr4、疾速排序
1.算法思维
找出基线前提，这类前提必需尽可能简略，一直将成绩合成（或许说减少规模），直到合乎基线前提。
2.代码完成
def quick_sort(arr):
if len(arr) < 2:
# 基线前提：为空或只蕴含一个元素的数组是“有序”的
return arr
else:
# 递归前提
pivot = arr[0]
# 由一切小于基准值的元素组成的子数组
less = [i for i in arr[1:] if i <= pivot]
# 由一切年夜于基准值的元素组成的子数组
greater = [i for i in array[1:] if i > pivot]
return quicksort(less) + [pivot] + quicksort(greater)
print(quick_sort([10, 5, 2, 3]))5、归并排序
1.算法思维
归并排序是分治法的典型使用。分治法（pide-and-Conquer）：将原成绩划分红 n 个规模较小而构造与原成绩类似的子成绩；递归地处理这些成绩，而后再兼并其后果，就失去原成绩的解，合成后的数列很像一个二叉树。
详细完成步骤：
应用递归将源数列应用二分法分红多个子列
请求空间将两个子列排序兼并而后前往
将一切子列一步一步兼并最初实现排序
- 注：先合成再归并
2.代码完成
def merge_sort(arr):
#归并排序
if len(arr) == 1:
return arr
# 应用二分法将数列分两个
mid = len(arr) // 2
left = arr[:mid]
right = arr[mid:]
# 应用递归运算
return marge(merge_sort(left), merge_sort(right))
def marge(left, right):
#排序兼并两个数列
result = []
# 两个数列都有值
while len(left) > 0 and len(right) > 0:
# 阁下两个数列第一个最小放后面
if left[0] <= right[0]:
result.append(left.pop(0))
else:
result.append(right.pop(0))
# 只有一个数列中另有值，间接增加
result += left
result += right
return result6、希尔排序
1.算法思维
希尔排序的全体思维是将固定距离的几个元素之间排序，而后再减少这个距离。这样到最初数列就成了根本有序数列。
详细步骤：
较量争论一个增量（距离）值
对元素进行增量元素进行比拟，比方增量值为7，那末就对0,7,14,21…个元素进行拔出排序
而后对1,8,15…进行排序，顺次递增长行排序
一切元素排序完后，减少增量比方为3，而后又反复上述第2，3步
最初减少增量至1时，数列曾经根本有序，最初一遍一般拔出便可
2.代码完成
def shell_sort(arr):
#希尔排序
# 取整较量争论增量（距离）值
gap = len(arr) // 2
while gap > 0:
# 从增量值开端遍历比拟
for i in range(gap, len(arr)):
j = i
current = arr[i]
# 元素与他同列的后面的每一个元素比拟，假如比后面的小则调换
while j - gap >= 0 and current < arr[j - gap]:
arr[j] = arr[j - gap]
j -= gap
arr[j] = current
# 减少增量（距离）值
gap //= 2
return arr7、基数排序
1.算法思维
基数排序（radix sort）属于“调配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，望文生义，它是透过键值的部份资讯，将要排序的元素调配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳固性的排序，其工夫复杂度为O (nlog(r)m)，此中r为所采取的基数，而m为堆数，正在某些时分，基数排序法的效率高于其它的稳固性排序法。
2.代码完成
2.1由桶排序革新，从最低位到最高位顺次桶排序，最初输入最初排好的列表。
def RadixSort(list,d):
for k in range(d):#d轮排序
# 每一一轮天生10个列表
s=[[] for i in range(10)]#由于每一一名数字都是0~9，故建设10个桶
for i in list:
# 按第k位放入到桶中
s[i//(10**k)%10].append(i)
# 按以后桶的程序重陈列表
list=[j for i in s for j in i]
return list2.2简略完成
from random import randint
def radix_sort():
A = [randint(1, 99999999) for _ in xrange(9999)]
for k in xrange(8):
S = [ [] for _ in xrange(10)]
for j in A:
S[j / (10 ** k) % 10].append(j)
A = [a for b in S for a in b]
for i in A:
print i8、计数排序
1.算法思维
对每个输出元素x，确定小于x的元素个数。行使这一信息，就能够间接把x 放正在它正在输入数组上的地位上了，运转工夫为O(n)，但其需求的空间纷歧定，空间糜费年夜。
2.代码完成
from numpy.random import randint
def Conuting_Sort(A):
k = max(A) # A的最年夜值，用于确定C的长度
C = [0]*(k+1) # 经过下表索引，暂时寄存A的数据
B = (len(A))*[0] # 寄存A排序实现后的数组
for i in range(0, len(A)):
C[A[i]] += 1 # 记载A有哪些数字，值为A[i]的共有几个
for i in range(1, k+1):
C[i] += C[i-1] # A中小于i的数字个数为C[i]
for i in range(len(A)-1, -1, -1):
B[C[A[i]]-1] = A[i] # C[A[i]]的值即为A[i]的值正在A中的秩序
C[A[i]] -= 1 # 每一拔出一个A[i]，则C[A[i]]减一
return B9、堆排序
1.算法思维
堆分为最年夜堆以及最小堆，是齐全二叉树。堆排序就是把堆顶的最年夜数掏出，将残余的堆持续调整为最年夜堆,详细进程正在第二块有引见，以递归完成 ，
残余局部调整为最年夜堆后,再次将堆顶的最年夜数掏出，再将残余局部调整为最年夜堆,这个进程继续到残余数只有一个时完结。
2.代码完成
import time,random
def sift_down(arr, node, end):
root = node
#print(root,2*root+1,end)
while True:
# 从root开端对最年夜堆调整
child = 2 * root +1 #left child
if child > end:
#print('break',)
break
print("v:",root,arr[root],child,arr[child])
print(arr)
# 找出两个child中交年夜的一个
if child + 1 <= end and arr[child] < arr[child + 1]: #假如右边小于左边
child += 1 #设置左边为年夜
if arr[root] < arr[child]:
# 最年夜堆小于较年夜的child, 替换程序
tmp = arr[root]
arr[root] = arr[child]
arr[child]= tmp
# 在调整的节点设置为root
#print("less1:", arr[root],arr[child],root,child)
root = child #
#[3, 4, 7, 8, 9, 11, 13, 15, 16, 21, 22, 29]
#print("less2:", arr[root],arr[child],root,child)
else:
# 无需调整的时分, 加入
break
#print(arr)
print('-------------')
def heap_sort(arr):
# 从最初一个有子节点的孩子仍是调整最年夜堆
first = len(arr) // 2 -1
for i in range(first, -1, -1):
sift_down(arr, i, len(arr) - 1)
#[29, 22, 16, 9, 15, 21, 3, 13, 8, 7, 4, 11]
print('--------end---',arr)
# 将最年夜的放到堆的最初一个, 堆-1, 持续调整排序
for end in range(len(arr) -1, 0, -1):
arr[0], arr[end] = arr[end], arr[0]
sift_down(arr, 0, end - 1)
#print(arr)10、桶排序
1.算法思维
为了节流空间以及工夫，咱们需求指定要排序的数据中最小和最年夜的数字的值，来不便桶排序算法的运算。
2.代码完成
#桶排序
def bucket_sort(the_list):
#设置全为0的数组
all_list = [0 for i in range(100)]
last_list = []
for v in the_list:
all_list[v] = 1 if all_list[v]==0 else all_list[v]+1
for i,t_v in enumerate(all_list):
if t_v != 0:
for j in range(t_v):
last_list.append(i)
return last_list总结：
正在编程中，算法都是雷同的，算法重正在算法思维，相称于将一道数学上的使用题的每一个前提，区间，可能呈现的后果进行合成，分步骤的完成它。算法就是将详细成绩的个性形象进去，将步骤用编程言语来完成。经过此次对排序算法的整顿，加深了对各算法的理解，详细的代码是无奈影象的，经过对算法思维的了解，依据伪代码来完成详细算法的编程，才是真正理解算法。
保举学习：Python视频教程
以上就是python排序算法有哪些？的具体内容，更多请存眷资源魔其它相干文章！
标签： Python 排序算法 python教程 python编程 python使用问题
相关文章
抱歉，评论功能暂时关闭!