Python中八种基本排序方法_buchiyexiao

Python 基本排序方法

---

1. 选择排序方法

    def select_sort(L):
        for i in range(0,len(L)):
            minl = L[i]
            for j in range(i+1,len(L)):
                if L[j] < minl:
                    temp = L[j]
                    L[j] = minl
                    minl = temp
        L[i] = minl
1
2
3
4
5
6
7
8
9

选择排序不过多解释，只是通过遍历把每次最小的放到当前的数组头

2. 插入排序方法

 def insert_sort(L):
    for x in range(1,len(L)):
        for i in range(x-1,-1,-1):
            if L[i] > L[i+1]:
                temp = L[i+1]
                L[i+1] = L[i]
                L[i] = temp
1
2
3
4
5
6
7

插入排序也就是让后面的依次插入到自己该去的位置，即可以类比为扑克牌发牌，每次拿一张牌然后放在它该放的位置

3. 冒泡排序方法

 def pop_sort(L):
    length = len(L)
    for i in range(1,length):
        for j in range(0,length - i):
            if L[j] > L[j+1]:
                temp = L[j]
                L[j] = L[j+1]
                L[j+1] = temp
1
2
3
4
5
6
7
8

bubble，冒泡冒泡冒泡泡，原理就是冒泡泡

4. 快速排序方法

def quick_sort(L,start,end):
    if start < end:
        left = start
        right = end
        temp = L[start]
        while left < right:
            while left < right and L[right] >= temp:
                right = right - 1 
            if(left < right):
                L[left] = L[right]
                left = left + 1
            while left < right and L[left] <= temp:
                left = left + 1
            if(left < right):
                L[left] = L[right]
                right = right - 1
        L[left] = temp
        quick_sort(L,start,left-1)
        quick_sort(L,left+1,end)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

快排，好用，原理移动，但是不稳定，它会把部分排序好的排在后面，会对排序稳定性有很大影响，同时大量的数据可能会超过其所满足的迭代深度，造成无法执行程序的后果

5. 希尔排序方法

 def insert_shell(L):
    gap = (int)(len(L)/2)
    while(gap>=1):
        for i in range (gap,len(L)):
            for j in range(i-gap,-1,-gap):
                if L[j] > L[j+gap]:
                    temp = L[j+gap]
                    L[j+gap] = L[j]
                    L[j] = temp
        gap = (int)(gap/2)
1
2
3
4
5
6
7
8
9
10

希尔排序自己其实也只是一知半解，大概理解为一个分组进行插入，用步长gap将待排序元素分成若干个子序列，然后对各组内进行插入排序，逐渐减小步长，gap=1时，该数组便是有序的

6. 归并排序方法

 def mergearray(L,first,mid,last,temp):
    i = first
    j = mid + 1
    k = 0
    m = mid
    n = last
    while (i <= m) and (j <= n):
        if L[i] <= L[j]:
            temp[k] = L[i]
            k = k + 1
            i = i + 1
        else:
            temp[k] = L[j]
            k = k + 1
            j = j + 1
    while i <= m:
        temp[k] = L[i]
        k = k + 1
        i = i + 1
    while j <= n:
        temp[k] = L[j]
        k = k + 1
        j = j + 1
    for i in range(0,k):
        L[first + i] = temp[i]
def mergesort(L,first,last,temp):
    if first < last:
        mid = (int)((first + last)/2)
        mergesort(L,first,mid,temp)
        mergesort(L,mid+1,last,temp)
        mergearray(a,first,mid,last,temp)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

归并不仅好用，稳定还方便理解，简单理解为通过mergesort做到左有序，右有序，然后把左右再整合有序

7. 堆排序方法

 def adjust(L,len,i):  #调整堆
    left = (int)(2*i+1)
    right = left + 1
    max = i
    #找大儿子
    if (left < len) and L[left]>L[max]:
        max = left
    if (right < len) and L[right]>L[max]:
        max = right
    if max!=i:
        temp = L[max]
        L[max] = L[i]
        L[i] = temp
        adjust(L,len,max)
def heapsort(L,size):
    for i in range(int(size/2)-1,-1,-1):  #对每一个非叶节点进行堆调整,从最后一个非叶节点开始
        adjust(L,size,i)
    for i in range(size-1,0,-1):
        temp = L[0]
        L[0]=L[i]
        L[i]=temp  #将当前最大的放置到数组的末尾
        adjust(L,i,0)  #将未完成排序的部分继续进行堆排序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

如上代码所构建的为大顶堆，即根节点大于叶节点，简单说就是父亲大于儿子，然后通过交换父亲与末尾节点，取出了本次循环的父亲，然后在对剩下的进行调整，形成大顶堆，直到只有一个元素的时候，循环结束，完成排序

8. 基数排序

#寻找最大数字的位数
def max_nums(L):
    maxnum = L[0]
    for i in L:
        if maxnum < i:
            maxnum = i
    flag = 0 #统计位数
    while (maxnum > 0):
        maxnum = (int)(maxnum/10)
        flag = flag + 1
    return flag
#获取num从低位到高位的第pos个位的数据
def get_num(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,max_nums(L)+1): #从个位开始循环
        for i in range(0,10):
            count[i] = 0
        for i in range(0,len(L)): #统计当前位数的元素数目
            j = get_num(int(L[i]),pos)
            count[j] = count[j]+1
        for i in range(1,10):
            count[i] = count[i] + count[i-1]
        for i in range(len(L)-1,-1,-1):
            j = get_num(L[i],pos)
            bucket[count[j] - 1] = L[i]
            count[j] = count[j] - 1
        for i in range(0,len(L)):
            L[i] = bucket[i]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

基数排序简单理解可以理解成，我首先只看个位，对个位进行排序，然后再看十位，对十位进行排序，以此类推，直到看完最大数的位数即可，下面是一个简单的程序样例类型。
L = [ 52 , 95 , 9 , 101 , 960 ]

我们可以获得L的最高位数为3，然后对个位进行排序得到：

L = [ 960 , 101 , 52 , 95 , 9 ]
1

然后我们对十位进行排序可以得到：

L = [ 9 , 101 , 52 , 960 , 95 ]
1

然后我们对百位进行排序可以得到：

L = [ 9 , 52 , 95 , 101 , 960 ]
1

排序结束

自己第一次写博客，可能排版还有文稿都比较菜，希望大家多多体谅，以后在闲暇时间通过博客记录自己的学习之路
上面的很多代码都是自己在之前的C++模板上稍加修改的，本质还是要学各种排序方法的原理和相关知识