Python实现常用查找与排序算法

 

查找算法

二分查找

import doctest

def binary_search(alist, item):
    """
    >>> alist=[1,3,4,7,11,18,29]
    >>> binary_search(alist,1)
    0
    >>> binary_search(alist,7)
    3
    >>> binary_search(alist,18)
    5
    >>> binary_search(alist,31)

    """

    binary_index = int(len(alist)/2)
    if alist == []:
        return None
    elif alist[binary_index] > item:
        return binary_search(alist[:binary_index], item)
    elif alist[binary_index] < item:
        result = binary_search(alist[binary_index + 1:], item)
        return  None if result is None else result + binary_index + 1
    elif alist[binary_index] == item:
        return binary_index

if __name__ == "__main__":
    doctest.testmod(verbose=True)

排序算法 

选择排序

原理：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。

稳定性：不稳定

最差时间复杂度：O(n^2）

平均时间复杂度：O(n^2）

import doctest
def select_sort(alist, reverse=False):
    """
    >>> alist = [1,7,4,8,6,9,2,5,3]
    >>> select_sort(alist)
    [1, 2, 3, 4, 5, 6, 7, 8, 9]

    >>> select_sort(alist, reverse=True)
    [9, 8, 7, 6, 5, 4, 3, 2, 1]

    """
    alist = alist[:]
    def select_sort_(alist, reverse):
        if alist == []:
            return []

        item = max(alist) if reverse else min(alist)
        alist.remove(item)
        return [item] + select_sort_(alist,reverse)
    return select_sort_(alist, reverse)

if __name__ == "__main__":
    doctest.testmod(verbose=True)

冒泡排序 

原理：依次比较相邻两个元素大小，交换两元素位置使之满足递增或递减关系，完成一次从序列头到序列尾部的过程称为一次冒泡，一次冒泡会产生最大或最小值于队列尾部，下一次冒泡序列长度减1，序列尾部的有序序列长度加1

稳定性：稳定

最差时间复杂度：O(n^2）

平均时间复杂度：O(n^2）

import doctest

def bubbing_sort(alist, reverse=False):
    """
    >>> alist = [1,7,4,8,6,9,2,5,3]
    >>> select_sort(alist)
    [1, 2, 3, 4, 5, 6, 7, 8, 9]

    >>> select_sort(alist, reverse=True)
    [9, 8, 7, 6, 5, 4, 3, 2, 1]

    """

    def swap(alist, index1, index2):
        temp = alist[index1]
        alist[index1] = alist[index2]
        alist[index2] = temp
        pass

    alist = alist[:]
    for cnt in range(len(alist) - 1):
        for index1 in range(len(alist) - 1 - cnt):
            index2 = index1 + 1
            if (alist[index1] > alist[index2] and reverse == False) or (alist[index1] < alist[index2] and reverse == True):
                swap(alist, index1, index2)

    return alist

if __name__ == "__main__":
    doctest.testmod(verbose=True)

插入排序

原理：将序列元素依次插入到序列首部的有序序列中，即每个元素执行一次有序插入操作

稳定性：稳定

最差时间复杂度：O(n2）

平均时间复杂度：O(n2）

import doctest

def insert_sort(alist, reverse=False):
    """
    >>> alist = [1,7,4,8,6,9,2,5,3]
    >>> insert_sort(alist)
    [1, 2, 3, 4, 5, 6, 7, 8, 9]

    >>> insert_sort(alist, reverse=True)
    [9, 8, 7, 6, 5, 4, 3, 2, 1]

    """
    result = alist[:1]
    for val in alist[1:]:
        for sort_val in result:
            if (val < sort_val and reverse == False) or (val > sort_val and reverse == True):
                result.insert(result.index(sort_val), val)
                break
        else:
            result.insert(len(result), val)
    return result

if __name__ == "__main__":
    doctest.testmod(verbose=True)

快速排序 

原理：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

性质：不稳定

最差时间复杂度：O(n2）

平均时间复杂度：O(nlogn）

import doctest
import copy
import random

def quick_sort(alist, reverse=False):
    """
    >>> alist = [1,7,4,8,6,9,2,5,3]
    >>> quick_sort(alist)
    [1, 2, 3, 4, 5, 6, 7, 8, 9]

    >>> quick_sort(alist, reverse=True)
    [9, 8, 7, 6, 5, 4, 3, 2, 1]

    """
    alist = copy.copy(alist)
    def quick_sort_(alist, reverse):
        if alist == []:
            return []

        dichotomy_index = random.randint(0, len(alist) - 1)
        dichotomy_val = alist[dichotomy_index]
        alist.pop(dichotomy_index)
        left_list = []
        right_list = []
        for val in alist:
            if (val >= dichotomy_val and reverse == True) or (val < dichotomy_val and reverse == False):
                left_list += [val]
            else:
                right_list += [val]

        return quick_sort_(left_list, reverse) + [dichotomy_val] + quick_sort_(right_list, reverse)
    return quick_sort_(alist, reverse)

if __name__ == "__main__":
    doctest.testmod(verbose=True)

归并排序 

原理：将序列通过递归二分拆分到不可分，不可分的序列可以认为是有序序列，然后将两个有序序列合并为一个有序序列，直到整个序列变为一个有序序列

稳定性：稳定

最差时间复杂度：O(nlogn）

平均时间复杂度：O(nlogn）

import doctest

def merger_sort(alist, reverse=False):
    """
    >>> alist = [1,7,4,8,6,9,2,5,3]
    >>> merger_sort(alist)
    [1, 2, 3, 4, 5, 6, 7, 8, 9]

    >>> merger_sort(alist, reverse=True)
    [9, 8, 7, 6, 5, 4, 3, 2, 1]

    """
    
    def merger(a, b):
        result = []
        for n in range(len(a) + len(b)):
            if a == []:
                return result + b
            elif b == []:
                return result + a
            elif (a[0] < b[0] and reverse == False) or (a[0] > b[0] and reverse == True):
                result += [a.pop(0)]
            else:
                result += [b.pop(0)]
        return result

    def merger_sort_(alist):        
        contre_index = int(len(alist)/2)
        left_list = alist[:contre_index]
        right_list = alist[contre_index:]
        if len(left_list) >= 2:
            left_list = merger_sort_(left_list)
        if len(right_list) >= 2:
            right_list = merger_sort_(right_list)
        return merger(left_list,right_list)

    return merger_sort_(alist)

if __name__ == "__main__":
    doctest.testmod(verbose=True)

堆排序

原理：堆排序也是选择排序的一种，他是利用完全二叉树的结构，从而构造出最大堆或最小堆，将堆顶元素替换到堆尾，如此反复，从而构造出有序序列

稳定性：不稳定

最差时间复杂度：O(nlogn）

平均时间复杂度：O(nlogn）

import doctest

def heap_sort(alist, reverse=False):
    """
    >>> alist = [1,7,4,8,6,9,2,5,3]
    >>> heap_sort(alist)
    [1, 2, 3, 4, 5, 6, 7, 8, 9]

    >>> heap_sort(alist, reverse=True)
    [9, 8, 7, 6, 5, 4, 3, 2, 1]

    """
    
    A = alist[:]
    def perc_down(A, i, N):
        Ai = A[i]
        def perc_down_(A, i, N):
            temp = A[i]
            child = i * 2 + 1

            if child  < N - 1 and ((A[child] < A[child + 1]  and reverse == False) or (A[child] >= A[child + 1] and reverse == True)):
                child += 1
            if child < N and ((Ai < A[child] and reverse == False) or (Ai >= A[child] and reverse == True)):
                A[i] = perc_down_(A, child, N)
            else:
                A[i] = Ai
            
            return temp
        perc_down_(A, i, N)

    def swap(A, a, b):
        temp = A[a]
        A[a] = A[b]
        A[b] = temp

    for n in list(range(int(len(A)/2)))[::-1]:
        perc_down(A, n, len(A))

    for n in list(range(len(A)))[::-1]:
        swap(A, 0, n)
        perc_down(A, 0, n)


    return A

if __name__ == "__main__":
    doctest.testmod(verbose=True)