时间复杂度
一段代码、一个程序、一个算法运行所需要的大概时间
这里举几个简单例子
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)
如有疑问和建议请发送到blbagony@163.com
;感谢观看