1，时间复杂度 (算法执行次数)

排序的时间复杂度为 O(NlogN)

O(1) : 传入参数对算法执行次数没有影响

func O1(){
    a := 1
    b := 1
    fmt.Println(a + b)
}

O(N) : 与传入的参数大小直接相关,存在循环。

func On(nums []int){
    for _, v := range nums {
        fmt.Println(v)
    }
}

O(logN): 执行时间 log 以2 底 N次方。

func OlogN(num){
    for i := 1; i < num;{
        i = i * 2
    }
}

O(M+N):两个并列for循环

func OMN(num1,num2 int){
    for i := 1; i < num1; i++ {
        
    }
    for j := 1; j < num2; j++ {
        
    }
}

O(NlogN):嵌套循环,其中一层循环次数为 OlogN

func ONLogN(num1,num2 int) {
    total := 0
    for i := 0; i < num1; i++ {
        for j:= 0; j < num2; {
            j = j * 2
        }
    }
    fmt.Println(total)
}
​

O(N^2): 嵌套循环

func ON2(num int) {
    total := 0
    for i := 0; i < num1; i++ {
        for j:= 0; j < num2; {
            total = j + i
        }
    }
    fmt.Println(total)
}

2,空间复杂度 （存储空间与输入值之间的关系）

解释：占空间的 为变量。 语句不占空间。 所以主要需要寻找的就是变量。

大部分都为 O(1) O(n) 递归会存在一个为O(N)栈，所以为O(N)

O(1): 只有一个变量。并且只在一个变量上进行操作

func test(num int){
    total = 0
    for i := 0; i < num; i++ {
        total += i
    }
    return total
}

O(N):进行切片扩容操作。

func test(nums []int){
    var array []int
    for _, v := range nums {
        array = append(array,v)
    }
}