数据结构_时间复杂度和空间复杂度

时间复杂度

首先，我们是不可能计算出程序的运行时间，因为这和计算机每秒运行次数以及该程序的运行次数有关。其次，时间复杂度往往用于算法分析，而**时间复杂度**其实是对运行次数的一个估算。
在一个算法里，我们通常都用最坏的情况进行分析它的运行次数，我们一般都用O渐进法表示计算时间复杂度。

一般算法O(n)的计算方法：
1.用常数1取代运行时间中所有加法常数；
2.修改后的运行次数函数中，只保留最高阶项；
3.如果高阶项系数存在且不是1，则去除与该项相乘的常数。

递归算法： 递归总次数*每次递归次数

空间复杂度

函数中创建对象的个数关于问题规模函数表达式，一般情况同样用O的渐进表示法表示。
代码占用空间+输入数据所占空间+辅助变量所占空间。

斐波那契数的递归和非递归

int fibonacci(int a)  //非递归
{
    int x1 = 0;
    int x2 = 1;
    int x3 = x1 + x2;
    if (1 == a)
    {
        return x1;
    }
    else if (2 == a)
    {
        return x2;
    }
    else if (a > 2)
    {
        for (int i = 0; i < a - 2; i++)   //O(n)
        {
            x3 = x1 + x2;
            x1 = x2;
            x2 = x3;
        }
        return x3;
    }
    return a;
}

时间复杂度：O(n)
空间复杂度：O(1)

t recursion_fibonacci(int a)
{
    assert(a>0);
    if (1 == a)
    {
        return 0;
    }
    else if (2 == a)
    {
        return 1;
    }
    return recursion_fibonacci(a - 1) + recursion_fibonacci(a - 2);  //O(2^n)

}

时间复杂度：O(2^n)
空间复杂度：O(n)

二分查找的递归和非递归

int binary_search(int arr[], int size, int key)
{
    int left = 0;
    int right = size - 1;
    int mid = 0;
    while (left <= right)                        //O(log2 n);
    {
        mid = (left + right) >> 1;
        if (key > arr[mid])
        {
            left = mid + 1;
        }
        else if (key < arr[mid])
        {
            right = mid - 1;
        }
        else
        {
            return mid;
        }
    }
    return -1;
}

时间复杂度：O(log2 n)
空间复杂度：O(n)

int recursion_binary_search(int arr[], int left, int right, int key)      //O(log2 n)
{
    int mid = (left + right) >> 1;
    if (left <= right)
    {
        if (key > arr[mid])
        {
            left = mid + 1;

        }
        else if (key < arr[mid])
        {
            right = mid - 1;
        }
        else
        {
            return mid;
        }
    }
    else
    {
        return - 1;
    }
    return recursion_binary_search(arr, left, right, key);

}

时间复杂度：O(log2 n)
空间复杂度：O(1)