用python实现各种排序算法(代码@@@)

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)