时间复杂度

Big O notation
O(1): Constant Complexity 常熟复杂度
O(log(n)):Logarithmic Complexity 对数复杂度
O(n):Linear Complexity 线性时间复杂度
O(n^2):N square Complexity 平方
O(n^3):N cubic Complexity 立方
O(2^n):Exponential Growth 指数
O(n!):Factorial 阶乘
注：只看最高复杂度的运算

//例1
package main

import "fmt"

func main() {
	n := 1000
	fmt.Println(n)
}

//例2
package main

import "fmt"

func main() {
	n := 1000
	fmt.Println(n)
	fmt.Println(n)
	fmt.Println(n)
}

在例1跟例2中都是常数级的,无论n是多少都是固定次数，即O(1)

//例3
package main

import "fmt"
var n int = 100
func main() {
	for i:=1;i<=n;i++ {
		fmt.Println(i)
	}
}

在例3中虽然只有一行print 但是随着n的增加循环次数会更多，是n的一次方，即O(n)

//例4
package main

import "fmt"
var n int = 100
func main() {
	for i:=1;i<=n;i++ {
		for j:=1;j<=n;j++ {
			fmt.Println(i,j)
		}
	}
}

在例4 中随着n的上升嵌套循环执行的次数是n*n的次数那么复杂度为O(n^2)

//例5
package main

import "fmt"
var n int = 100
func main() {
	for i:=1;i<=n;i++ {
		fmt.Println(i)
	}
	for j:=1;j<=n;j++ {
		fmt.Println(j)
	}
}

在例5中我们可以看到随着n上升那么循环是并列的复杂度为O(n)

//例6
package main

import "fmt"

var n int = 100
func main() {
	for i:=1;i< n;i=i*2 {
		fmt.Println(i)
	}
}

在例6中这个执行次数是log2(n) 那么他的复杂度是O(log(n))

//例7
func fib(n int) int{
	if n < 2 {
		return n
	}
	return fib(n-1)+fib(n-2)
}

在例7中是一个简单的递归，那么就是指数级的复杂度 O(2^n)

在这里插入图片描述

//例8
package main

import "fmt"

var y int = 0
var z int = 0
var n int = 50
func main() {
	for i:=1;i<=n;i++ {
		y += i
	}
	fmt.Println(y)
	z  = n * (n + 1 ) / 2
	fmt.Println(z)
}

如果是按照循环的写法那么他的时间复杂度是O(n) 如果按照求和公式那么他是O(1)

如果是二分查找那么是O(log(n))
binarg search 二分查找
binary tree traversal 二叉树
optimal sorted matrix search 有序的二维矩阵
merge sort 归并排序
二叉树的前序中序后序时间复杂度
通过主定理得到或者说不管前序中序后序他遍历二叉树的时候，每个节点会访问一次，且仅访问一次,就是线性于二叉树的节点总数也就是O(n)的时间复杂度
图的时间复杂度
图里的节点访问一次且仅访问一次所以是O(n),n是图里的节点总数
搜索算法 DFS（深度优先） BFS（广度优先）的时间复杂度
O(n),n搜索空间的节点总数
二分查找时间复杂度
O(log(n))

空间复杂度

1.数组
如果有数组那么数组的长度基本就是空间复杂度，开了个数组那么他的元素是传入的个数那么他就是O(n)的
如果是二维数组，那么开的长度是n^2的那么他的复杂度就是O(n^2)
2.递归的深度
如果有递归的话最大值就是递归的深度，如果递归里面又开了数组，那就是两者的最大值
我的理解也就是递归的最大次数

时间复杂度与空间复杂度简介

时间复杂度

空间复杂度

猜你喜欢