排序算法

最新推荐文章于 2023-07-05 09:31:50 发布

一直走别回头_

最新推荐文章于 2023-07-05 09:31:50 发布

阅读量495

点赞数

分类专栏： algorithm

本文链接：https://blog.csdn.net/u012603073/article/details/45693731

版权

algorithm 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

今天接到新的任务是：周五要讲排序算法，十大排序算法我分到五个。

在我的记忆中，上一次接触排序算法还是在大二的时候。那个时候我才19岁（天呐真年轻！），当然这已经是四年前的事情了，岁月催人老啊。

言归正传。这里要讲的算法是：插入排序、归并排序、堆排序、基数排序和希尔排序。

一插入排序

《大话数据结构》里面将插入排序的时候，举的例子是打扑克的时候，摸牌之后自己理牌的时候，就会按大小顺序插好。恩，插入排序就是这样。用官方的话来说就是：

是每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位置，直到全部插入完毕。

再来举一个数学中的栗子。

说白了就是，后一个数和前一个数比大小，如果比前一个数大就不动，还放后面；如果比前一个数小，就放在前一个数的前面。比完了就再比后一个数，也是按照这样的方法。

还有一种语言叫做程序，用python实现是这样的：

# -*- coding: cp936 -*-
def InsertionSort(A):
    for j in range(1,len(A)):
        key = A[j]
        i = j-1
        #向前查找插入位置
        while i>=0 and A[i]>key:
            A[i+1] = A[i]
            i = i-1
        A[i+1] = key
 
#初始化输入数据
A = []
input = raw_input('please input some numbers:') #输入逗号分隔整数列 如：7，6，5，1，8，34
for item in input.split(','):
    A.append(int(item))
 
InsertionSort(A)#插入排序
print A

二归并排序算法

举个栗子。高考查分的时候，他不但会告诉你你考了多少分，也会告诉你在全省拍多少名。那么全省的排名是怎么出来的呢，一定是先学校排，然后一个市的几个学校的学生的成绩排名合并到一起，就出现了市排名，再把市排名合并就是省排名。这里的合并就是归并算法。即将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

再来数学例子：原本的数组是这样的 {16,7,13,10,9,15,3,2,5,8,12,1,11,4,6}

这里简单数一下具体是怎么排的，比如{7,16}和{10,13}合并的时候，先比较两个数组的第一个数，7和10 。显然7小，写前面。然后把7从原数组划掉，变成{16}和{10,13}，荏苒比较第一个数，16>10，把10拿出来，原数组划掉，变成{16}和{13}，再比，13胜，16写在最后。每一次比较就是这样的。

如果写成程序：

# -*- coding: cp936 -*-
def MergeSort(lists):
    if len(lists) <=1:
        return lists
    num = len(lists)/2
    left = MergeSort(lists[:num])
    right = MergeSort(lists[num:])
    return Merge(left,right)
def Merge(left,right):
    r,l=0,0
    reslut=[]
    while l<len(left) and r<len(right):
        if left[l] < right[r]:
            reslut.append(left[l])
            l+=1
        else:
            reslut.append(right[r])
            r+=1
    reslut+= right[r:]
    reslut+= left[l:]
    return reslut

A = []
input = raw_input('please input some numbers:') #输入逗号分隔整数列 如：7，6，5，1，8，34
for item in input.split(','):
    A.append(int(item))

print MergeSort(A)

三堆排序

叠罗汉见过吧，堆排序就是要把数据搞成一个塔状的。这个塔就是一个完全二叉树。这里就要从二叉树开始讲起了。

首先什么事完全二叉树。若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。

那么堆又是什么呢。堆就是有要求的完全二叉树，分为最大堆和最小堆。最大堆要求节点的元素都要大于其孩子，最小堆要求节点元素都小于其左右孩子，两者对左右孩子的大小关系不做任何要求。于是我们知道，最大堆的根节点就是最大的数。

有了最大就好办啊，我们每次把最大堆的根节点（就是堆顶的元素）放在队列最后面，然后把剩下的元素调整为最大堆，然后再把堆顶提溜出来就行了呗。

本质上讲，堆排序是一种选择排序。

举例。数组 {16,7,3,20,17,8}

画图是在太恼火了，于是我在纸上画了，过程见上图。

#!/usr/bin/envpython
#-*-coding:utf-8-*-
 

