几种经典的排序算法，你都能写出来吗？

排序算法是面试中经常遇到的问题，对排序算法的掌握从一定程度可以反映面试者的代码能力。这里介绍几种常用的排序算法。

冒泡排序

冒泡排序是一种极其简单的排序算法，也是我所学的第一个排序算法。它重复地走访过要排序的元素，依次比较相邻两个元素，如果他们的顺序错误就把他们调换过来，直到没有元素再需要交换，排序完成。这个算法的名字由来是因为越小(或越大)的元素会经由交换慢慢“浮”到数列的顶端。

1. 比较相邻的元素，如果前一个比后一个大，就把它们两个调换位置。

2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

3. 针对所有的元素重复以上的步骤，除了最后一个。

4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

冒泡排序代码

# 冒泡排序
def bubbleSort(arr):
    for i in range(len(arr) - 1):
        for j in range(i+1, len(arr)):
            if arr[i] > arr[j]:
                arr[i],arr[j] = arr[j],arr[i]
if __name__ == '__main__':
    data = [2,56,7,10,69,5,23,34,12,24,4]
    bubbleSort(data)
    print(data)
# 结果
[2, 4, 5, 7, 10, 12, 23, 24, 34, 56, 69]

选择排序

选择排序也是一种简单直观的排序算法。它的工作原理很容易理解：初始时在序列中找到最小（大）元素，放到序列的起始位置作为已排序序列；然后，再从剩余未排序元素中继续寻找最小（大）元素，放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

注意选择排序与冒泡排序的区别：冒泡排序通过依次交换相邻两个顺序不合法的元素位置，从而将当前最小（大）元素放到合适的位置；而选择排序每遍历一次都记住了当前最小（大）元素的位置，最后仅需一次交换操作即可将其放到合适的位置。

选择排序代码

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

# 选择排序
def selectSort(arr):
    for i in range(len(arr) - 1):
        # 使用变量存储最小元素的index
        minIndex = i
        for j in range(i+1, len(arr)):
            if arr[minIndex] > arr[j]:
                minIndex = j
        arr[i],arr[minIndex] = arr[minIndex],arr[i]

if __name__ == '__main__':
    data = [2,56,7,10,69,5,23,34,12,24,4]
    selectSort(data)
    print(data)
# 结果
[2, 4, 5, 7, 10, 12, 23, 24, 34, 56, 69]

插入排序

插入排序是一种简单直观的排序算法。它的工作原理非常类似于我们抓扑克牌，每次把右边的没有理顺的扑克牌一张张插入到左侧理顺的位置，最终全部有序。

具体算法描述如下：

1. 从第一个元素开始，该元素可以认为已经被排序

2. 取出下一个元素，在已经排序的元素序列中从后向前扫描

3. 如果该元素（已排序）大于新元素，将该元素移到下一位置

4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置

5. 将新元素插入到该位置后

6. 重复步骤2~5

插入排序代码

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

# 插入排序
def insertSort(arr):
    for i in range(1,len(arr)):
        temp = arr[i]
        j = i - 1
        while j >= 0 and temp < arr[j]:
            arr[j + 1] = arr[j]
            j = j - 1
        arr[j + 1] = temp

if __name__ == '__main__':
    data = [2,56,7,10,69,5,23,34,12,24,4]
    insertSort(data)
    print(data)
# 结果
[2, 4, 5, 7, 10, 12, 23, 24, 34, 56, 69]

快速排序

快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序n个元素要O(nlogn)次比较。在最坏状况下则需要O(n^2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他O(nlogn)算法更快，因为它的内部循环可以在大部分的架构上很有效率地被实现出来。

快速排序使用分治策略(Divide and Conquer)来把一个序列分为两个子序列。步骤为：

1. 从序列中挑出一个元素，作为"基准"(pivot).

2. 把所有比基准值小的元素放在基准前面，所有比基准值大的元素放在基准的后面（相同的数可以到任一边），这个称为分区(partition)操作。

3. 对每个分区递归地进行步骤1~2，递归的结束条件是序列的大小是0或1，这时整体已经被排好序了。

快速排序代码

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

# 快速排序
def quickSort(arr, begin, end):
    if begin < end:
        key = arr[begin]
        i = begin
        j = end
        while i < j:
            while i < j and arr[j] > key:
                j = j - 1
            if i < j:
                arr[i] = arr[j]
                i = i + 1
            while i < j and arr[i] < key:
                i = i + 1
            if i < j:
                arr[j] = arr[i]
                j = j - 1
        arr[i] = key
        quickSort(arr, begin, i - 1)
        quickSort(arr, i + 1, end)

if __name__ == '__main__':
    data = [2,56,7,10,69,5,23,34,12,24,4]
    quickSort(data, 0, len(data) - 1)
    print(data)
# 结果
[2, 4, 5, 7, 10, 12, 23, 24, 34, 56, 69]

代码已上传到Github:

https://github.com/ddxygq/PyCode/blob/master/Python%E5%9F%BA%E7%A1%80%E8%AF%AD%E6%B3%95/%E7%AE%97%E6%B3%95/SortAlgo.py

猜你可能喜欢