python选择排序算法图解_排序算法详解与python实现

Note:

写后感：

理解算法思想很重要！

理解算法思想很重要！

理解算法思想很重要！

之后尝试自己独立码代码对算法的理解更深刻！

本文章所有算法默认从小到大排序。

1. 冒泡排序(Bubble Sort)

自然语言描述

按照列表中待排序的先后顺序，依次比较相邻的两个数，若两者是升序则不做任何操作，否则交换两者位置。

核心算法举例

以第一趟为例

1 5 7 3 9 2 6 8 1 与 5比较，不变

1 5 7 3 9 2 6 8 5 与 7比较，不变

1 5 3 7 9 2 6 8 7 与 3比较，交换位置

1 5 3 7 9 2 6 8 7 与 9比较，不变

1 5 3 7 2 9 6 8 9 与 2比较， 交换位置

1 5 3 7 2 6 9 8 9 与 6比较，交换位置

1 5 3 7 2 6 8 9 9 与 8比较，交换位置

所以第一趟结束后，排序结果为

1 5 3 7 2 6 8 9 9为最大数，后续不需要比较

算法优劣分析

一共比较((N-1)+(N-2)+...+2+1)次

最好情况下交换0次

最坏情况下交换((N-1)+(N-2)+...+2+1)次

平均时间复杂度O(n²)

算法实现

#-*-coding=UTF-8-*-

class BubbleSort:

def __init__(self,list_=[]):

self.list_ = list_

def get_current_list(self):

return self.list_

def ascent_sort(self):

for i in range(0,len(self.list_)-1):

for j in range(0, len(self.list_)-i-1):

if self.list_[j]>self.list_[j+1]:

temp = self.list_[j]

self.list_[j] = self.list_[j+1]

self.list_[j+1] = temp

#实例化

list1 = BubbleSort([1,8,4,9,2])

print list1.get_current_list()

list1.ascent_sort()

print list1.get_current_list()

2. 选择排序算法(Selection Sort)

自然语言描述

遍历列表所有元素，最小（大）的元素放在最左（右）边。

确定第一个元素位置后，遍历剩下的所有元素，最小（大）的元素放在最左（右）边。

以此类推，直到倒数第二个元素。

核心算法举例

第二趟比较为例(以找最小数为例)

此时min_index = 1

1 7 5 9 4

7 与 5 作比较，min_index更新为2

5 与 9 作比较，min_index不变

5 与 4 作比较，min_index更新为4

将index = 4与index=1的元素交换位置

1 4 5 9 7

算法优劣分析

一共比较((N-1)+(N-2)+...+2+1)次，交换N次。

平均时间复杂度O(n²)

算法实现

#-*-coding = utf-8-*-

class SelectionSort:

def __init__(self,list_=[]):

self.list_ = list_

def get_current_list(self):

return self.list_

def ascent_sort(self):

for i in range(0,len(self.list_)-1):

min_index, swap_temp = i, i

for j in range(i, len(self.list_)-1):

if self.list_[min_index] > self.list_[j+1]:

min_index = j + 1

swap_temp = self.list_[min_index]

self.list_[min_index] = self.list_[i]

self.list_[i] = swap_temp

return self.list_

#实例化

list1 = SelectionSort([1,7,4,9,2])

print list1.get_current_list()

list1.ascent_sort()

print list1.get_current_list()

3. 直接插入算法(Insertion Sort)

自然语言描述

在前面已经排好序的列表中插入新元素。步骤：

将第二元素与第一个元素比较，如果小于第一个元素则交换位置，反之不变。

将第三个元素分别与前两个元素比较(这里的算法用的是与之前一个的位置比较)，插入合适位置。

以此类推，直到最后一个元素。

核心算法举例

第二趟比较为例

此时 current_value = 1

5 7 1

current_value = 1 与7作比较

5 7 7

current_value = 1 与5作比较

5 5 7

将 current_value = 1 插入

1 5 7

算法优劣分析

最坏的情况下，一共比较并交换（1+2+...+(N-1)）次

最好的情况下，只需比较(N-1)次，无需交换

平均时间复杂度O(n²)

稳定

