递归与分治

一、算法思想

递归(Recurrence):计算机、数学、运筹等领域经常使用的最强大的解决问题的方法之一，它用一种简单的方式来解决那些用其他方法解起来可能很复杂的问题，也就是说有些问题用递归算法来求解，则变得简单，而且容易理解。

递归的基本思想:把一个问题划分为一个或多个规模更小的子问题，然后用同样的方法解规模更小的子问题。

递归算法的基本设计步骤：

1.找到问题的初始条件(递归出口)，即当问题规模小到某个值时，该问题变得很简单，能够直接求解。

2.设计一个策略，用于将一个问题划分为一个或多个一步步接近递归出口的相似的规模更小的子问题。

3.将所解决的各个小问题的解组合起来，即可得到原问题的解。

设计递归算法时需注意以下几个问题:

1.如何使定义的问题规模逐步缩小，而且始终保持同一问题类型?

2.每个递归求解的问题其规模如何缩小?

3.多大规模的问题可作为递归出口?

4.随着问题规模的缩小，能到达递归出口吗?

Hanoi问题

给定三根柱子，其中A柱子从大到小套有n个圆盘，问题是如何借助B柱子，将圆盘从A搬到C。

和尚搬圆盘的游戏规则如下：

1.一次只能搬动一个圆盘;

2.不能将大圆盘放在小圆盘上面。

用递归来做，具体步骤如下：

把a上面n-1个盘子看做一个整体，这样a上面就剩下两个盘子了(n，n-1)。

 如果只有一个盘子 直接将a柱子上的盘子移到C柱上

否则     先将a柱上的n-1盘子移到B柱上，再将第n个盘子移动到C柱上。

要想完成将a柱上的n-1个盘子移到B柱上，遇到了刚才同样的问题，即将n-1个盘子从a柱借由c柱将n-2个盘子的先移到C柱上，再将最下面的第n-1个盘子移到B柱上。

/*
Haboi问题
用递归来做 
Hanoi(n,A,B,C)
    if n=1 then move(1,A,C)
    else
      Hanoi(n-1,A,C,B)
      move(n,A,C)
      Hanoi(n-1,B,A,C)
*/ 

#include<iostream>
using namespace std;

void Hanoi(int n,char a,char b,char c)
{
    if(n==1)  //如果只有一个盘子，直接a->c 
    {
        cout << n << ":" << a <<"->" << c << endl;
    }
    else
    {
        //把n-1个盘子借助于c从a移动到b
        Hanoi(n-1,a,c,b);
         cout << n << ":" << a <<"->" << c << endl;
         //把n-1个盘子借助于借助于a从b移动到c
         Hanoi(n-1,b,a,c); 
    }
}

int main()
{
    int num;
    cout << "盘子数：";
    cin >> num;
    Hanoi(num,'a','b','c');
    return 0;
}

时间复杂度分析：

二、选择排序

基本思想就像排列你手中的扑克牌一样:

■把所有牌摊开，放在桌上，伸出你的左手，开始为空，准备拿牌;

■将桌上最小的牌拾起， 并把它插到左手所握牌的最右边。

■重复步骤(2) ，直到桌.上所有牌都拿在你的左手上，此时左手上所握的牌便是排好序的牌。

 

/*
SelectSort
从头到尾扫描序列，找出最小的一个元素，和第一个元素交换，
接着从剩下的元素中继续这种选择和交换
最终得到一个有序序列 
*/

#include<iostream>
using namespace std;

void swap(int *a,int *b)  //交换两个数的值 
{
    int temp=*a;
    *a=*b;
    *b=temp;
}

void selection_sort(int a[],int len)
{
    int i,j;
    for(i=0;i<len;i++)
    {
        int min=i;
        for(j=i+1;j<len;j++)  //走访未排序的元素
        if(a[j]<a[min])   //找到目前最小值 
        min=j;   //记录最小值 
        swap(&a[min],&a[i]);  //交换 
    }
}

int main()
{
    int num[100];
    int n;
    cout << "输入元素个数：";
    cin >> n;
    for(int i=0;i<n;i++)
    cin >> num[i];
    cout << "排序后的结果为：" << endl;
    selection_sort(num,n);
    for(int j=0;j<n;j++)
    cout << num[j] << ' ';
    cout << endl;
    return 0;
 } 

选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。

三、生成排列

问题是生成{,2..,n}的所有n!个排列

想法1:固定位置放元素

假设我们能够生成n-1个元素的所有排列，我们可以得到如下算法:

1.生成元素{2,3.,n} 的所有排列，并且将元素1放到每个排列的开头;

2.接着，生成元素{1,3...,n}的所有排列，并将数字2放到每个排列的开头;

3.重复这个过程，直到元素{2,3,..,n-1}的所有排列都产生，并将元素n放到每个排列的开头。

/*
permutstion
递归生成全排列问题 
*/

#include<iostream>
using namespace std;

void swap(int *a,int *b)
{
    int temp=*a;
    *a=*b;
    *b=temp;
}

void print_array(int a[],int len)
{
    for(int i=0;i<len;i++)
    cout << a[i] <<' ';
    cout << endl;
 } 
 
void permutation(int num[],int p,int q)
{
    if(p==q)
    print_array(num,q+1);
    else
    {
        for(int j=p;j<=q;j++)
        {
            swap(&num[p],&num[j]);
            permutation(num,p+1,q);
            swap(&num[p],&num[j]);
        }
    }
}

int main()
{
    int n;
    cout << "n=";
    cin >> n;
    int array[100];
    for(int i=0;i<n;i++)
    array[i]=i+1;
    //print_array(array,n);
    permutation(array,0,n-1);
    return 0;
}