常用算法

程序=数据结构+算法

递归(复习)

特点：

调用自身

结束条件

def func1(x):
    if x>0:
        func1(x-1)
        print(x)
func1(10)

列表查找

顺序查找：就是for循环，一个一个找

二分查找：必须是有序的列表

代码：

def bin_search(li,val):
    low = 0
    high = len(li) -1
    while low <=high:
        mid = (low+high)//2
        if li[mid] ==val:
            return mid
        elif li[mid] >val:
            high = mid -1
        else:
            low = mid +1
    return None
li=list(range(1000))
print(bin_search(li,3))

LOW B三人组

冒泡：列表每两个相邻的数，如果前面比后面的大，那么交换这两个数的位置

选择：一趟遍历记录中最小的数，放到第一个位置，再一趟遍历剩余列表中的数字，继续放置

插入：每次从无序区选择一个元素，插入到有序区，直到无序区为空

冒泡代码：

def bubble_sort(li):
    for i in range(len(li)-1):
        flag = False
        for j in range(0, len(li)-i-1):
            if li[j] > li[j+1]:
                li[j], li[j+1] = li[j+1], li[j]
                flag=True
        if not flag:  #如果走了一趟都没有变化，说明已经排好了，直接跳出循环
            break

li=list(range(100))
random.shuffle(li)
print(li)
bubble_sort(li)
print(li)

 选择排序代码：

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
        li[min_loc], li[i] = li[i], li[min_loc]

li=list(range(100))
random.shuffle(li)
print(li)
select_sort(li)
print(li)

 插入排序代码

def insert_sort(li):
    for i in range(1, len(li)):#从第二个开始循环
        tmp = li[i] #把抽到的牌先临时存起来
        j = i - 1  #前面那张牌的下标
        while j>=0 and li[j]>tmp:  #从第二个开始循环，且前面的数大于后面
            li[j+1]=li[j] #满足条件j的位置往后挪一位，tmp不插入
            j = j - 1 #再把前一张牌往前挪一位，去比较下一张
        li[j+1] = tmp  #插入tmp

li=list(range(100))
random.shuffle(li)
print(li)
insert_sort(li)
print(li)

NB三人组

快排：好写排序里面最快的

取一个元素P，通过某种方式使P归位，列表被分成两部分，左边的都比P小，右边的都比P大，完成归位；

分别对左右递归，当列表中小于两个元素，排序完成。

代码：

def partition(data, left, right):
    tmp = data[left]   #取第一个数(要归位的数)临时存起来，此时左边有空位了
    while left < right:
        while left<right and data[right] >= tmp: #从右边找只要right比tmp大，就一直找
            right -= 1
        data[left]=data[right]  #不满足while条件,说明右边比左边小,将右边的数值,覆盖到左边
        while left<right and data[left] <= tmp:  #从左边找
            left += 1
        data[right]=data[left]
    data[left]=tmp   #不满足while条件，说明left=fight，归位
    return left

def quick_sort_x(data, left, right):
    if left < right:#说明至少还有俩元素，需要继续递归
        mid = partition(data, left, right) #mid值指已经归位的下标，把列表分成两部分
        quick_sort_x(data, left, mid - 1)
        quick_sort_x(data, mid + 1, right)

@cal_time
def quick_sort(data):
    quick_sort_x(data, 0, len(data)-1)
    print(data)

li=list(range(10))
random.shuffle(li)
print(li)
quick_sort(li)

 堆排序：

import random
def sift(li, left, right):
    i = left
    j = 2 * i + 1
    tmp = li[left]
    while j <= right:
        if j+1 <= right and li[j] < li[j+1]:
            j = j + 1
        if tmp < li[j]:
            li[i] = li[j]
            i = j
            j = 2 * i + 1
        else:
            break
    li[i] = tmp


def heap_sort(li):
    n = len(li)
    for i in range(n//2-1, -1, -1): #建立堆
        sift(li, i, n-1)
    for i in range(n-1, -1, -1):    #挨个出数
        li[0], li[i] = li[i],li[0]
        sift(li, 0, i-1)
li=list(range(100000))
random.shuffle(li)
print(li)
heap_sort(li)
print(li)

 归并排序

假设现在的列表分两段有序，如何将其合成一个有序列表

这个过程称为一次归并

 分解：将列表越分越小，直至分成一个元素

一个元素是有序的

合并：将两个有序列表归并，列表越来越大

 代码：

import random
def merge(li, left, mid, right):
    i = left
    j = mid + 1
    ltmp = []
    while i <= mid and j <= right:   #左边右边都没排完
        if li[i] < li[j]:
            ltmp.append(li[i])  #升序排列
            i += 1
        else:
            ltmp.append(li[j])
            j += 1
    while i<= mid: #左边剩下了
        ltmp.append(li[i])   #依次挨个追加
        i += 1
    while j <= right:
        ltmp.append(li[j])
        j += 1
    li[left:right+1] = ltmp

def _merge_sort(li,left,right):
    if left < right:
        mid = (left+right)//2
        _merge_sort(li,left,mid)
        _merge_sort(li,mid+1,right)
        #print(li[left:right+1])
        merge(li,left,mid,right)
        #print(li[left:right+1])

@cal_time
def merge_sort(li):
   _merge_sort(li, 0, len(li)-1)

li=list(range(100))
random.shuffle(li)
print(li)
merge_sort(li)
print(li)

时间装饰器代码

import time

def cal_time(func):
    def wrapper(*args, **kwargs):
        t1 = time.time()
        x = func(*args, **kwargs)
        t2 = time.time()
        print("%s running time %s secs."%(func.__name__, t2-t1))
        return x
    return wrapper

 一般情况下，就运行时间而言

快排  < 归并排序  < 堆排序

 快排：极端情况下排序效率低

归并排序：需要额外的内存开销

堆排序：在快的排序算法中相对比较慢