插入排序适用于数量较小，部分或者全部排序过的列表。尽管插入排序的时间复杂度也是O(n²)，但一般情况下，插入排序会比冒泡排序快一倍，要比选择排序还要快一点。并且，直接插入排序在对几乎已经排好序的数据操作时，效率高，可以达到线性排序的效率。

算法实现

#-*-coding = UTF-8-*-

class InsertionSort:

def __init__(self,list_=[]):

self.list_ = list_

def get_current_list(self):

return self.list_

def ascent_sort(self):

for i in range(1,len(self.list_)):

position = i

current_value = self.list_[i]

while position>0 and self.list_[position-1]>current_value:

self.list_[position] = self.list_[position-1]

position = position - 1

self.list_[position] = current_value

return self.list_

#实例化

list1 = InsertionSort([1,9,3,7])

print list1.get_current_list()

list1.ascent_sort()

print list1.get_current_list()

4. 希尔排序(Shell Sort)

自然语言描述

直接插入算法一趟只能为数据移动一位，比较低效。希尔排序作为直接插入算法的优化，又称缩小增量排序、递减增量排序。

以步长分区，对跳过步长的数进行直接插入算法排序，直至步长为1。

步长是希尔排序的精髓，已知的最好步长序列是由Sedgewick提出的 1，5，19，41，109，...

核心算法举例

原列表：[4,6,8,2,9,3,7,5,1]

步长增量：9/2=4, 4/2=2, 2/2=1 (Note: 取列表长度的一半作为最初步长，这里的步长使用的是Donald Shell的建议)

第一趟(步长为4)：

原列表 4 6 8 2 9 3 7 5 1，分组后为：

4 6 8 2

9 3 7 5

1

排序后为：

1 3 7 2

4 6 8 5

9

即排序后列表顺序为：

1 3 7 2 4 6 8 5 9

第二趟(步长为2)

待排序列表1 3 7 2 4 6 8 5 9，分组后为：

1 3

7 2

4 6

8 5

9

排序后为：

1 2

4 3

7 5

8 6

9

即排序后列表顺序为：

1 2 4 3 7 5 8 6 9

第三趟(步长为1), 即直接插入排序

待排序列表1 2 4 3 7 5 8 6 9

排序后列表顺序为：1 2 3 4 5 6 7 8 9

算法优劣分析

希尔排序比插入排序要快，甚至在小数组中比快速排序和堆排序还快，但是在涉及大量数据时希尔排序还是比快速排序慢。

不稳定

平均时间复杂度O(nlog2n)「n倍的log以2为底n」

算法实现

巧记：将直接插入算法的步长从1改为gap，加入限制条件gap > 0即可

#-*-coding = utf-8 -*-

class ShellSort():

def __init__(self, list_=[]):

self.list_ = list_

def get_current_list(self):

return self.list_

def ascent_sort(self):

gap = len(self.list_)/2

while gap > 0:

for i in range(gap, len(self.list_)):

current_value = self.list_[i]

position = i

while position >0 and self.list_[position - gap] > current_value:

self.list_[position] = self.list_[position - gap]

position = position - gap

self.list_[position] = current_value

gap = gap/2

return self.list_

list1 = ShellSort([1,9,3,2,5,8])

print list1.get_current_list()

list1.ascent_sort()

print list1.get_current_list()

5. 归并排序(Merge Sort)

自然语言描述

将两个有序表合并成一个有序表。归并排序算法依赖于归并操作。

from Wikipedia

两个有序表，left = [0,3,5,7], right = [1,4]，

合成的有序列表result = []

left[0] < right[0] ----> result = [0]

left[1] > right[0] ----> result = [0,1]

left[1] < right[1] ----> result = [0,1,3]

left[2] > right[1] ----> result = [0,1,3,4]

此时right[]为空，将left[]剩余的元素依次放入result列表中：result = [0,1,3,4,5,7]

两种核心算法

递归法

设计递归，将复杂的问题分解为最小规模子问题。

将列表分解为 两个更小的列表。

递归分解，将更小的列表继续分解，直到达到最小规模，也就是只有一个元素的时候。

对已经排序好的列表 进行合并。单个元素的列表，认为是已经排序好的。

from Wikipedia

递归python实现

