数据结构与算法分析 学习笔记（一）

1.3 递归的四个基本法则：

1. 基准情况：所有递归问题最终是靠回归到基准情况解出，即需要一些基准情况，不需要递归即可求出。 
2. 不断推进：不断逼近基准情况，不能在逼近基准情况的过程中卡住，否则之后的情况将会停留在卡顿的位置，造成死循环，导致栈空间溢出。

   //递归输出数字
   #include <iostream>
   using namespace std;
   
   void F(int x)
   {
   	if (x >= 10)
   		F(x / 10);
   	cout << x % 10;
   }
   
   int main(void)
   {
   	F(67893);
   	system("pause");
   	return 0;
   }

   
   
3. 设计法则：即所有的递归调用都能运行。
4. 合成效益法则：在求解一个问题的同一个实例中，切勿在不同的递归调用中做重复性的工作。

   return F(N - 1) + F(N - 2);

   比如这句中，每次在计算F(N - 1)的时候其实都计算了F(N - 2)了，但是每次计算完都被抛弃了，根本没被利用到。

2.3 要分析的问题：

1. 一般来说，若无相反的指定，则所需要计算的判断量是最坏情况下的运算时间。  

2.4 运行时间计算：

1. 法则1——for循环：一次for循环运算的时间至多是for循环内语句运行时间乘以循环的次数（废话）。
2. 法则2——嵌套的for循环：从里向外分析这些循环。在一组嵌套循环中，某一句话执行的次数应该是该语句的运行时间乘以该组（即其外面的for）循环的 大小的乘机。
3. 法则3——顺序语句。时间负责度取决于最大的那个时间复杂度。因为T1(N) + T2(N) = MAX(O(f(N)), O(g(N)))。
4. 法则4——if/else语句。（没啥用）

2.4.3 最大子序列和问题的解

1. 联机算法：只对数据进行一次扫描，一旦数据A[i]被读入并被处理，就不需要再记忆。并且在任何时刻，算法都能给出以读入数据的正确答案（我的理解是for循环进行了整个序列的一部分时，也能给出者一部分中的最大子序列）。

   //联机算法求最大子序列
   #include <iostream>
   using namespace std;
   
   int maxSubSequence(const int a[], int N)
   {
   	int maxSum = 0, thisSum = 0;
   	for (int i = 0; i < N; i++)
   	{
   		thisSum += a[i];
   		if (thisSum > maxSum)
   			maxSum = thisSum;
   		else if (thisSum < 0)
   			thisSum = 0;
   	}
   	return maxSum;
   }
   
   int main()
   {
   	const int a[10] = { 1, -4, 5, 19, -12, 5, -5, 9, -3, 1 };
   	cout << maxSubSequence(a, 10);
   	system("pause");
   }

2.4.4 运行时间中的对数

1. 如果一个算法用常数时间将问题的大小削减为其一部分（一个比例），那么该算法是O(logN)的，如果经过常数时间将问题减少一个常数，则为O(N)。
2. 对分查找：时间复杂度是O(LogN)， （因为进行1步完成了1/2的工作量）

   //对分查找（二分法）
   #include <iostream>
   using namespace std;
   
   int maxSubSequence(const int a[], int N, int x)
   {
   	int left = 0, right = N - 1, middle;
   	while (left <= right)
   	{
   		middle = (left + right) / 2;
   		cout << a[middle] << endl;
   		if (a[middle] < x)
   			left = middle + 1;
   		else if (a[middle] > x)
   			right = middle - 1;
   		else
   			return middle;
   	}
   		return -1;
   }
   
   int main()
   {
   	const int a[10] = {0,1,2,3,4,5,6 ,7};
   	cout << maxSubSequence(a, 8, 2);
   	system("pause");
   }