1. 1数据结构 算法时间复杂度

看代码效率如何？直接看时间效率和空间效率，可以不用让代码在电脑上跑。

1.时间复杂度

算法的时间复杂度是一个函数，是算法中的基本操作的执行次数。
也就是找到某条基本语句与问题规模N之间的数学表达式，就是算出了该算法的时间复杂度。

举例

例如计算Func1中++count语句总共执行了多少次？

void Func1(int N)
{
int count = 0;
for (int i = 0; i < N ; ++ i)
{
 for (int j = 0; j < N ; ++ j)
 {
 ++count;
 }
}
 
for (int k = 0; k < 2 * N ; ++ k)
{
 ++count;
}
int M = 10;
while (M--)
{
 ++count;
}
printf("%d\n",count);
}

所以Func1执行的基本操作次数是 F(N)=N^2+2*N+10
N=10时，F(N)=130
N=100时，F(N)=10210
N=1000时，F(N)=1002010
当我们只想估算时，
只让F(N)=N^2
N=10时，F(N)=100
N=100时，F(N)=1000
N=1000时，F(N)=1000000
这两份数据都很接近，所以其实我们只需要取影响最大的项进行估算就好了，这就是大O的渐进表示法。
所以，Func1的时间复杂度是O(N^2)

总结

大O渐进表示方法：

1. 用常数1取代运行时间中的所有加法常数。
2. 在修改后的运行次数函数中，只保留最高阶项。（取决定性的那一项）。
3. 如果最高阶项存在且系数不是1，则去除与这个项目相乘的常数（系数）。得到的结果就是大O阶。例如F（N）=4N，则可以将4去掉，最后O（N）。
4. 时间复杂度是保守的估算，在实际中一般情况关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N)。

练习

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);
}

O（N）

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);
}

不确定M和N的关系：O（N+M）
M>N：O（M）
M<N：O（N）
M=N：O（M）or O（N）

3.计算Func4的时间复杂度

void Func4(int N)
{
 int count = 0;
 for (int k = 0; k < 100; ++ k)
 {
 ++count;
 }
 printf("%d\n", count);
}

O(1)
注意：O(1)代表的是常数次，不是1次

❗时间复杂度不是计算代码中循环次数，而是根据代码思想，灵活计算。
例如以下：
4.计算Func5的时间复杂度

// 计算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;
 }
 }

这个代码思想是看里面的for循环变化，里面for循环次数是和外面end有关。所以里面的for循环是：n-1次，n-2次，n-3次…3,2,1。
所以F（N）=N*(N-1)/2，O(N)=N^2。
5.

int PartSort1(int* a,int left,int right)
{
   int keyi=left;
   while(left<right)
   {
   while(left<right&&a[right]>=a[keyi])
   {
   --right;
   }
   while(left<right&&a[left]<=a[keyi])
   {
    ++left;
   }
   Swap(&a[keyi],&a[left]);
   }
   Swap(&a[keyi],&a[left]);
   return left;
};

O(N)
6.

方法1：
1.先冒泡排序。
2.遍历，当前值+1，不等于下一个数字就是下一个数字。
官方题解是用C++语言写，并且使用哈希表的方法，本人还未学到这儿，稍后再来，先附上方法：
遍历数组nums，第一次循环将数组中的每个元素加入哈希集合，第二次循环依次检查从0到n的每个整数是否在哈希表中

方法2：
异或

int missingNumber(int* nums, int numsSize){
   int x=0;
   int i=0;
   for(i=0;i<numsSize;i++)
   {
      x^=nums[i];
   }
   for(i=0;i<numsSize+1;i++)
   {
      x=x^i;
   }
   return x;
}
//例如numsSize=5
//第一个循环，i<5,下标0 1 2 3 4数字异或
//i<6,完整的数字:0 1 2 3 4 5
//完整数字和下标0 1 2 3 4数字异或

方法3：
等差数列公式计算和

int missingNumber(int* nums, int numsSize){
      int N=numsSize;
      int sum=N*(0+N+1)/2;
      for(int i=0;i<numsSize;i++)
      {
          sum-=nums[i];
      }
      return sum;
}
//通过等差数列求和让完整数字相加
//用和减去部分数字，找出消失数字

// 计算BinarySearch的时间复杂度？
int BinarySearch(int* a, int n, int x)
{
 assert(a);
 int begin = 0;
 int end = n-1;
 // [begin, end]：begin和end是左闭右闭区间，因此有=号
 while (begin <= end)
 {
 int mid = begin + ((end-begin)>>1);
 if (a[mid] < x)
 begin = mid+1;
 else if (a[mid] > x)
 end = mid-1;
 else
 return mid;
 }
 return -1;
}

O(logN)
很明显这里用了二分查找的方法

找了多少次，除了多少个2，假设找了x次，N=2^x, x=log2的N，这样我们就得出了时间复杂度是O(logN)，可以把2给忽略掉进行缩写，logN就说明是以2位底。
但是以其他数字为底的就不能缩写。

❗：二分查找对应的是暴力查找
暴力查找（数组过一遍查找）：O(N)
二分查找：O(logN)
对比下来二分查找效率更高的原因：
O(N)=1000时，O(logN)=10
因为2^10=1024,约等于1000次
O(N)=100W时，O(logN)=20
因为2^20约等于100000次
O(N)=10亿时，O(logN)=30
❗用二分查找的前提是有序，所以空有其表，因为要排序，所以插入删除都不方便，后面的高级数据结构会用到AVL树，红黑树，哈希表，会方便很多。

// 计算阶乘递归Fac的时间复杂度？
long long Fac(size_t N)
{
 if(0 == N)
 return 1;
 
 return Fac(N-1)*N;
}

O(n)
递归调用是多次调用累加。
Fac(N)，Fac(N-1)，Fac(N-2)，Fac(N-3)…Fac(2)，Fac(0)。

// 计算斐波那契递归Fib的时间复杂度？
long long Fib(size_t N)
{
 if(N < 3)
 return 1;
 
 return Fib(N-1) + Fib(N-2);
}

O(N)=2^N
递归调用是调用的累加

斐波那契到Fib(2)和Fib(1)就不会分解，因为都是返回1。
斐波那契额数在实际运用中会困难，因为它是指数型增长。