> 1. 時間複雜度：

時間複雜度實際上就是一個函式，計算程式執行的總次數（不是計算時間，是計算語句執行次數）；** 在進行時間複雜度計算時要注意：
1）在實際中通常考慮的是演算法執行的最壞情況；
2）關注執行時間的增長趨勢，關注增長最快的項即可，其他可進行忽略
比如：F（n)=8*n^2+9*n+9;其時間複雜度為O（n^2);
3)遞迴演算法的時間複雜度計算：遞迴總次數*每次遞迴運算元

2、空間複雜度

它是對一個演算法在執行過程中臨時佔用儲存空間大小的量度，強調的是使用輔助空間的大小，不是所有的資料所佔用的空間，不會一直累加。
（計算的不是空間，而是函式中建立的物件的個數） 遞迴演算法的空間複雜度：
遞迴總次數為n*每次遞迴的輔助空間大小。若每次遞迴的輔助空間大小為常數， 則其空間複雜度為O（n)

咱們用以下例項來分析以下時間複雜度與空間複雜度**

1. 折半查詢—–非遞迴

#include<stdio.h>
#include<stdlib.h>
int BinarySearch(int arr[],int sz,int n)
{
    int left=0;
    int right=sz-1;
    while(left<=right)
   {
    int mid=left+((right-left)>>1);
     if(arr[mid]>n)
     {
         right=right-1
 
;
     }
     else if(arr[mid]<n)
     {
         left=left+1;
     }
     else
     {
         return mid;
     }

   }
    return -1;
}
int main()
{
    int arr[]={1,2,3,4,5,6,7,8,9};
    int sz=sizeof(arr)/sizeof(arr[0]);
     printf("%d\n", BinarySearch(arr,sz,1));
    printf("%d\n",  BinarySearch(arr,sz,2
 
));
    printf("%d\n",  BinarySearch(arr,sz,3));
    printf("%d\n",  BinarySearch(arr,sz,4));
    printf("%d\n",  BinarySearch(arr,sz,5));
    printf("%d\n",  BinarySearch(arr,sz,6));
    printf("%d\n",  BinarySearch(arr,sz,7));
    printf("%d\n",  BinarySearch(arr,sz,8));
    printf("%d\n",  BinarySearch(arr,sz,9));
    system("pause");
    return 0;
}
時間複雜度：O（log2 N)//每次查詢縮小一半範圍，即每次執行的次數為log2 N所以不難算出時間複雜度為----->O（log2 N）
空間複雜度：O(1)   建立的物件為常數個

折半查詢——-遞迴

#include<stdio.h>
#include<stdlib.h>
int  BinarySearch(int arr[],int left,int right,int n)
{
    int mid=left+((right-left)>>1);
    while(left<=right)
    {
        if(arr[mid]==n)
        {
            return mid;
        }
        else if(arr[mid]>n)
        {
            return BinarySearch(arr,left,mid-1,n);
        }
        else if(arr[mid]<n)
        {
            return BinarySearch(arr,mid+1,right,n);
        }
    }
    return -1;
}
int main()
{
    int arr[]={1,2,3,4,5,6,7,8,9};
    int left=0;
    int sz=sizeof(arr)/sizeof(arr[0]);
    int right=sz-1;
    printf("%d\n",  BinarySearch(arr,left,right,1));
    printf("%d\n",  BinarySearch(arr,left,right,2));
     printf("%d\n", BinarySearch(arr,left,right,3));
     printf("%d\n", BinarySearch(arr,left,right,4)); 
     printf("%d\n", BinarySearch(arr,left,right,5));
     printf("%d\n", BinarySearch(arr,left,right,6));
     printf("%d\n", BinarySearch(arr,left,right,7));
     printf("%d\n", BinarySearch(arr,left,right,8));
     printf("%d\n", BinarySearch(arr,left,right,9));

    system("pause");
     return 0;
}
時間複雜度：遞迴總次數log2 N，每次執行的時間複雜度為O（1）------>O(log2  N)
空間複雜度：遞迴總次數log2 N，每次建立的物件都是常數個--------->O(log2   N)

斐波那鍥數——-非遞迴

int fib(int n)//1 1 2 3 5 8 13
{
    int first=1;
    int second=1;
    int sum=0;
    if(n<3)
    {
        return 1;
    }
    while(n>2)
      {
          sum=first+second;
          first=second;
          second=sum;
          n--;
      }


   return  sum;
}
時間複雜度：O（N)---程式執行n次
空間複雜度：O(1)---建立的物件為常數個

斐波那鍥數—遞迴

 long long fib(int n)
    {
        if(n<3)
            return 1;
        else
            return fib(n-1)+fib(n-2);
    }

    每一次的計算都被分成前兩個數之和，依次往下遞迴，類似於二叉樹
    當n較大時，形成一個滿二叉樹

    時間複雜度：O（2^n)
    空間複雜度：O(n)