Python系列之简单算法分析

时间复杂度与空间复杂度

算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。

• 时间复杂度

  时间复杂度是指执行算法所需要的计算工作量

  • 计算时间复杂度的方法：

    1、用常数1代替运行时间中的所有加法常数
    2、修改后的运行次数函数中，只保留最高阶项
    3、去除最高阶项的系数

按数量级递增排列，常见的时间复杂度有：

O(1)<O(log2n)<O(n)<O(nlog2n)<O(n2)<O(n2log2n)<O(n3) O ( 1 ) < O ( l o g 2 n ) < O ( n ) < O ( n l o g 2 n ) < O ( n 2 ) < O ( n 2 l o g 2 n ) < O ( n 3 )

不常见的时间复杂度有：

O(n!)<O(2n)<O(nn) O ( n ! ) < O ( 2 n ) < O ( n n )

常见时间复杂度实例：

O(1) O ( 1 )

第一种：
    print("Hello")
第二种：
    sum = (sum+2)/3

O(log2n) O ( l o g 2 n )

def a(n):
    while n > 1:
        n = n // 2
        print(n)
    return n
print(a(10))

O(n) O ( n )

for i in range(n):
    print(i)

O(n2) O ( n 2 )

for i in range(n):
    for j in range(n):
        print(j)

O(n3) O ( n 3 )

for i in range(n):
    for j in range(n):
        for k in range(n):
            print(j)

如何一眼就看出时间复杂度呢？

- 循环减半的过程一般包含:  O(logn)
- 几次循环就是n的几次方复杂度

• 常见算法复杂度

算法名称	最差时间复杂度	平均时间复杂度	是否稳定	空间复杂度
冒泡排序	O(n2) O ( n 2 )	O(n2) O ( n 2 )	稳定	O(1) O ( 1 )
快速排序	O(n2) O ( n 2 )	O(nlog2n) O ( n l o g 2 n )	不稳定	O(log2n)|O(1) O ( l o g 2 n ) | O ( 1 )
选择排序	O(n2) O ( n 2 )	O(n2) O ( n 2 )	稳定	O(1) O ( 1 )
二叉树排序	O(n2) O ( n 2 )	O(nlog2n) O ( n l o g 2 n )	不稳定	O(n) O ( n )
插入排序	O(n2) O ( n 2 )	O(n2) O ( n 2 )	稳定	O(1) O ( 1 )
堆排序	O(nlog2n) O ( n l o g 2 n )	O(nlog2n) O ( n l o g 2 n )	稳定	O(1) O ( 1 )

• 空间复杂度

  空间复杂度是指执行算法所需的内存空间

• 只有变量
  

  O(1) O ( 1 )

• 有一个列表
  

  O(n) O ( n )

• N维列表
  

  O(nn) O ( n n )

算法实例

• 二分查找
  条件：必须是有序集合

import time

def org(func):
    def te(*args, **kwargs):
        t1 = time.time()
        x = func(*args, **kwargs)
        t2 = time.time()
        print  "The time: %s, %s "% (func.__name__, t2-t1)
        return x
    return te

@org
def datas(data_list, val):

    low = 0
    high = len(data_list) - 1

    mid = high // 2

    while low <= high:
        mid = (high + low) // 2
        if data_list[mid] == val:
            return mid
        elif data_list[mid] > val:
            high = mid - 1
        else:
            low = mid + 1
    return

a = list(range(10000))

print(datas(a, 1234))

• 冒泡排序

import random
import time

def org(func):
    def te(*args, **kwargs):
        t1 = time.time()
        x = func(*args, **kwargs)
        t2 = time.time()
        print  "The time: %s, %s "% (func.__name__, t2-t1)
        return x
    return te

@org
def bubble_sort(bubble_list):
    n = len(bubble_list)
    for i in range(n-1):
        exchange = False
        for j in range(n-1-i):
            if bubble_list[j] < bubble_list[j+1]:
                bubble_list[j],bubble_list[j+1] = bubble_list[j+1],bubble_list[j]
                exchange = True
        if not exchange:
            break


a = list(range(10000))

random.shuffle(a)

bubble_sort(a)

• 选择排序

import random
import time

def org(func):
    def te(*args, **kwargs):
        t1 = time.time()
        x = func(*args, **kwargs)
        t2 = time.time()
        print  "The time: %s, %s "% (func.__name__, t2-t1)
        return x
    return te

@org
def select_sort(bubble_list):
    for i in range(len(bubble_list) - 1):
        min_loc = i
        for j in range(i, len(bubble_list)):
            if bubble_list[j] < bubble_list[min_loc]:
                min_loc = j

        bubble_list[i],bubble_list[min_loc] = bubble_list[min_loc], bubble_list[i]

a = list(range(10000))

random.shuffle(a)

select_sort(a)

• 插入排序

import random
import time

def org(func):
    def te(*args, **kwargs):
        t1 = time.time()
        x = func(*args, **kwargs)
        t2 = time.time()
        print  "The time: %s, %s "% (func.__name__, t2-t1)
        return x
    return te

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

a = list(range(1000))

random.shuffle(a)

insert_sort(a)