python版本的各种排序算法,其中除了归并排序有点问题之外,其他的都经过测试的!!!
#coding=utf8
import os
import sys
import numpy as np
# 显示
def show(list):
if len(list) == 0 :
print("list中没有元素")
return 0
print(list)
# 交换数据
def swap(list,i,j):
if len(list) == 0:
print("list中没有元素")
return 0
temp = list[i]
list[i] = list[j]
list[j] = temp
# 选则排序---> 核心：选择最小的数据
def select_sort(list):
if len(list) == 0:
print("列表的内容为空")
index = 0
while index < len(list):
min = index
select = index + 1
while select < len(list):
if list[min] > list[select]:
min = select
select += 1
swap(list,index,min)
index += 1
return list
# 冒泡排序 ---> 核心：两两比较，小的向上冒，或者两两比较，大的向下沉
def bubble(list):
if len(list) == 0:
print("列表的内容为空")
index = 0
while index < len(list):
select = len(list) - 1
while select > index:
if list[select] < list[select - 1]:
swap(list,select,select-1)
select -= 1
index += 1
return list
# 插入排序 ---> 核心： 选择插入点，把数据取出来，和前面比较插入到合适的位置
def insert(list):
if len(list) == 0:
print("列表的内容为空")
# 选择插入点数据
index = 1
while index < len(list):
insert = list[index]
# 从index位置开始向前搜索，选择合适的插入位置
select = index - 1
while select >= 0:
if list[select] > insert:
# swap(list,select,select+1)
list[select + 1] = list[select]
select -= 1
else:
break
# 插入到合适的位置，在 list[select] < insert的时候执行，也就是select刚好插入到 select+1 的位置
list[select+1] = insert
index += 1
return list
# 以上三种排序算法，选择排序、冒泡排序、插入排序都是复杂度比较高的排序算法---O(n^2)
# 快速排序和归并排序的复杂度---O(nlogn)
# 快速排序，一种递归的思想，核心思想-->找基准点，分块-->分成子列表（不断的重复着基准点，分块，直到子列表的长度为1就说明这个列表已经排好序了）
# 基准和划分的使用，保证每一次划分--对于基准点的右边都会比基准点大，对于基准点左边都会比基准点小
"""
快排的一些重要性能： （1）快排是一种不稳定的排序算法
（2）快排的时间复杂度：最好的情况-->O(nlogn)
最坏的情况-->O(n^2)
(3)快排的空间复杂度：快排是一个递归的排序算法，每一次递归都需要一个固定大小的栈空间，对于列表的每一次分割都会有两次递归
调用，所以快排的空间复杂度：最好的情况-->O(log2(n))
最坏的情况-->O(n)
(4)对于基准的选取也会对算法产生性能上的改变，以下我将以第一个元素为基准来实现一个递归快排
"""
# 对于交换和显示部分的代码上面已经给出
# 快排实现1
# 进行1次划分，此时 left=right ，此时left就是基准的位置 --> 基准点左边的数据都比基准点小，基准点右边的数据都比基准点大
def onceQuickSort(list,left,right):
temp = list[left]
while left < right:
while (left < right) and (temp <= list[right]):
right -= 1
swap(list,left,right)
while (left < right) and (temp >= list[left]):
left += 1
swap(list,left,right)
list[left] = temp
# 此时left和right应该是重合的
return left
# 对子序列进行递归操作，直到子列表的元素是1就表示列表已经排好序了
def Qsort(list,left,right):
if left < right :
# povit已经是排好位置的，所以在前在后操作
povit = onceQuickSort(list,left,right)
Qsort(list,left,povit-1)
Qsort(list,povit+1,right)
#总的函数，调用快排,list是可变类型
def QuickSort(list):
Qsort(list,0,len(list)-1)
return list
# 快排比较好理解
# 现在介绍另一种排序---> 归并排序 也叫合并排序算法 利用递归、分而治之
"""
归并排序的性能：（1）时间复杂度： O(nlog(n))
(2)空间复杂度： 合并排序有两个空间需求（1）支持递归调用的调用栈需要O(log(n))
(2)复制缓存需要O(n)
"""
def merge(list,copylist,low,middle,high):
i = low
j = middle + 1
k = low
while (i <= middle) and (j <= high):
if list[i] <= list[j]:
copylist[k] = list[i]
k += 1
i += 1
else:
copylist[k] = list[j]
k += 1
j += 1
# 保证左右序列的长度在不相等的情况下的排序问题
while i <= middle:
copylist[k] = list[i]
i += 1
k += 1
while j <= high:
copylist[k] = list[j]
j += 1
k += 1
# 划分列表
def MergeSortClip(list,copylist,left,right):
if left < right:
middle = (left+right)//2
MergeSortClip(list,copylist,left,middle)
MergeSortClip(list,copylist,middle+1,right)
# 算法部分
merge(list,copylist,left,middle,right)
# 用户调用函数
def MergeSortDisplay(list):
copyBuffer = [None] * len(list)
print(copyBuffer)
print(type(copyBuffer))
MergeSortClip(list,copyBuffer,0,len(list)-1)
if __name__ == '__main__':
a = [12,3,41,34,6,78,2354,12,34,1,56,0,35]
list_num = select_sort(a)
show(list_num)
b = [12, 3, 41, 34, 6, 78, 2354, 12, 34, 1, 56, 0, 35]
list_bu = bubble(b)
show(list_bu)
c = [12, 3, 41, 34, 6, 78, 2354, 12, 34, 1, 56, 0, 35]
list_in = insert(c)
show(list_in)
d = [12, 3, 41, 34, 6, 78, 2354, 12, 34, 1, 56, 0, 35]
list_q = QuickSort(d)
show(list_q)
e = [12,3,41,34,6,78,2354,12,34,1,56,0,35]
list_qk = QuickSort(e)
show(list_qk)
# 均好使用
# 归并排序
f = [12,34,2,1,45,567,213,12,34,345,45,56]
list_reg = MergeSortDisplay(f)
print(list_reg)
# show(list_reg)
