排序算法总结(Python实现)——(二)

上一篇总结了冒泡、选择、插入和希尔排序，这篇来总结归并排序、快速排序和堆排序。

归并排序

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

算法描述

• 把长度为n的输入序列分成两个长度为n/2的子序列；
• 对这两个子序列分别采用归并排序；
• 将两个排序好的子序列合并成一个最终的排序序列。

#归并排序(2-路分治)
    def MergeSort(self, arr):
        if len(arr) < 2:
            return arr
        mid = len(arr) // 2
        left = arr[:mid]
        right = arr[mid:]
        return self.merge(self.MergeSort(left), self.MergeSort(right))

    def merge(self, left, right):
        result = []
        length = len(left) + len(right)
        i = 0
        j = 0
        for index in range(0, length):
            if i >= len(left):
                result.append(right[j])
                j += 1
            elif j >= len(right):
                result.append(left[i])
                i += 1
            elif left[i] > right[j]:
                result.append(right[j])
                j += 1
            else:
                result.append(left[i])
                i += 1
        return result

算法分析

最佳情况：T(n) = O(n)  最差情况：T(n) = O(nlogn)  平均情况：T(n) = O(nlogn)。不过时间复杂度是以空间复杂度为代价的，从代码中我们可以看到要新申请一个大小和原列表相同的列表。

快速排序

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

算法描述

• 首先选择出来一个值作为分界值，可以任取，代码中取第一个元素作为分界值
• 定义两个指针start和end，分别指向列表的开头和结尾
• 从末位指针开始向前遍历，如果遇到值小于分界值，就把这个值赋给首指针指向的地址空间。
• 然后再从前到后遍历首指针，碰到大于分界值的值，把这个赋给尾指针指向的地址空间。

#快速排序
    def QuickSort(self, arr, start, end):
        if start >= end:
            return
        i = start
        j = end
        baseline = arr[start]
        while i < j:
            while i < j and arr[j] >= baseline:
                j -= 1
            arr[i] = arr[j]
            while i < j and arr[i] < baseline:
                i += 1
            arr[j] = arr[i]
        arr[i] = baseline
        self.QuickSort(arr, start, i-1)
        self.QuickSort(arr, i+1, end)
        return arr

算法分析

最佳情况：T(n) = O(nlogn)   最差情况：T(n) = O(n2)   平均情况：T(n) = O(nlogn)。对比归并排序，虽然时间复杂度一样，但是并不需要申请额外的空间。

堆排序

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

算法描述

对于完全二叉树的描述最好有动图，看到一篇文章讲的不错快速排序，这里就不赘述。

#堆排序
    def HeapSort(self, arr):
        self.heap_len = len(arr)
        if self.heap_len < 1:
            return arr
        #构建一个最大堆
        self.buildMaxHeap(arr)
        #循环将首位(最大值)与末位交换，然后重新调整最大堆
        while self.heap_len > 0:
            self.swap(arr, 0, self.heap_len - 1)
            self.heap_len -= 1
            self.adjust(arr, 0)
        return arr

    #建立最大堆
    def buildMaxHeap(self, arr):
        #利用完全二叉树的性质，从最后一个非叶子结点开始向上构造最大堆
        for i in range(self.heap_len // 2, -1, -1):
            self.adjust(arr, i)
    #调整使之成为最大堆
    def adjust(self, arr, i):
        maxIndex = i
        #如果有左子树，而且左子树大于父节点，将最大指针指向左子树
        if 2 * i < self.heap_len and arr[2 * i] > arr[maxIndex]:
            maxIndex = 2 * i
        # 如果有右子树，而且右子树大于父节点，将最大指针指向右子树
        if 2 * i + 1 < self.heap_len and arr[2 * i + 1] > arr[maxIndex]:
            maxIndex = 2 * i + 1
        #如果父节点不是最大值，则将父节点与最大值交换，并且递归调整与父节点交换的位置
        if maxIndex != i:
            self.swap(arr, maxIndex, i)
            self.adjust(arr, maxIndex)

    def swap(self, arr, i, j):
        temp = arr[j]
        arr[j] = arr[i]
        arr[i] = temp

代码中的self.heap_len是全局变量，这里没复制出来整个类的代码，所以自己定义吧。所有完整代码可以参考末尾github，所有7个排序算法封装成了一个大类。

算法分析

最佳情况：T(n) = O(nlogn) 最差情况：T(n) = O(nlogn) 平均情况：T(n) = O(nlogn)

完整代码：传送门