时间复杂度和空间复杂度，排序算法

一。时间复杂度和空间复杂度

　　时间复杂度是，衡量算法是否优秀的一个标准，其概念是大概一个算法运行需要的时间。

　　空间复杂度是一个算法在运行的时候，所消耗的空间。

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

　　其他：

　　O(n!)，O(2^n)，O(n^n)

二。冒泡排序

　　冒泡排序的时间复杂度为 O（n^2）

def Bubble_sort(li):
    for i in range(len(li)-1):
        for j in range(len(li)-1-i):
            if li[j] > li[j+1]:
                li[j], li[j+1] = li[j+1], li[j]

三。选择排序

　　选择排序的时间复杂度为O（n^2）

def select_sort(li):
    for i in range(len(li)):
        minLoc = i ###i = 0
        for j in range(i+1, len(li)):
            if li[j] < li[minLoc]:
                li[j], li[minLoc] = li[minLoc], li[j]

四。插入排序

　　插入排序的时间复杂度为O（n^2）

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 = j - 1
        li[j+1] = tmp

　　

五。快速排序

　　快速排序的时间复杂度为O（nlogn）

def partition(li, left, right):
    tmp = li[left]
    while left < right:
        while left < right and li[right] >= tmp:
            right = right - 1
        li[left] = li[right]
        while left < right and li[left] <= tmp:
            left = left + 1
        li[right] = li[left]
    li[left] = tmp
    return left


def quick_sort(li, left, right):
    if left < right:
        mid = partition(li, left, right)
        quick_sort(li, left, mid-1)
        quick_sort(li, mid+1, right)

　　

 排序视图网站

https://visualgo.net/zh/sorting