排序算法python版本

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/jiaoyangwm/article/details/81807774

1、冒泡排序

# coding:utf-8


# 冒泡排序
# 1. 外层循环负责帮忙递减内存循环的次数【len-1, 1】
# 2. 内层循环负责前后两两比较, index 的取值范围【0, len-2】 len-1-i 次，求最大值放到最后
def bubble_sort(nums):
    # [1, len-1]
    for i in range(1, len(nums)-1):
        # [0, len-1-i]
        for j in range(len(nums)-i):  # ｊ为列表下标
            if nums[j] > nums[j+1]:
                nums[j], nums[j+1] = nums[j+1], nums[j]
    return nums


if __name__ == "__main__":
    nums = [2, 6, 8, 5, 1, 4, 9, 3, 7]
    bubble_sort(nums)
    print('result:', nums)

2、插入排序

# coding:utf8
"""
插入排序和冒泡排序的区别在于：

插入排序的前提是：左边是有序的数列
而冒泡排序：相邻的值进行交换，一共进行n次交换
"""
from __future__ import print_function


def insert_sort(l):
    # 循环  除第一个数字组成的有序数组 以外的数字
    for i in range(1, len(l)):
        # 每一个数字，依次和有序数组进行比较
        print(l[:i])
        for j in range(len(l[:i])):
            if l[i] < l[j]:
                l[i], l[j] = l[j], l[i]


if __name__ == "__main__":
    l = [5, 1, 9, 3, 2, 7]
    print(l)
    insert_sort(l)
    print("result: " + str(l))

3、归并排序

# coding: utf-8


def MergeSort(nums):
    if len(nums) <= 1:
        return nums
    num = int(len(nums)/2)
    # 从中间，进行数据的拆分, 递归的返回数据进行迭代排序
    left = MergeSort(nums[:num])
    right = MergeSort(nums[num:])
    print("left: ", left)
    print("right: ", right)
    print("-" * 20)
    return Merge(left, right)


def Merge(left, right):
    l, r = 0, 0
    result = []
    while l < len(left) and r < len(right):
        if left[l] < right[r]:
            result.append(left[l])
            l += 1
        else:
            result.append(right[r])
            r += 1
    result += left[l:]
    result += right[r:]
    return result


if __name__ == "__main__":
    nums = [2, 6, 8, 5, 1, 4, 9, 3, 7]
    nums = MergeSort(nums)
    print('result:', nums)

4、快速排序

#!/usr/bin/python
# coding:utf8


def quick_sort(nums, start, end):
    i = start
    j = end
    # 结束排序
    if i >= j:
        return
    # 保存首个数值
    key = nums[i]
    # 一次排序，i和j的值不断的靠拢，然后最终停止，结束一次排序
    while i < j:
        # 和最右边的比较，如果>=key,然后j-1，慢慢的和前一个值比较;如果值<key，那么就交换位置
        while i < j and key <= nums[j]:
            print(key, nums[j], '*' * 30)
            j -= 1
        nums[i] = nums[j]
        # 交换位置后，然后在和最左边的值开始比较，如果<=key,然后i+1，慢慢的和后一个值比较;如果值>key，那么就交换位置
        while i < j and key >= nums[i]:
            print(key, nums[i], '*' * 30)
            i += 1
        nums[j] = nums[i]
    nums[i] = key
    # 左边排序
    quick_sort(nums, start, i-1)
    # 右边排序
    quick_sort(nums, i+1, end)


if __name__ == "__main__":
    nums = [2, 6, 8, 5, 1, 4, 9, 3, 7]
    quick_sort(nums, 0, len(nums) - 1)
    print('result:', nums)

5、基数排序

#************************基数排序****************************
#确定排序的次数
#排序的顺序跟序列中最大数的位数相关
def radix_sort_nums(L):
    maxNum = L[0]
#寻找序列中的最大数
    for x in L:
        if maxNum < x:
            maxNum = x
#确定序列中的最大元素的位数
    times = 0
    while (maxNum > 0):
        maxNum = int((maxNum/10))
        times += 1
    return times
#找到num从低到高第pos位的数据
def get_num_pos(num, pos):
    return (int((num/(10**(pos-1))))) % 10
#基数排序
def radix_sort(L):
    count = 10 * [None]       #存放各个桶的数据统计个数
    bucket = len(L) * [None]  #暂时存放排序结果
#从低位到高位依次执行循环
    for pos in range(1, radix_sort_nums(L)+1):
        #置空各个桶的数据统计
        for x in range(0, 10):
            count[x] = 0
        #统计当前该位(个位，十位，百位....)的元素数目
        for x in range(0, len(L)):
            #统计各个桶将要装进去的元素个数
            j = get_num_pos(int(L[x]), pos)
            count[j] += 1
        #count[i]表示第i个桶的右边界索引
        for x in range(1,10):
            count[x] += count[x-1]
        #将数据依次装入桶中
        for x in range(len(L)-1, -1, -1):
            #求出元素第K位的数字
            j = get_num_pos(L[x], pos)
            #放入对应的桶中，count[j]-1是第j个桶的右边界索引
            bucket[count[j]-1] = L[x]
            #对应桶的装入数据索引-1
            count[j] -= 1
        # 将已分配好的桶中数据再倒出来，此时已是对应当前位数有序的表
        for x in range(0, len(L)):
            L[x] = bucket[x]

6、选择排序

# coding:utf8
"""
选择排序和冒泡排序的区别在于：

选择排序的前提是：找到最大值的位置，最后才进行1次交换
而冒泡排序：相邻的值进行交换，一共进行n次交换
"""
from __future__ import print_function


def selection_sort(l):
    length = len(l) - 1

    while length:
        index = length
        # 第一个数字，和后面每一个数字进行对比，找出最大值，放到最后！！
        for j in range(length):
            if l[j] > l[index]:
                index = j
        l[length], l[index] = l[index], l[length]
        print(len(l) - length, l)
        length -= 1


if __name__ == "__main__":
    l = [5, 1, 9, 3, 2, 7]
    print(l)
    selection_sort(l)
    print("result: " + str(l))

7、希尔排序

# coding: utf8

from __future__ import print_function
def insert_sort(l, start, increment):
    for i in range(start+increment, len(l), increment):
        for j in range(start, len(l[:i]), increment):
            if l[i] < l[j]:
                l[i], l[j] = l[j], l[i]
    print(increment, '--',l)
    return l

def shell_sort(l, increment):
    # 依次进行分层
    while increment:
        # 每一层，都进行n次插入排序
        for i in range(0, increment):
            insert_sort(l, i, increment)
        increment -= 1
    return l

if __name__ == "__main__":
    l = [5, 2, 9, 8, 1, 10, 3, 4, 7]
    increment = len(l)/3+1 if len(l)%3 else len(l)/3
    print("开始", l)
    l = shell_sort(l, increment)
    print("结束", l)