两段函数，判断函数执行速度

func t1() int {
  fmt.Println("hello world")
  return 0
}

此段函数运行次数为2次，打印字符串一次，返回0值一次，T(n)估算值为：T(n)=2

  // i:=0 1次
  // i<n n+1次
  // i++ n次
  // fmt n次
  // return 1次
  // 相加：1 + n + 1 + n + n+ 1 = 3n+3
func t2(n int) int {
  for i := 0; i < n; i++ {
    fmt.Println("hello world")
  }
  return 0
}

当n=2时此段代码运行次数为9次，i=0一次，i<2 3次，i++两次，打印两次，return一次，T(n)估算值为：T(n)=3N+3

T(n)，T当输入为n时，某段代码的总执行次数，n输入数据的大小或者数量

简化的T(n)就是时间复杂度

调用一次函数t1，T(n)= 2 → 1 ,T(n)=常数，常数无论是什么值都估算为1

掉用一次函数t2，T(n)=3n+3 →,常数在时间复杂度估算为1,T(n)=n,因为对于程序来说运行时长最大的还是n，常数的运行时长的固定的

对于n的指数方程应该按照最高指数项来约

T(n)=5n^3+6666n^2+2333 约为T(n)=n^3，n^2的运行时常远远小于n^3的运行时长，对于T(n)来说影响程序运行时长最大的还是n^3的运行时长

表示时间复杂度需要在估值外面加上O

例如：

T(n)=O(1)
T(n)=O(n)
T(n)=O(n^3)

例题

• 多重循环

func t3(n int) {
  for i := 0; i < n; i++ { //执行次数为n
    for j := 0; j < n; j++ { //执行次数为n
      fmt.Println("你好@") //执行次数为1
    }
  }
  // 整体执行次数为：n * n * 1 = n^2
}

  时间复杂度：O(n^2)，公式为如果有a层循环，时间复杂度就是O(n^a)

• 多重循环加上单循环

func t4(n int) {
  for i := 0; i < n; i++ { //执行次数为n
    for j := 0; j < n; j++ { //执行次数为n
      fmt.Println("你好@") //执行次数为1
    }
  }
  // 多重循环执行次数为n^2
  for i := 0; i < n; i++ {
    fmt.Println("你好!")
  }
  // 单循环执行次数为n
}

  整体时间复杂度为O(n^2)，因为对程序整体时间复杂度影响最大的是n^2

• 多重循环加上判断

func t4(n int) {
  if n > 100 {
    for i := 0; i < n; i++ { //执行次数为n
      for j := 0; j < n; j++ { //执行次数为n
        fmt.Println("你好@") //执行次数为1
      }
    }
  } else {
    // 多重循环执行次数为n^2
    for i := 0; i < n; i++ {
      fmt.Println("你好!")
    }
  }
  // 单循环执行次数为n
}

  对于分情况运行的程序依旧是按照运行时间最长的分支来计算，所以此程序时间复杂度为O(n^2)

• 循环嵌套

func t5(n int) {
  for i := 0; i < n; i++ {
    for j := i; j < n; j++ {
      // i = 0 j = 0 循环次数为n-0次 i = 1 j = 1 循环次数为 n - 1 次 i = 2 j = 2 循环次数为 n - 2次 当i = n -1 时 j = n -1 循环次数为 n - (n - 1) 循环次数为1
      fmt.Println(j, i)
    }
  }

}

  整体时间复杂度公式为:

  T(n) = n + (n -1) + (n-2)...+(n - (n-2)) + (n-(n-1))+(n-(n-0))

       =n + n - 1 + n - 2 ... + 2 + 1 + 0

       =n + n + n +.....

       =n * n

       = n^2

  时间复杂度O(n^2)

logn算法

func t6(n int) {
  for i := 0; i < n; i *= 2 {
    fmt.Println("hello world")
  }
}

根据单循环时间复杂度来类比，当n=2时T(2)=2，2是打印的次数，也就是说打印的时间就是此代码的真正执行时间。对于上面的代码，假设n=8，共计打印字符串的次数为3次，假设n=16共计打印字符串次数为4次，从公式可得

T(8)=3, 2^3=8，2^T(8)=8

T(16)=4, 2^4=16，2^T(16)=16

2^T(n)=n

转换一下可得：T(n)=logn2n，再换算为时间复杂度为：T(n)=O(logn n)

时间复杂度对比

运行时间大小从上往下排越靠下运行时间越长