python中的一些算法

两个基础知识点:递归和时间复杂度

递归

递归函数的特点:自己调用自己,有结束条件,看下面例子:

def fun1(x):

    """无结束条件,报错"""

    print(x)

    fun1(x-1)

def fun2(x):

    """结束条件为错误条件,报错"""

    if x>0:

        print(x)

        fun2(x+1)

def fun3(x):

    """打印倒序"""

    if x>0:

        print(x)

        fun3(x-1)

def fun4(x):

    """打印正序"""

    if x > 0:

        fun4(x-1)

        print(x)

fun3(7)

fun4(7)

结果:

时间复杂度

用来评估算法运行效率的东西:

print('Hello World')

#时间复杂度:O(1)

for i in range(n):

    '''时间复杂度:O(n)'''

    print('Hello World')

for i in range(n):

    '''时间复杂度:O(n^2)'''

    for j in range(n):

        print('Hello World')

for i in range(n):

    '''时间复杂度:O(n^3)'''

    for j in range(n):

        for k in range(n):

            print('Hello World')

while n > 1:

    '''时间复杂度:O(log2n)或者O(logn)'''

    print(n)

    n = n // 2

小结:

时间复杂度是用来估算一个算法运行时间的标准
一般说来,时间复杂度高的要比时间复杂度低的算法慢
常见的复杂度按效率排行:

O(1) < O(logn) <O(n) <O(nlogn) < O(n^2) < O(n^2 logn) < O(n^3)

那么如何一样判断时间复杂度?

循环减半的过程,O(logn)
几次循环就是n的几次方的复杂度

列表查找

输入:列表或者待查找元素
输出:元素下标或者未查到的元素

顺序查找

从元素的第一个开始,按顺序进行查找,直到找到为止

二分查找

从有序列表的候选区data[0:n]开始，通过对待查找的值与候选区中间值的比较，可以使候选区减少一半。

import time

#定义一个计算运行时间的装饰器

def cal_time(func):

    def wrapper(*args,**kwargs):

        t1 = time.time()

        res = func(*args,**kwargs)

        t2 = time.time()

        print('%s:%s'%(func.__name__,t2-t1))

        return res

    return wrapper

#顺序查找

@cal_time

def linear_search(data_set,value):

    for i in range(len(data_set)):

        if data_set[i] == value:

            return i

#二分查找

@cal_time

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:

            low = mid + 1

        else:

            high = mid - 1

ret = linear_search(list(range(100000)),99999)

ret2 = bin_search(list(range(100000)),99999)

但有个问题:理论上顺序查找的时间复杂度为O(n),二分查找的为O(logn),看结果二分查找的结果为一个科学记数法,相差2个量级.

linear_search:0.009849071502685547

bin_search:1.5974044799804688e-05

列表排序

将无序列表变为有序列表

low逼三人组:冒泡、选择、插入

之前写过：http://www.cnblogs.com/ccorz/p/5581066.html

冒泡

序列中,相邻的两个元素比较大小,如果前面的比后面的元素大,那么交换位置,以此类推...

import random

data = list(range(10000))

random.shuffle(data)

def bubbel_sort(data):

    for i in range(len(data) - 1):

        for j in range(len(data) - i - 1):

            if data[j] > data[j+1]:

                data[j], data[j+1] = data[j+1], data[j]

bubbel_sort(data)

print(data)

冒泡的优化:

如果排序执行了一趟数据没有交换,那么说明列表已经是有序状态,可以直接结束算法:

def bubbel_sort(data):

    for i in range(len(data) - 1):

        exchange = False

        for j in range(len(data) - i - 1):

            if data[j] > data[j+1]:

                data[j], data[j+1] = data[j+1], data[j]

                exchange = True

        if not exchange:

            break

选择

遍历一趟,选择最小的数放到第一个位置,接着遍历剩下的序列,选择其中最小的,放到剩下序列的第一个位置,如此循环.

