python3 实现经典的排序与搜索算法

1).插入算法，最优时间复杂度：O(n), 最坏时间复杂度：O(n^2).
   算法原理：从无序数列中选一个元素插入到有序的子序列中去，得到一个有序的、元素加一的子序列，直到整个无序数列的元素为0，则整个序列全部有序。

2).选择排序：在无序数列中找到最小元素，存放在数列的起始位置，然后从剩余未排序元素中继续寻找最小元素，放到已排序序列的末尾。以此类推，直到所有元素排序完毕。

3).快速排序算法：最优时间复杂度：O(nlogn), 最坏时间复杂度：O(N^2)

4).冒泡排序：重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。

5).希尔排序：希尔排序(Shell’s Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。希尔排序属于插入类排序,是将整个有序序列分割成若干小的子序列分别进行插入排序。
   排序过程：先取一个正整数d1<n，把所有序号相隔d1的数组元素放一组，组内进行直接插入排序；然后取d2<d1，重复上述分组和排序操作；直至di=1，即所有记录放进一个组中排序为止。

6).二分查找算法：二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。
   查找过程：首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
   python3算法实现：

### 排序/搜索算法 ###

##  插入排序算法实现  ##
def insert_sort(eg_list):
    # 从第2个元素开始向前插入 #
    for i in range(1, len(eg_list)):
        # 从第i个元素开始向前比较，小于前一个元素，交换位置 #
        for j in range(i, 0, -1):
            if eg_list[j] < eg_list[j-1]:
                eg_list[j], eg_list[j-1] = eg_list[j-1], eg_list[j]


##  选择排序算法  ##
def select_sort(eg_list):
    for j in range(len(eg_list)-1):
        min_index = j
        for i in range(j+1, len(eg_list)):
            if eg_list[min_index] > eg_list[i]:
                min_index = i
        eg_list[j], eg_list[min_index] = eg_list[min_index], eg_list[j]


## 递归排序算法 ##
def merge_sort(eg_list):
    if len(eg_list)  <= 1:
        return eg_list
    mid = len(eg_list)//2
    left = merge_sort(eg_list[:mid])
    right = merge_sort(eg_list[mid:])
    result = []
    l, r = 0, 0
    while l < len(left) and r < len(right):
        if left[l] < right[r]:
            result.append(left[l])
            l += 1
        else:
            result.append(right[r])
            r += 1
    result += left[l:]
    result += right[r:]
    return result


##  冒泡排序算法  ##
def bubble_sort(data):
    for i in range(len(data) - 1, 0, -1):
        for j in range(0, i):
            if data[j] > data[j + 1]:
                data[j], data[j + 1] = data[j + 1], data[j]


##  快速排序算法  ##
def quick_sort(data, low = 0, high = None):
    if high == None:
        high = len(data) - 1
    if low < high:
        s, i, j = data[low], low, high
        while i < j:
            while i < j and data[j] >= s:
                j = j - 1
            if i < j:
                data[i] = data[j]
                i = i + 1
            while i < j and data[i] <= s:
                i = i + 1
            if i < j:
                data[j] = data[i]
                j = j - 1
        data[i] = s
        quick_sort(data, low, i - 1)
        quick_sort(data, i + 1, high)


##  二分查找算法  ##
def binary_search(eg_list, item):
    n = len(eg_list)
    if n > 0:
        mid = n//2
        if eg_list[mid] == item:
            return True
        elif item < eg_list[mid]:
            return binary_search(eg_list[:mid], item)
        else:
            return binary_search(eg_list[mid+1:], item)
    return False




eg_list = [2, 4, 6, 8, 9, 23, 51, 77, 88, 99]
print(binary_search(eg_list, 10))