#-*-coding=utf-8-*-

#递归算法

def mergeSort(seq=[]):

if len(seq) == 1:

return seq

else:

mid = len(seq)/2

left = []

right = []

left = mergeSort(seq[:mid])

right = mergeSort(seq[mid:])

return merge(left,right)

#将排好序的

def merge(left=[],right=[]):

#i, j are index for left and right seperately

i, j = 0,0

result = []

while i < len(left) and j < len(right):

if left[i] <= right[j]:

result.append(left[i])

i = i + 1

else:

result.append(right[j])

j = j + 1

#将剩余的部分依次加入result

result = result + left[i:]

result = result + right[j:]

return result

#实例化

list1 = [2,6,8,1,3,9,4]

print list1

print mergeSort(list1)

#time consume

import random,time

start_time = time.time()

seq = random.sample(range(10000), 10000) #random.sample(取值范围, 获取的个数)

result = mergeSort(seq)

print 'Time consume:{}'.format(time.time()-start_time)

非递归法（迭代法）

从最小的子问题开始解决，直到复杂的问题。要搞清每次排序归并的对象。

非递归算法（迭代法）

第一次：我们将数组分为 8个子数组 每个数组 1 个元素，对相邻的两个数组进行排序合并。

第二次：我们将数组分为 4个子数组 每个数组 2 个元素，对相邻的两个数组进行排序合并。

第三次：我们将数组分为 2个子数组 每个数组 4 个元素，对相邻的两个数组进行排序合并。

至此：排序完毕。

分析

第一步：每一次子数组的元素个数

k = 1 #子数组的个数

while k

k = k*2

第二步：确定要合并的两个相邻数组的区间[low:mid)[mid:height)

low = low(之前的low) +2k

mid = low(现在的low)+k

height = low(现在的low) + 2k

并且，

height不能越界（不能超过数组长度）；

mid不能大于height（mid大于height说明此时子数组个数不足k，那么这个时候该子数组不给予拆分直接pass，下图给予说明）

来自http://www.jianshu.com/p/3f27384387c1

非递归python实现

#-:-coding=utf-8-*-

class MergeSort:

def __init__(self,seq=[]):

self.seq = seq

def get_current_seq(self):

return self.seq

def ascent_sort(self):

k = 1 #子数组元素的个数

while k < len(self.seq):

low = 0

while low < len(self.seq):

height = min(low + 2*k, len(self.seq))

mid = low + k

if mid < height:

'''mergeSort'''

left = self.seq[low:mid]

right = self.seq[mid:height]

result =[]

i,j = 0,0

while i < len(left) and j < len(right):

if left[i] < right[j]:

result.append(left[i])

i += 1

else:

result.append(right[j])

j += 1

result = result + left[i:]

result = result + right[j:]

'''将原始数组的[low,height)替代为已经排好序的数组'''

self.seq[low:height] = result

low = low + 2*i

k *= 2

return self.seq

list1 = MergeSort([3,5,2,1])

print list1.get_current_seq()

list1.ascent_sort()

print list1.get_current_seq()

6. 堆排序(HeapSort)

堆排序是对简单选择排序的一种优化。

堆的定义及性质见这里。

堆的主要性质：

若根的index为1，则最后一个非叶子节点的index为len(seq)/2。此时对于index为i的节点，其左节点的index为2i；右节点的index为2i+1。

若根的index为0，最后一个非叶子节点的index为len(seq)/2-1。此时对于index为i的节点；其左节点的index为2i+1，右节点的index为2i+2。

堆排序需要解决两个主要的问题：

P1：如何将无序的列表构建成最小堆

P1：如何从无序数组构建最小堆

P2：将最小堆的顶部取出后如何重建最小堆

P2：如何重构最小堆

堆排序过程演示：

from Wikipedia

堆排序的三个步骤：

构建堆

调整堆

堆排序

堆排序python实现

#-*-coding=utf-8-*-

def build_max_heap(seq):

"""建立一个堆"""

#根据完全二叉树的性质，根的index为0，非叶子节点的index为1至len(seq)/2-1，

#

for i in range(len(seq)/2-1, -1, -1):

max_heap(seq, len(seq), i)

def max_heap(seq, heap_size, index):