import random

data = list(range(1000))

random.shuffle(data)

def select_sort(data):

    for i in range(len(data) - 1):

        min_loc = i

        for j in range(i + 1, len(data)):

            if data[j] < data[min_loc]:

                min_loc = j

        if min_loc != i:

            data[i], data[min_loc] = data[min_loc], data[i]

select_sort(data)

print(data)

插入排序

列表被分为有序区和无序区两个部分,并且最初有序区只有一个元素.

import random

data = list(range(1000))

random.shuffle(data)

def insert_sort(data):

    for i in range(1,len(data)):

        tmp = data[i]

        j = i - 1

        while j >= 0 and data[j] > tmp:

            data[j+1] = data[j]

            j -= 1

        data[j+1] = tmp

insert_sort(data)

print(data)

快速排序(简称快排)

好些的算法里最快的,快的排序算法中最好写的。

思路:

取第一个元素,是这个元素(P)归位(对的位置)
列表被P元素分成两部分
递归这两部分列表,以此类推

总结一句话就是:先整理,后递归

import sys, random

#解除python默认递归次数的限制

sys.setrecursionlimit(10000)

data = list(range(1000))

random.shuffle(data)

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

quick_sort(data, 0, len(data) - 1)

print(data)

堆排序

二叉树

满二叉树是指这样的一种二叉树：除最后一层外，每一层上的所有结点都有两个子结点。在满二叉树中，每一层上的结点数都达到最大值，即在满二叉树的第k层上有2k-1个结点，且深度为m的满二叉树有2m－1个结点。

完全二叉树是指这样的二叉树：除最后一层外，每一层上的结点数均达到最大值；在最后一层上只缺少右边的若干结点。

二叉树的数据存储

二叉树总结

二叉树是不超过2个节点的树
满二叉树是完全二叉树,完全二叉树不一定是满二叉树
完全二叉树可以用列表来存储,通过规律可以从父亲找到孩子,或从孩子找到父亲

堆

大根堆:一颗完全二叉树,满足任何一节点都比其子节点大

小根堆:一颗完全二叉树,满足任何一节点都比其子节点小

堆排序

堆排序的过程:

建立堆
得到堆顶元素,假设为最大元素
去掉堆顶元素,将最后一个元素放到堆顶,此时可以通过一次调整,重新使堆有序
堆顶元素为第二大元素
重复步骤三

代码:

import sys, random

sys.setrecursionlimit(10000)

data = list(range(100))

random.shuffle(data)

def sift(data,low,high):

    '''堆整理,选出最大的元素'''

    i = low

    j = 2*i+1

    k = j +1

    tmp = data[i]

    while j <= high:

        if j < high and data[j] < data[k]:

            j+=1

        if tmp < data[j]:

            data[i]=data[j]

            i=j

            j=2*i+1

        else:

            break

    data[i]=tmp

def heap_sort(data):

    n = len(data)

    for i in range(n//2-1,-1,-1):

        sift(data,i,n-1)

    for i in range(n-1,-1,-1):

        data[0],data[i]=data[i],data[0]

        sift(data,0,i-1)

heap_sort(data)

print(data)

out:

[0, 1, 2, 3, 12, 5, 4, 6, 7, 8, 25, 9, 10, 11, 17, 23, 13, 73, 29, 14, 15, 19, 40, 28, 44, 64, 30, 27, 18, 16, 21, 70, 22, 20, 31, 24, 34, 32, 33, 26, 35, 36, 39, 46, 37, 41, 38, 42, 86, 45, 43, 51, 62, 47, 49, 75, 72, 54, 50, 48, 57, 63, 68, 56, 87, 60, 67, 59, 55, 78, 58, 61, 69, 52, 53, 80, 83, 65, 89, 66, 94, 91, 71, 82, 92, 90, 77, 81, 74, 84, 95, 76, 85, 88, 93, 79, 96, 98, 97, 99]