排序算法python实现

快速排序
选择数组中的任意一个元素pivot，该元素作为基准，将小于基准的元素移到左边，大于基准的元素移到右边（分区操作），数组被pivot分为两部分，继续对剩下的两部分做同样的处理，直到所有子集元素不再需要进行上述步骤。

class Solution(object):
    def sortArray(self, nums):
        n = len(nums)
        def quick(low, high):
            if low >= high:  # 说明已经排好
                return nums;
            i = low
            j = high
            pivot = low
            while (i < j):
                while (i < j and nums[j] > nums[pivot]):
                    j -= 1
                while (i < j and nums[i] <= nums[pivot]):
                    i += 1
                nums[i], nums[j] = nums[j], nums[i]
            nums[pivot], nums[j] = nums[j], nums[pivot]

            quick(low, i - 1)
            quick(i + 1, high)
            return nums

        return quick(0, n - 1)
if __name__ == '__main__':
    nums = [3, 4, 2, 7, 1]
    my_sort = Solution()
    my_sort.sortArray(nums)
    print(nums)

堆排序
利用大根堆的根节点是最大的元素的原理，每次将根节点取出后再继续构造大根堆，直到所有元素排完。
步骤：
1 build heap；
2 交换根节点与最后一个叶子节点顺序，最大元素放到了最后；
3 通过heapy调整大根堆。

class Solution():
    def heapify(self, nums, n, start_pos):
        if start_pos >= n:
            return nums
        i = start_pos
        if 2 * i + 1 < n and nums[2 * i + 1] > nums[i]:
            start_pos = 2 * start_pos + 1
        if 2 * i + 2 < n and nums[start_pos] < nums[2 * i + 2]:
            start_pos = 2 * i + 2
        if i != start_pos:
            nums[i], nums[start_pos] = nums[start_pos], nums[i]
            self.heapify(nums, n, start_pos)

    def heap_sort(self, nums, n):
        for i in range((n - 2) // 2, -1, -1):  # build heap
            self.heapify(nums, n, i)
        for i in range(n - 1, -1, -1):
            nums[0], nums[i] = nums[i], nums[0]
            self.heapify(nums, i, 0)


if __name__ == '__main__':
    nums = [5, 1, 1, 2, 0, 0]
    n = len(nums)
    my_sort = Solution()
    my_sort.heapify()
    my_sort.heap_sort(nums, n)
    print(nums)