排序算法总结(归并排序、快速排序)(python实现)

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

# -*- coding: gb2312 -*-

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

# 合并两个有序数列
    # 这两个数列都是已排好序的
    # 申请一个大小为两个数列长度之和的数组
    # 两个指针分别指向这两个数列开头
    # 比较两个数列，小的或大的放到临时数组中，指针移到， 直到其中一个数列遍历完
    # 将剩余数列的其余元素入到临时数组,并将临时数组的元素拷贝加原数列
    def __merge__(self, l, begin, middle, end, btype):
        i = begin
        j = middle + 1
        k = begin
        tmp = []

        while i<=middle and j<=end :
            if btype:
                if l[i] <= l[j]:
                    tmp.append(l[i])
                    i += 1
                else:
                    tmp.append(l[j])
                    j += 1
            else:
                if l[i] >= l[j]:
                    tmp.append(l[i])
                    i += 1
                else:
                    tmp.append(l[j])
                    j += 1

        while i <= middle:
            tmp.append(l[i])
            i += 1

        while j <= end:
            tmp.append(l[j])
            j += 1

        for k in range(begin, end+1):            
            l[k] = tmp[k-begin]      



    def __mergeSort__(self, l, begin, end, btype):
        if begin < end:
            middle = (begin+end)/2 
            self.__mergeSort__(l, begin, middle, btype)
            self.__mergeSort__(l, middle+1, end, btype)
            self.__merge__(l, begin, middle, end, btype)
            print '一趟选择排序后(%d: %d): %s' %(begin, end, l[begin:end+1])

    # 归并排序
    # 归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。
    # 归并操作的工作原理如下：第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列第二步：设定两个指针，最初位置分别
    # 为两个已经排序序列的起始位置第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，
    # 并移动指针到下一位置重复步骤3直到某一指针达到序列尾将另一序列剩下的所有元素直接复制到合并序列尾。
    # 例如：
    # 如 设有数列{6，202，100，301，38，8，1} 
    # 初始状态：[6] [202] [100] [301] [38] [8] [1]      比较次数 
    # i=1   [6 202 ] [ 100 301] [ 8 38] [ 1 ]3
    # i=2[ 6 100 202 301 ] [ 1 8 38 ]4 
    # i=3 [ 1 6 8 38 100 202 301 ]4
    def mergeSort(self, btype=True):
        l = self.list[:]
        print
        n = len(l)
        self.__mergeSort__(l, 0, n-1, btype)
        print l


    def __partition__(self, l, low, high, btype):

        key = l[low]
        while(low < high):

            while(low < high):
                if btype:
                    if l[high] < key:
                        break
                else:
                    if l[high] > key:
                        break
                high -= 1

            if low < high:
                l[low], l[high] = swap(l[low], l[high])
                low += 1

            while(low < high):
                if btype:
                    if l[low] > key:
                        break
                else:
                    if l[low] < key:
                        break
                low += 1

            if low < high:
                l[low], l[high] = swap(l[low], l[high])
                high -= 1

        return low


    def __quickSort__(self, l, low, high, btype):
        if (low < high):
            pivotpos = self.__partition__(l, low, high, btype)            
            self.__quickSort__(l, low, pivotpos-1, btype)
            self.__quickSort__(l, pivotpos+1, high, btype)
            print '一趟快速排序后(%d: %d : %d): %s' %(low, pivotpos, high, l[low:high+1])


    # 快速排序
    def quickSort(self, btype=True):
        l = self.list[:]
        n = len(l)
        self.__quickSort__(l, 0, n-1, btype);
        print l

结果：