# 将index节点制作成堆
def Heapify(list, heapSize, index): #index is 0 based
    left = 2*index + 1
    right = left + 1
    large = index
    if right < heapSize and list[large]<list[right]:
        large=right
    if left < heapSize and list[large]<list[left]:
        large=left
    if large != index:
        list[large], list[index]=list[index], list[large]
        Heapify(list, heapSize, large)
 
# 创建一个最大堆（初始化堆）
def BuildMaxHeap(list):
    heapSize = len(list)
    for i in range(heapSize/2 - 1, -1, -1):
        Heapify(list, heapSize, i)
 
# 对排序实现
def HeapSort(list):
    BuildMaxHeap(list)
    for i in range(len(list)-1, -1, -1):
        list[0], list[i] = list[i], list[0] #move the largest value to the end
        Heapify(list, i, 0)
    return list
 
#在Python中已经实现了堆，所以可以直接使用现成的方法
import heapq
def HeapSort(list):
    heapq.heapify(list)
    heap = []
    while list:
        heap.append(heapq.heappop(list))
    list[:] = heap
    return list

A = []
input = raw_input('please input some numbers:') #输入逗号分隔整数列 如：7，6，5，1，8，34
for item in input.split(','):
    A.append(int(item))
 
HeapSort(A)#堆排序
print A

四基数排序

又叫桶子法（第一次看成了橘子法什么鬼）。就是找一个键值，将其作为标准把数据分配到相应的“桶”中，经过多次分配，达到排序的目的。比如数值就可以把数位当做键值。比如说先按个位排一遍，再按十位排一遍，就排好了。

举个栗子。

73,22,93,43,55,14,28,65,39,81

首先根据个位数的数值，将他们分配到0-9这10个桶中：

1 81

2 22

3 73 93 43

4 14

5 55

8 28

9 39

然后把他们按照现在的顺序重排：81,22,73,93,43,14,55,28,39

接下来，按照十位数的数值再排一遍：

1 14

2 22 28

3 39

4 43

5 55

6 65

7 73

8 81

9 93

再按照现在的顺序排出来：14,22,28,39,43,55,65,73,81,93

这个时候我们写个程序来排一下：

#!/usr/bin/env python
#encoding=utf-8
 
import math
 
def sort(a, radix=10):
    """a为整数列表， radix为基数"""
    K = int(math.ceil(math.log(max(a), radix))) # 用K位数可表示任意整数
    bucket = [[] for i in range(radix)] # 不能用 [[]]*radix
    for i in range(1, K+1): # K次循环
        for val in a:
            bucket[val%(radix**i)/(radix**(i-1))].append(val) # 析取整数第K位数字 （从低到高）
        del a[:]
        for each in bucket:
            a.extend(each) # 桶合并
        bucket = [[] for i in range(radix)]

#初始化输入数据
A = []
input = raw_input('please input some numbers:') #输入逗号分隔整数列 如：7，6，5，1，8，34
for item in input.split(','):
    A.append(int(item))
 
sort(A)#插入排序
print A

五希尔排序

看了一下理论的东西，没怎么看懂，那先来例子吧。

假设有这样一个数组{13,14,94,33,82,25,59,94,65,23,45,27,73,25,39,10}，选择步长为5

13 14 94 33 82
25 59 94 65 23
45 27 73 25 39
10

然后我们对每列进行排序：

10 14 73 25 23
13 27 94 33 39
25 59 94 65 82
45

将上述四行数字，依序接在一起时我们得到：[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ].这时10已经移至正确位置了，然后再以3为步长进行排序：

排序之后变为：

最后以1步长进行排序（此时就是简单的插入排序了）。

# -*- coding: cp936 -*-
def shell_sort(seq):
    incr = len(seq)/2
    while(incr>=1):
        for i in range(incr,len(seq)):
            tmp=seq[i]
            pos=i;
            for j in range(i-incr,-1,-incr):
                if seq[j]>tmp:
                    seq[j+incr]=seq[j]
                    pos=j
            seq[pos]=tmp
        incr = incr/2  
    return seq

#初始化输入数据
A = []
input = raw_input('please input some numbers:') #输入逗号分隔整数列 如：7，6，5，1，8，34
for item in input.split(','):
    A.append(int(item))

shell_sort(A)#插入排序
print A

希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。