时间空间复杂度（二分查找和斐波那契数列）

时间复杂度 ：

时间复杂度就是函数执行的基本操作次数（运算次数）

在实际中，我们通常考量的是这个函数的最坏运行情况，即最大运行时间。

使用 O 来标记最坏运行情况的渐进上界—— O的渐进表示法

需要注意的是 递归算法的时间复杂度：递归总次数*每次递归数

空间复杂度 ：

最多占用的空间

同样使用O的渐进表示法

递归的空间复杂度：每次递归所开空间*深度

以二分查找（折半查 找为例）

#include <iostream>
#include <assert.h>
using namespace std;

//二分查找
int BinarySearch1(int a[], int key,int n)//非递归
//时间复杂度 O(log2 N)  空间复杂度O(1)
{
	assert(n >= 0);
	int left=0;
	int right=n;
	while (left <= right)
	{
		int mid = (left&right) + ((left^right) >> 1);

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

		}
		else
			return a[mid];
	}
	return NULL;
	
}
//递归
//时间复杂度:O(log2 N)空间复杂度：O(log2N )。
bool BinarySearch2(int a[], int key,int left, int right)
{
	int mid = (left+right)>>1;
	if (left <= right && key == a[mid])
		return true;
	else if (key != a[mid])
		return false;

	if(key < a[mid])
		BinarySearch2(a, key,left, mid);
	if (key>a[mid])
		BinarySearch2(a, key, mid, right);

}


void test1()
{
int a[] = { 1, 2, 3, 4, 5, 6 };
cout << BinarySearch1(a, 8, sizeof(a) / sizeof(a[0])) << endl;
//cout << BinarySearch2(a, 0, 0, sizeof(a) / sizeof(a[0])) << endl;
}




//斐波那契
//递归    时间复杂度O(2^N) 空间复杂度O(N)
int fib1(size_t n)
{
	return n < 2 ? n : fib1(n - 1) + fib1(n -2);
}
//非递归  时间复杂度O（N）空间复杂度O(1)
long long fibNonR(size_t n)
{
	size_t a1 = 0, a2 = 1, a3 = n;
	for (long long i = 2; i <= n;++i)
	{
		a3 = a1 + a2;
		a1 = a2;
		a2 = a3;
	}
	return a3;
}

void test2()
{
	printf("%lld", fib1(10));
	//printf("%lld", fibNonR(10));
	getchar();
}

int main()
{
	test1();
	//test2();
	getchar();
	return 0;
}