"""调整列表中的元素以保证以index为根的堆是一个最大堆--->从而最终得到从小到大的排列顺序"""

# 将当前结点与其左右子节点比较，将较大的结点与当前结点交换，然后递归地调整子树

left_child = 2 * index + 1

right_child = left_child + 1

if left_child < heap_size and seq[left_child] > seq[index]:

largest = left_child

else:

largest = index

if right_child < heap_size and seq[right_child] > seq[largest]:

largest = right_child

if largest != index:

seq[index], seq[largest] = seq[largest], seq[index] #python特有，不需temp

max_heap(seq, heap_size, largest)

def heap_sort(to_sort_list):

"""堆排序"""

# 先将列表调整为堆

build_max_heap(to_sort_list)

heap_size = len(to_sort_list)

# 调整后列表(此时为堆）的第一个元素就是这个列表中最大的元素，将其与最后一个元素交换，然后将剩余的列表再调整为最大堆

for i in range(len(to_sort_list) - 1, 0, -1):

to_sort_list[i], to_sort_list[0] = to_sort_list[0], to_sort_list[i]

heap_size -= 1

max_heap(to_sort_list, heap_size, 0)

to_sort_list = [4, 1, 3, 2, 16, 9, 10, 14, 8, 7]

heap_sort(to_sort_list)

print to_sort_list

算法优劣分析

平均时间复杂度O(nlogn)

空间复杂度O(1)

7. 快速排序(QuikSort)

自然语言描述

对冒泡排序的有效改进。快速排序是一种不稳定的排序算法，即多个相同的值的相对位置也许会在算法结束时产生变动。

假设要排序的列表a[0],a[1]...a[n-1]，首先任意选取一个数据（通常选用a[0]）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。整个排序过程可以递推进行，从而使整个列表变得有序。

更具体一些：

设置两个变量i、j，排序开始的时候：i=0，j=n-1；

以第一个数组元素作为关键数据，赋值给key，即key = a[0]；

从j开始向前搜索 (顺序不能调转，因为你的比较对象是a[0])，即由后开始向前搜索，找到第一个小于key的值list[j]，将list[j]赋值给list[i], 并令i++；

从i开始向后搜索，即由前开始向后搜索，找到第一个大于key的list[i]，将list[i]赋值给list[j]，并令j--；

重复第3、4步，直到i = j（下面有图解说明这一结束条件）。

Note:

3,4步中，没找到符合条件时，改变j、i的值，使得j = j-1，i = i+1，直至找到为止。

找到符合条件的值，进行交换的时候i， j指针位置不变，只交换所指的值。

i == j这一过程一定正好是i++或j--完成的时候，此时令循环结束。

不多说了，上图！

一趟比较的图解：

字太丑凑活看

快速排序python实现

#-*-coding=UTF-8-*-

def quick_sort(a,left,right):

if len(a) <= 1 or right < 0 or left >= len(a) or right <= left:

return a

key = a[left]

i, j = left, right

while i < j:

while a[j] > key and i < j:

j -= 1

if a[j] < key and i < j:

a[i] = a[j]

i += 1

while a[i] < key and i < j:

i += 1

if a[i] > key and i < j:

a[j] = a[i]

j -= 1

a[i] = key

quick_sort(a, left, i-1)

quick_sort(a, i+1, right)

return a

list1 = [67,23,89,35,28,90,10,24]

left = 0

right = len(list1)-1

print(quick_sort(list1, left, right))

总结比较

七大算法的比较

补充：

基于桶排序的思想

计数排序

class CountingSort:

def countingSort(self, A, n):

# Assume that there are only 1000 numbers

buckets = [0] * 1001

for num in A:

buckets[num] += 1

sorted_arr = []

for i in range(0, 1001):

if buckets[i] != 0:

sorted_arr += [i] * buckets[i]

return sorted_arr

基数排序

class RadixSort:

def radixSort(self, A, n):

# write code here

bucket = [[] for l in range(10)]

for i in range(4):

for number in A:

value = (number//10**i)%10

bucket[value].append(number)

temp = []

for j in range(len(bucket)):

while bucket[j]:

temp.append(bucket[j].pop(0))

A = temp

return A