排序算法总结(简单选择排序、堆排序)(python实现)

其实本文叫排序算法总结有点过了，只是用python实现了一遍。本文都是参照一篇csdn博客《数据结构排序算法》，里面详细介绍每种排序算法的原理，并给出了C++的实现，再次膜拜。

其中堆排序参考了《堆排序原理及算法实现（最大堆）》，虽然它是转载的，但写确实很不错，而且让人清楚明白。

# -*- coding: gb2312 -*-

# 交换两个数
def swap(a, b):
    return b, a

# 简单选择排序
    # 每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
    # 首先第0元素为一个有序数列， 从其余元素[1:n-1]中找一个最小的与第0元素交换
    # 依次从剩余无序元素找最小元素放到有序元素最后
    def simpleSelectSort(self, btype=True):
        l = self.list[:]
        if not self.list:
            return l
        n = len(l)

        for i in range(0, n):
            print_flag = False
            idx = i
            for j in range(i+1, n):
                if btype: #升序
                    if l[j] < l[idx]:
                        idx = j
                        print_flag = True
                else: # 降序
                    if l[j] > l[idx]:
                        idx = j
                        print_flag = True
            if idx != i:
                l[i], l[idx] = swap(l[i], l[idx])

            if print_flag: print '一趟选择排序后: ', l
        print l

    # 堆调整
    def heapAdjust(self, l, i, n, btype):
        lchild = 2*i
        rchild = 2*i + 1
        max = i
        if (i<=n/2):
            if btype:
                if lchild < n and l[lchild] > l[max]:
                    max = lchild
                if rchild < n and l[rchild] > l[max]:
                    max = rchild                
            else:
                if lchild < n and l[lchild] < l[max]:
                    max = lchild
                if rchild < n and l[rchild] < l[max]:
                    max = rchild                
            if max != i:
                    l[i], l[max] = swap(l[i], l[max])
                    self.heapAdjust(l, max, n, btype)

    # 建立堆
    def buildHeap(self, l, btype):
        n = len(l)
        for i in range(n/2, -1, -1):
            self.heapAdjust(l, i, n, btype)

    # 堆排序
    # 完全二叉树
    # 完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。
    # 一棵二叉树至多只有最下面的一层上的结点的度数可以小于2，并且最下层上的结点都集中在该层最左边的若干位置上，则此二叉树成为完全二叉树。
    # 大顶堆、小顶堆
    # 堆实际上是一棵完全二叉树，其任何一非叶节点满足性质：
    # Key[i]<=key[2i+1]&&Key[i]<=key[2i+2]或者Key[i]>=Key[2i+1]&&key>=key[2i+2]
    # 即任何一非叶节点的关键字不大于或者不小于其左右孩子节点的关键字。
    # 堆分为大顶堆和小顶堆，满足Key[i]>=Key[2i+1]&&key>=key[2i+2]称为大顶堆，满足 Key[i]<=key[2i+1]&&Key[i]<=key[2i+2]称为小顶堆。
    # 由上述性质可知大顶堆的堆顶的关键字肯定是所有关键字中最大的，小顶堆的堆顶的关键字是所有关键字中最小的。
    def heapSort(self, btype=True):
        l = self.list[:]
        n = len(l)
        self.buildHeap(l, btype)
        for i in range(n-1, 0, -1):
            l[0], l[i] = swap(l[0], l[i])
            self.heapAdjust(l, 0, i, btype)
        print l

结果：