算法：二分算法、冒泡排序、选择排序、插入排序、快排、堆排序、更改python默认递归层次

1、二分算法

 

data_set = [1,2,4,6,8,11,14,16,18,19,20,22,23,26,30,33,36,39,40]
def bin_search(data_set,value):
    low = 0
    high = len(data_set) - 1
    while low <= high:
        mid = (low + high) // 2
        if data_set[mid] == value:
            return mid
        elif data_set[mid] > value:
            high = mid - 1
        else:
            low = mid + 1

print(bin_search(data_set,22))

 

 

2、冒泡排序

 

def bubble_sort(li):
     for i in range(len(li)-1):
         exchange = False
         for j in range(len(li)-i-1):
             if li[j] > li[j+1]:
                 li[j],li[j+1] = li[j+1],li[j]
                    exchange = True
         if not exchange:
             return

        时间复杂度 O(n²)

 

 

3、选择排序

 

def select_sort(li):
    for i in range(len(li) - 1):
        min_loc = i
        for j in range(i+1,len(li)):
            if li[j] < li[min_loc]:
                min_loc = j
        if min_loc !=i:
            li[i],li[min_loc] = li[min_loc],li[i]

        # 时间复杂度 O(n²)

 

4、插入排序

 

def insert_sort(li):
    for i in range(1,len(li)):
        tmp = li[i]
        j = i - 1
        while j >= 0 and tmp < li[j]:
            li[j + 1] = li[j]
            j = j - 1
        li[j + 1] = tmp

        # 时间复杂度 O(n²)

 

5、快排

 

def quick_sort(data,left,right):
    if left < right:
        mid = partition(data,left,right)
        quick_sort(data,left,mid - 1)
        quick_sort(data,mid + 1,right)

def partition(data,left,right):
    tmp = data[left]
    while left < right:
        while left < right and data[right] >= tmp:
            right -= 1
        data[left] = data[right]
        while left < right and data[left] <= tmp:
            left += 1
        data[right] = data[left]
    data[left] = tmp
    return left


更改python 默认递归层次
import sys
sys.setrecursionlimit(100000000)

 

6、堆排序

 

# 大根堆 ： 一颗  完全二叉树，满足任一节点都比其孩子节点大
# 小根堆 ： 一颗  完全二叉树，满足任一节点都比其孩子节点小

# python 内置模块  heapq
# 利用heapq 模块实现堆排序
# import heapq
# def heapsort(li):
#     h = []
#     for value in li:
#         heapq.heappush(h,value)
#     return [heapq.heappop(h)for  i in range(len(h))]
#
# # 利用heapq 模块实现取top-k
# heapq.nlargest(100,li)