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

选择问题：

#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[n];
	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);
}