数据结构与算法分析学习笔记---第一章

#include <iostream>
using namespace std;
/*
问题描述：
设有一组N个数而要确定其中第k个最大者。我们称为选择问题。
算法思路：
思路1：
将N个数的数组进行排序，然后选择第k个数。排序的方法比如冒泡、快速等。
时间复杂度：根据排序算法确定。如果是冒泡，那就是n^2。
思路2：
从初始数组a[]里面取前k个放入一个新的数组b[]，然后对这个数组进行排序（按递减的顺序）。
接着将初始数组a[]里面剩余的元素逐个与b[k-1]比较，如果大于b[k-1]则不处理，
如果小于b[k-1]则将该数放入b中正确的位置（相对于插入排序）。
时间复杂度：待定。
*/

//////////////////////////////////////////////////////////////////////////
//思路1：
//k为第k个数
//n为数组的大小
template <class type>
type seletProblem1(const type source[],int k,int n)
{
type *temp = new type
;
for(int i = 0; i < n; ++i)
{
temp[i] = source[i];		//复制原数组
}

type bb;
for(int i = 0; i < n; ++i)
{
for(int j = i; j < n; ++j)	//注意，这里的j是从i开始的，可以减少循环次数
{
if(temp[i] > temp[j])
{
bb = temp[i];
temp[i] = temp[j];
temp[j] = bb;
}
}
}
bb = temp[k-1];
delete []temp;
temp = NULL;
return bb;
}

//////////////////////////////////////////////////////////////////////////
//思路2：
//k为第k个数
//n为数组的大小
template <class type>
type seletProblem2(const type source[],int k,int n)
{
type *temp = new type[k];
int j = 0;
for(int i = 0; i < k; ++i)
{
temp[i] = 0;
}
temp[0] = source[0];
for(int i = 1; i < k; ++i)
{
j = i;
while(temp[j - 1] > source[i] && j > 0)		//插入排序；
{
temp[j] = temp[j - 1];
--j;
}
temp[j] = source[i];
}
for(int i = k; i < n; ++i)
{
j = k - 1 ;
if(temp[j - 1] > source[i])
{
while(temp[j - 1] > source[i] && j > 0)
{
temp[j] = temp[j - 1];
--j;
}
temp[j] = source[i];
}
}

type bb;

bb = temp[k-1];
delete []temp;
temp = NULL;
return bb;
}
int main()
{
int a[20] = {1,16,3,7,19,2,18,15,4,10,0,14,12,5,13,8,9,6,17,11};
cout <<"First function:"<<endl;
cout <<"The 10th number is :" <<seletProblem1(a,10,20) <<endl;

cout <<"Second function:"<<endl;
cout <<"The 10th number is :" <<seletProblem2(a,10,20) <<endl;
return 0;
}

/*
递归的两个基本法则：
1.基准情形（base case）：你必须总要有某些基准的情形，它们不用递归就能求解。
2.不断推进（make progress）：对于那些需要递归求解的情形，递归调用必须能够总朝着产生基准情形的方向推进。
递归的设计法则：
1.基准情形。
2.不断推进。
3.设计法则。假设所有的递归调用都能运行。
4.合成效益法则：在求解一个问题的同一实例时，切勿在不同的递归调用中做重复性的工作。
*/

//============================================
//错误的递归例子
//不满足 不断推进 的原则。因为当n = 1的时候，一直循环Bad(1)
int Bad(unsigned int n)
{
if(n == 0)
return 0;
else
return Bad(n/3 + 1) + n -1;
}

//============================================
//正确的例子,斐波那契数列
/*
虽然fibonacci数列用递归的方法看起来代码很简单，但是执行效率一点都不高，因为它违背了递归的第四条设计原则。
如：在计算fibonacci(n - 1)的时候，实际上已经计算过fibonacci(n - 2)了,然后在后来弃之不用又计算了一次fibonacci(n - 2);
所以效率很低,可以试着输入一个n = 30,时间很惊人.
*/
int fibonacci(unsigned int n)
{
if(n <= 1)
return 1;
else
return fibonacci(n - 1) + fibonacci(n - 2);
}