时间复杂度与空间复杂度

数据元素：是数据的基本单位，可以理解为记录。

数据项：一个数据元素可由多个数据项组成，数据项可以理解为所组成的记录的每一个属性。

数据结构：是相互之间存在一种或多种特定关系的数据元素的集合。

算法：  是对特定问题求解步骤的一种描述，它是指令的有限序列，其中每一条指令表示一个或多个操作。

 算法的5个重要特性：

 1.确定性 2.可行性 3.有穷性 4.输入 5.输出

时间复杂度：

      1.  百度百科中的定义：算法中基本 操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),使得当n趋近于无穷大时，

 T(n)/f(n）的极限值为不等于零的常数。，则称f(n)是T(n)的同量级函数。记作T(n) = O(f(n)),则称f(n)为渐进是渐进时间复杂度，简称时间复杂度。

     2.  在计算时间复杂度的时候，先找出算法的基本操作，然后根据相应的各语句确定它的执行次数，再找出 T(n) 的同数量级

（它的同数量级有以下：1，log2n，n，n log2n ，n的平方，n的三次方，2的n次方，n!），找出后，f(n) = 该数量级，

 若 T(n)/f(n) 求极限可得到一常数c，则时间复杂度T(n) = O(f(n))。

具体的解题步骤：

1.找到基本操作，计算执行次数

2.用常数1代替所有的加法常数

3.在修改后的运行次数函数中，只保留最高阶项

4.如果最高阶项的系数存在且不是1，则去除

空间复杂度：

  一个算法的空间复杂度值考虑在运行过程中为局部变量分配的存储空间的大小，它包括为参数表中形参变量分配的存储空间和为在函数体中定义的局部变量分配的

存储空间两个部分。若一个算法为递归算法，其空间复杂度为递归所使用的堆栈空间的大小，它等于一次调用所分配的临时存储空间的大小乘以被调用的次数

有关时间复杂度的计算：

二分查找所需要的时间复杂度和空间复杂度的分析：

假设其数组长度为n，经过m次二分查找到结果（即只剩下一个元素），则：n/(2^m) = 1（即n=m^2），对于二分查找来说，树的高度是时间复杂度。

代码如下：

#include<stdio.h>
//二分查找非递归
int binary_search(int * arr, int sz , int key)
{
           int left = 0;
           int right = sz - 1;
           int mid = 0;
           while (left <= right)
          {
                   mid = left + (right - left) / 2;

                    if (arr [mid] == key)
                   {
                              return mid;
                   }
                    else if (arr[mid] > key)
                   {
                             right = mid - 1;
                   }
                    else
                   {
                             left = mid + 1;
                   }
          }
           return -1;
}
int main()
{
           int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
           int sz = sizeof (arr) / sizeof(arr[0]);
           int key = 4;
           int ret = binary_search(arr, sz, key);
           if (ret == -1)
          {
                   printf( "没找到\n" );
          }
           else
          {
                   printf( "找到了%d\n" , ret);
          }
           return 0;
}

对于递归算法：

//二分查找递归
int binary_search2(int * arr,int left, int right , int key)
{
          
           int mid = (left + right) >> 1;

           while (left <= right)
          {
                    if (arr [mid] < key)
                   {
                              return binary_search2(arr , mid + 1, right, key);
                   }
                    else if (arr[mid]> key)
                   {
                              return binary_search2(arr , left, mid - 1, key);
                   }
                    return mid;
          }
           return -1;
}
int main()
{
           int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
           int sz = sizeof (arr) / sizeof(arr[0]);
           int key = 11;
           //int ret = binary_search(arr, sz, key);
           int ret = binary_search2(arr, 0, sz, 11);

           if (ret == -1)
          {
                   printf( "没找到\n" );
          }
           else
          {
                   printf( "找到了%d\n" , ret);
          }
           return 0;
}

    要重复执行的基本操作是循环体里面的语句。

    对于递归算法的二分查找的时间复杂度是一样是O(long2^n),而空间复杂度是数的高度，为O(long2^n)

//斐波那契数的递归实现
int fibo(int n)
{
           if (n < 3)
          {
                    return 1;
          }
           else
          {
                    return fibo(n - 1) + fibo( n - 2);
          }
}
int main()
{
           int n;
           int ret;
          printf( "请输入求第几个数：\n" );
          scanf( "%d" , &n);
          ret = fibo(n);
          printf( "%d\n" , ret);
           return 0;
}