Python系列之简单算法分析

时间复杂度与空间复杂度

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

• 时间复杂度

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

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

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

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

$$O(1) < O(log _{2}n) < O(n) < O(nlog_{2}n) < O(n^2) < O(n^2log_{2}n) < O(n^3)$$
不常见的时间复杂度有：
$$O(n!) < O(2^n) < O(n^n)$$

常见时间复杂度实例：

$$O(1)$$

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

$$O(log_{2}n)$$

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

$$O(n)$$

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

$$O(n^2)$$

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

$$O(n^3)$$

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

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

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

• 常见算法复杂度

算法名称	最差时间复杂度	平均时间复杂度	是否稳定	空间复杂度
冒泡排序	$$O(n^2)$$	$$O(n^2)$$	稳定	$$O(1)$$
快速排序	$$O(n^2)$$	$$O(nlog_{2}n)$$	不稳定	$$O(log_{2}n) | O(1)$$
选择排序	$$O(n^2)$$	$$O(n^2)$$	稳定	$$O(1)$$
二叉树排序	$$O(n^2)$$	$$O(nlog_{2}n)$$	不稳定	$$O(n)$$
插入排序	$$O(n^2)$$	$$O(n^2)$$	稳定	$$O(1)$$
堆排序	$$O(nlog_{2}n)$$	$$O(nlog_{2}n)$$	稳定	$$O(1)$$

• 空间复杂度

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

• 只有变量
  

  $$O(1)$$

• 有一个列表
  

  $$O(n)$$

• N维列表
  

  $$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)