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)

你可能感兴趣的:(python,算法)