用python实现的经典排序算法
一，冒泡排序
1，把第一个元素与第二个元素比较，如果第一个比第二个大，则交换他们的位置。接着继续比较第二个与第三个元素，如果第二个比第三个大，则交换他们的位置….
2，对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样一趟比较交换下来之后，排在最右的元素就会是最大的数。
3，除去最右的元素，对剩余的元素做同样的工作，重复1，2，如此重复下去，直到排序完成。
def BubbleSort(arr):
for i in range(len(arr)-1,0,-1):
for j in range(0,i):
if arr[j]> arr[j+1]:
temp=arr[j]
arr[j]=arr[j+1]
arr[j+1]=temp
return arr
array=[3,6,3,8,9,1,10]
print(BubbleSort(array))
性质：时间复杂度：O(n2) ；空间复杂度：O(1) ；稳定排序 ；原地排序
二，选择排序
首先，找到数组中最小的那个元素，其次，将它和数组的第一个元素交换位置(如果第一个元素就是最小元素那么它就和自己交换)。其次，在剩下的元素中找到最小的元素，将它与数组的第二个元素交换位置。如此往复，直到将整个数组排序。
def SelectSort(arr):
for i in range(0,len(arr)):
for j in range(i+1,len(arr)):
if arr[i]>arr[j]:
temp=arr[i]
arr[i]=arr[j]
arr[j]=temp
return arr
array=[3,6,4,8,9,1,0]
t=SelectSort(array)
print(t)
性质：时间复杂度：O(n2) ；空间复杂度：O(1) ；非稳定排序 ；原地排序
三，插入排序
1、从数组第2个元素开始抽取元素。
2、把它与左边第一个元素比较，如果左边第一个元素比它大，则继续与左边第二个元素比较下去，直到遇到不比它大的元素，然后插到这个元素的右边。
3、继续选取第3，4，….n个元素,重复步骤 2 ，选择适当的位置插入。
def InsertSort(arr):
for i in range(1,len(arr)):
for j in range(i,0,-1):
if arr[j]性质：时间复杂度：O(n2) ；空间复杂度：O(1) ；稳定排序 ；原地排序
四，希尔排序
希尔排序的思想是采用插入排序的方法，先让数组中任意间隔为 h 的元素有序，刚开始 h 的大小可以是 h = n / 2,接着让 h = n / 4，让 h 一直缩小，当 h = 1 时，也就是此时数组中任意间隔为1的元素有序，此时的数组就是有序的了。
注意：对各个分组进行插入的时候并不是先对一个组排序完了再来对另一个组排序，而是轮流对每个组进行排序。
希尔排序可以说是插入排序的一种变种。无论是插入排序还是冒泡排序，如果数组的最大值刚好是在第一位，要将它挪到正确的位置就需要 n - 1 次移动。也就是说，原数组的一个元素如果距离它正确的位置很远的话，则需要与相邻元素交换很多次才能到达正确的位置，这样是相对比较花时间了。
希尔排序就是为了加快速度简单地改进了插入排序，交换不相邻的元素以对数组的局部进行排序。
def InsertSort(arr):
gap=len(arr)//2
while gap>0:
for i in range(gap, len(arr)):
for j in range(i, 0, -gap):
if j >= gap and arr[j] < arr[j - gap]:
temp = arr[j]
arr[j] = arr[j - gap]
arr[j - gap] = temp
gap//=2
return arr
a = list(input("input some numbers:"))
print (a)
print(InsertSort(a))
或者：
def ShellSort(ar):
n=len(ar)
g=n//2
while g>0:
ar=InsertSort(ar,g)
g//=2
return ar
#类似插入排序
def InsertSort(arr,gap):
for i in range(gap, len(arr)):
for j in range(i, 0, -gap):
if j >= gap and arr[j] < arr[j - gap]:
temp = arr[j]
arr[j] = arr[j - gap]
arr[j - gap] = temp
return arr
a = list(input("input some numbers:"))
print (a)
print(ShellSort(a))
性质：时间复杂度：O(nlogn) ；空间复杂度：O(1) ；非稳定排序 ；原地排序
五、归并排序
将一个大的无序数组有序，先把大的数组分成两个，然后对这两个数组分别进行排序，之后再把这两个数组合并成一个有序的数组。由于两个小的数组都是有序的，所以在合并的时候是很快的。
通过递归的方式将大的数组一直分割，直到数组的大小为 1，此时只有一个元素，那么该数组就是有序的了，之后再把两个数组大小为1的合并成一个大小为2的，再把两个大小为2的合并成4的 …… 直到全部小的数组合并起来。 即：先递归分解数组，再合并数组
def MergeSort(ar):
if len(ar)<=1:
return ar
num=len(ar)//2
left=MergeSort(ar[:num])
right=MergeSort(ar[num:])
return merge(left,right)
def merge(left,right):
result=[]
l, r=0, 0
while l性质：时间复杂度：O(nlogn) ；空间复杂度：O(n) ；稳定排序 ；非原地排序
六，快速排序
我们从数组中选择一个元素，我们把这个元素称之为中轴元素吧，然后把数组中所有小于中轴元素的元素放在其左边，所有大于或等于中轴元素的元素放在其右边，显然，此时中轴元素所处的位置的是有序的。也就是说，我们无需再移动中轴元素的位置。
从中轴元素那里开始把大的数组切割成两个小的数组(两个数组都不包含中轴元素)，接着我们通过递归的方式，让中轴元素左边的数组和右边的数组也重复同样的操作，直到数组的大小为1，此时每个元素都处于有序的位置。
def QuickSort(arr,s,e):
if s>=e:
return
flag=s
for i in range(flag+1,e+1):
if flagarr[i]:
temp=arr[i]
del arr[i]
arr.insert(flag,temp)
flag+=1
# QuickSort(arr[:flat-1],0,flat-1)
# QuickSort(arr[flat+1:], 0, flat+1)
QuickSort(arr, s, flag - 1) # 将基准的 前后部分分别递归排序
QuickSort(arr, flag + 1, e)
return arr
a = list(input("input some numbers:"))
print (a)
print(QuickSort(a,0,len(a)-1))
性质：时间复杂度：O(nlogn) ；空间复杂度：O(logn) ；非稳定排序 ；原地排序
术语解释：
1、稳定排序：如果 a 原本在 b 的前面，且 a == b，排序之后 a 仍然在 b 的前面，则为稳定排序。
2、非稳定排序：如果 a 原本在 b 的前面，且 a == b，排序之后 a 可能不在 b 的前面，则为非稳定排序。
3、原地排序：原地排序就是指在排序过程中不申请多余的存储空间，只利用原来存储待排数据的存储空间进行比较和交换的数据排序。
4、非原地排序：需要利用额外的数组来辅助排序。
5、时间复杂度：一个算法执行所消耗的时间。
6、空间复杂度：运行完一个算法所需的内存大小。
声明：菜鸟学习路上的总结，若有误请您指正，若侵权请您联系我，若转载请您附上链接。