数据结构之------算法复杂度

1. 数据结构前言

1.1 数据结构

数据结构(Data Structure)是计算机存储、组织数据的方式，指相互之间存在⼀种或多种特定关系的数据元素的集合。没有⼀种单⼀的数据结构对所有用途都有用，所以我们要学各式各样的数据结构，如：线性表、树、图、哈希等

1.2 算法

算法(Algorithm):就是定义良好的计算过程，他取⼀个或⼀组的值为输入，并产生出⼀个或⼀组值作为输出。简单来说算法就是⼀系列的计算步骤，用来将输入数据转化成输出结果。

2. 算法效率

2.1 复杂度的概念

算法在编写成可执行程序后，运行时需要耗费时间资源和空间(内存)资源 。因此衡量⼀个算法的好

坏，⼀般是从时间和空间两个维度来衡量的，即时间复杂度和空间复杂度。

时间复杂度主要衡量⼀个算法的运行快慢，而空间复杂度主要衡量⼀个算法运行所需要的额外空间。在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注⼀个算法的空间复杂度。

3. 时间复杂度

定义：在计算机科学中，算法的时间复杂度是⼀个函数式T(N)，它定量描述了该算法的运行时间。时间复杂度是衡量程序的时间效率，那么为什么不去计算程序的运行时间呢？

1. 因为程序运行时间和编译环境和运行机器的配置都有关系，比如同⼀个算法程序，⽤⼀个老编译

器进行编译和新编译器编译，在同样机器下运行时间不同。

2. 同⼀个算法程序，用⼀个老低配置机器和新⾼配置机器，运行时间也不同。

3. 并且时间只能程序写好后测试，不能写程序前通过理论思想计算评估。

计算程序能代表增长量级的大概执行次数，复杂度的表示通常使用大O的渐进表示法。

注意：1.每条语句的执行时间即使有差别但很小，可忽略不计，认为每条语句的执行时间是相同                   的，简而言之，就是在循环部分计入，在单个的语句就不算了。

           2.时间复杂度只能用来表示输入条件对时间的影响趋势。

3.1 大O的渐进表示法

大O符号（Big O notation）：是用于描述函数渐进行为的数学符号，表示算法的复杂度。

3.2 时间复杂度计算示例

3.2.1 示例1

// 计算Func2的时间复杂度？ 
void Func2(int N) 
{ 
  int count = 0; 
  for (int k = 0; k < 2 * N ; ++ k) 
  {
     ++count; 
  }
  int M = 10; 
  while (M--) 
  { 
    ++count; 
  }
  printf("%d\n", count); 
}

Func2执行的基本操作次数：

T ( N ) = 2 N + 10

根据推导规则第3条得出

Func2的时间复杂度为： O ( N )

3.2.2 示例2

// 计算Func3的时间复杂度？ 
void Func3(int N, int M) 
{ 
  int count = 0; 
  for (int k = 0; k < M; ++ k) 
  { 
    ++count; 
  }
  for (int k = 0; k < N ; ++ k) 
  { 
    ++count; 
  }
  printf("%d\n", count);
}

Func3执行的基本操作次数：

T ( N ) = M + N

我们来进一步讨论：若M>>N，则O(M);

                                若N>>M，则O(N);

                                若N==M,   则O(M)||O(N);

3.2.3 示例3

// 计算Func4的时间复杂度？ 
void Func4(int N) 
{ 
  int count = 0; 
  for (int k = 0; k < 100; ++ k) 
  { 
    ++count; 
  }
  printf("%d\n", count); 
}

Func4执行的基本操作次数：

T ( N ) = 100

根据推导规则第1条得出

Func2的时间复杂度为： O (1)

3.2.4 示例4

// 计算strchr的时间复杂度？ 
const char * strchr ( const char * str, int character) 
{ 
  const char* p_begin = s; 
  while (*p_begin != character) 
  {
    if (*p_begin == '\0')
    return NULL; 
    p_begin++; 
  } 
  return p_begin; 
}

strchr执行的基本操作次数：

1）若要查找的字符在字符串第⼀个位置，则： T ( N ) = 1

2）若要查找的字符在字符串最后的⼀个位置， 则： T ( N ) = N

3）若要查找的字符在字符串中间位置，则： T ( N ) = N/2

因此：strchr的时间复杂度分为：

最好情况： O (1)

最坏情况： O ( N )

平均情况： O ( N )

总结

通过上⾯我们会发现，有些算法的时间复杂度存在最好、平均和最坏情况。

最坏情况：任意输入规模的最大运行次数(上界)

平均情况：任意输入规模的期望运行次数

最好情况：任意输入规模的最小运行次数(下界)

大O的渐进表示法在实际中⼀般情况关注的是算法的上界，也就是最坏运行情况。

4. 空间复杂度

空间复杂度也是⼀个数学表达式，是对⼀个算法在运行程中因为 算法的需要额外临时开辟的空间 。

空间复杂度不是程序占用了多少bytes的空间，因为常规情况每个对象大小差异不会很大，所以 空间复杂度算的是变量的个数。

空间复杂度计算规则基本跟实践复杂度类似，也使用大O渐进表示法。

注意：函数运行时所需要的栈空间(存储参数、局部变量、⼀些寄存器信息等)在编译期间已经确定好了，因此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定

// 计算BubbleSort的空间复杂度？ 
void BubbleSort(int* a, int n) 
{ 
  assert(a); 
  for (size_t end = n; end > 0; --end)
  { 
    int exchange = 0; 
    for (size_t i = 1; i < end; ++i)
    { 
      if (a[i-1] > a[i]) 
      { 
         Swap(&a[i-1], &a[i]); 
         exchange = 1; 
      } 
    }
   if (exchange == 0) break; 
   } 
}

函数栈帧在编译期间已经确定好了， 只需要关注函数在运行时额外申请的 空间。

BubbleSort额外申请的空间有 exchange等有限个局部变量，使用了常数个额外空间

因此空间复杂度为 O (1)