简述时间复杂度和空间复杂度

时间复杂度和空间复杂度

费波纳茨数列 二分查找

• 时间复杂度和空间复杂度
  • 时间复杂度
  • 空间复杂度
    • 斐波那契数列
      • 递归版本
      • 非递归版本
    • 冒泡排序
    • 折半查找
      • 递归版本
      • 非递归版本

时间复杂度

一段代码、一个程序、一个算法运行所需要的大概时间

这里举几个简单例子

for (i = 0; i < N; ++i) //时间复杂度为O(N)，比如在无序的数组中找某个元素的函数
    //

for (i = 0; i < N; ++i)
    //
    for (j = 0; j < N; ++j) //时间复杂度为O(N²)，比如冒泡排序函数
        //

空间复杂度

一个程序的空间复杂度是指运行完一个程序所需内存的大小简单说来就是计算当前程序同时最多能创建多少变量

斐波那契数列

什么是斐波那契数列

递归版本

long long Fib(size_t N)
{
    return N>2 ? Fib(N - 1) + Fib(N - 2):N;
}
//时间复杂度为0(2^N)
//空间复杂度为O(N)

这里函数调用类似一个二叉树

这里大概有100层每一个函数都要往下递归调用，所以时间复杂度为O(2^N),空间复杂度为O(N)。

非递归版本

long long FibNoRe(size_t N)
{
    if (N < 2)
        return N;
    else
    {
        long long first = 0, second = 1, ret = 0;
        for (size_t i = 2; i <= N + 1; ++i)
        {
            ret = first + second;
            first = second;
            second = ret;
        }
        return ret;
    }
}

这里时间复杂度是0(N)，空间复杂度为O(1)。

冒泡排序

冒泡排序

void BubbleSort(int* arr, size_t sz)
{
    assert(arr != NULL);
    for (size_t i = 0; i < sz; i++)
    {
        int flag = 0;
        for (size_t j = 0; j < sz -1 - i; j++)
        {
            if (arr[j] > arr[j+1])
            {
                swap(arr[j],arr[j+1]);
                flag ++;
            }
        }
        if (0 == flag)
        {
            return;
        }
    }
}

时间复杂度为O(N²),空间复杂度为O(1)

折半查找

所查找序列必须为`有序``

递归版本

bool BinSearch(int* arr,size_t left, size_t right, int key)
{
    assert(NULL != arr);
    int mid = (left + right) / 2; 
    if (arr[mid] == key){
        return true;
    }
    else if (right <= left)
    {
        return false;
    }
    else if (arr[mid] > key)
    {
        if (key == arr[left])
        {
            return true;
        }
        right = mid - 1;
        BinSearch(arr,left,right,key);
    }
    else if (arr[mid] < key)
    {
        if (key == arr[right])
        {
            return true;
        }
        left = mid + 1 ;
        BinSearch(arr,left,right,key);
    }
}

时间复杂度为O(lgN),空间复杂度0(N)

非递归版本

bool BinSearchNoRe(int* arr,size_t left, size_t right, int key)
{
    assert(NULL != arr);
    while (right > left)
    {
        int mid = (right + left) >> 1;
        if (key == arr[mid])
        {
            return true;
        }
        else if (key > arr[mid])
        {
            if (key == arr[right])
                return true;
            left = mid + 1;
        }
        else if (key < arr[mid])
        {
            if (key == arr[left])
                return true;
            right = mid - 1;
        }
    }
    return false;
}

时间复杂度为O(lgN),空间复杂度0(1) 
如有疑问和建议请发送到[e-mail];感谢观看