时间复杂度与空间复杂度

算法的时间复杂度

算法的语句执行次数作为算法语句频度或时间频度
算法中基本操作重复执行的次数是问题规模为n的某个函数$f(n)$，算法的时间度量
$$T（n）=O（f（n）)$$
表示问题规模n的增长，算法执行时间的增长率和f(n)的增长率相同，称算法的时间复杂度。
在下面三个程序中

//1 时间复杂度 O（1）
{	
	++ x ;
	s = 0;
}
//2 时间复杂度O（n）
for(int i = 1; i <= n; ++ i)
	++ x;
	s = 0;
}
//3 时间复杂度O（n^2）
for(int k = 0; k <= n; ++ k)
{
	for ( int j = 0; j <= n; ++ j) 
	{
		++ x;
		s += 0;
	}
}

• 时间复杂度的推到规则
  1. 只保留最高阶的项
  2. 去掉最高阶项的系数
• 常用的时间复杂度

常数型	线性型	对数型	平方型	二维型	立方形	指数型
$O(1)$	$O(n)$	$O(logn)$	$O(n^2)$	$O(nlogn)$	$O(n^3)$	$O(2^n)$

算法的空间复杂度

算法占用的空间复杂度是指算法实际中所占用的辅助空间总和
算法的空间复杂度$S(n)$定义为算法所消耗的储存空间的数量级,记作
$$S(n)=O(f(n))$$
若算法执行时间所需要的辅助空间相对于输入的数据量来讲是一个常数,则空间复杂度O(1)

时间复杂度/空间复杂度的计算

//时间复杂度 O(1)空间复杂度O(1)
x=91; 
y=100;
while(y>0) 
    if(x>100) {
    x=x-10;
    y--;
} 
else {
    x++;
}

//这段循环与n无关,在大的循环时间复杂度为O(1)

//时间复杂度 O(n)空间复杂度O(n)
int Sum(int N)
{ 
	if (1 == N)
		return 1;
	return  Sum(N - 1) + N;
}

//时间复杂度 O(2^n)空间复杂度O(n)
//斐波那契数列
int Fib(int n)
{
	if(n == 1 || n == 0)
	{
		return 1;
	}
	else 
	{
		return Fib( n - 1) + Fib ( n - 2 );
	}	
}
//斐波那契数列递归版本,

//时间复杂度O(1) ~ O(logn) 空间复杂度O(1)
//二分查找
int BinarySeach(int a[], int n, int key)
{
    int left = 0;
    int right = n - 1;
    int mid;
    while (left <= right)
    {
        mid = (left + right) / 2;

        if (a[mid] == key)
        {
            return mid;
        }
        else if(a[mid] < key)
        {
            left = mid + 1;
        }
        else
        {
            right = mid + 1;
        }

    }
    return -1;
}


//时间复杂度O(nlogn) ~ O(n^2) 空间复杂度 O(logn)

int partition(int arr[], int i, int j)
{
    int tmp = arr[i];
    while (i < j)
    {
        while (i<j&&tmp <= arr[j]) j--;
      
        if (i < j)
        {
            arr[i] = arr[j];
        }
        
        while (i < j&&tmp >= arr[i]) i++;
       
        if (i < j)
        {
            arr[j] = arr[i];
        }   
    }
    arr[i] = tmp;
    return i;
}


void QuickSort(int arr[], int i,int j)
{
    int p;
    if (i < j)
    {
        p = partition(arr, i, j);
        QuickSort(arr, i, p-1);
        QuickSort(arr, p + 1, j);
    }
}