算法笔记2 递归与分治策略

一.递归的概念：直接或间接地调用自身的算法成为递归算法。用函数自身给出定义的函数成为递归函数。

1.1递归解决阶乘函数。定义=(n是非负整数，n的阶乘是n*(n-1)......2*1)

int factorial(int n)
            {
                    if(n == 0)return 1;
                      return n * factorial(n - 1);
              }

 

1.2递归解决Fibonacci（斐波那契）数列。定义=当n〉时，数列的第n项是他前面两项之和，初始值F（0）和F（1）都==1。

int fibonacci(int n)
              {
                      if(n <= 1) return 1;
                    return fibonacci(n - 1) + fibonacci(n - 2);
              }

 

1.3递归解决排列问题。R的全排列定义=当n=1时，全排列Perm（R） = （r），其中r是集合R中唯一的元素；      当n>1时，Perm（R）由（r1）Perm(R1),(r2)Perm(R2),...,(rn)Perm(Rn）构成

template<class Type>
  void Perm(Type list[], int k, int m)//k是待排列数组的起始位，m是结束位。
  {//产生List[k, m]的所有排列
    if(k == m)
    {//只剩下一个元素
      for(int i = 0;i <= m; i++) cout << list[i];
      cout << endl;
    }
    else//还有多个元素待排列，递归产生排列
    {
      for(int i = k;i <=m; i++)//递归调用时，对剩下的k->m之间的数，继续排列。
      {
        Swap(list[k], list[i]);
        Perm(list, k + 1, m);
        Swap(list[k], list[i]);
      }
    }
   
  }
  void Swap(Type &a, Type &b)
  {
    Type temp = a;a = b; b = temp;
  }

 

1.4递归解决Hanoi塔问题。定义=有a,b,c三个塔座，a上自下而上，由大到小叠有n个圆盘。要求将塔座a上的所有圆盘移动b上，并仍按同样顺序叠置。移动过程中遵循的规则：1）每次只能移动一个圆盘2）任何时刻都不允许小的圆盘上有大的3）满足1）2)的前提下，可将圆盘移到a，b,c中任一塔座上。

基本解决思路：移动过程中，奇数次移动，将最小的顺时针（a->b->c->a）移到下一塔座；偶数次移动，最小的不动，其他两个塔座间，次小的移到另一个塔座上。

递归解决思路：n=1时，直接移动。n>1时，设法将n-1个较小的移到c上，然后将剩下的最大的从a移到b上；在设法将c上n-1个较小的从c移到b。

  void hanoi(int n, int a,int b,int c)//a,b,c可看做三个塔座a,b,c;n是n个圆盘
  {
    if（n > 0）
    {
      hanoi(n - 1, a, c, b);
      move(a,b);  //模拟移动动作
      hanoi(n - 1, c, b, a);
    }
  }

 

二.分治法的基本思想：将一个规模为n的问题分解为k个规模较小的子问题，这些子问题，互相独立且与原问题相同。递归地解这些子问题，然后将各子问题的解合并得到原问题的解。

一个分治法，将规模为n的问题分成k个规模为n/m的子问题去解。为方便起见，设分解阀值n0=1，且adhoc解规模为1的问题耗费1个单位时间。另外，再设将原问题分解为k个子问题及用merge将k个子问题的解合并为原问题的解需用f（n）个单位时间。如果用T（n）表示该分治法divide-and-conquer（P）解规模为|P|=n的问题所需的计算时间，则有T（n）=O（1） n=1；T（n）=kT(n/m) + f(n).

它的一般的算法设计模式如下：

divide-and-conquer(P)
  {
    if(|P| <= n0) adhoc(P);
    divide P into small subinstances P1,P2,···,Pk;
    for(int i = 1; i <= k; i++)
    {
      yi = divide-and-conquer(Pi);
      return merge(y1,y2,···，yk);
    }
  }

 

2.1分治法解决二分搜索技术。定义=给定已经排好序的n个元素a[a:n-1],现在要在这n个元素中找出一特定元素x。采用分治策略，最坏情况下用O(logn)时间完成搜索任务。

基本思路：将n个元素分成个数大致相同的两半，取a[n/2]与x比较。如果，x=a[n/2],则找到x，算法终止；如果x<a[n/2],则只要在数组a的左半部继续搜索x；如果x>a[n/2],则只要在数组a的右半部继续搜索x。

template<class Type>
  int BinarySearch(Type a[], const Type&, int n)
  {//在a[0]到a[n-1]中搜索x
    int left = 0; int right = n - 1;
    while(left <= right)
    {
      int middle = (left +　right) / 2;
      if(x == a[middle]) return middle;
          if(x > a[middle]) left = middle + 1;
          else right = middle - 1;
    }
    return -1;//没找到x
  }

 

2.2分治法解决大整数的乘法。定义=需要处理的数无法在计算机硬件对整数的表示范围内直接处理，就必须用软件的方法来实现大整数的算术运算，如果将每两个一位数的乘法或加法看做一步运算，这种方法要进行O(n~2)步才能求出乘积XY。用分治法来设计将更有效地解决这个问题。X=A2~(n/2) + B,Y=C2~（n/2） +D.按此式相乘几乎没有改进算法。写成另外一种形式：XY=AC2~n + ((A-B)(D-C) +AC + BD)2~(n/2) +BD,此式看似复杂，但对于计算机运算来说，效率有了很大改进，T(n)由O(n~2)变为O(n~1.59).

 

2.3分治法解决Strassen矩阵乘法。定义=对于A和B的乘积矩阵C，每计算一个元素c（ij），需要做n次乘法和n-1次加法。因此，求出矩阵C的n~2个元素所需的计算时间是O(n~3)。

分治法解决思路：假设n是2的幂，将矩阵A，B，C中每一矩阵都分块成4个大小相等的子矩阵，每个子矩阵都是n/2 * n/2的方阵,对这个小方阵，改进一下，则2阶方阵用少于原来8次的乘法运算7次，但增加了加、减法的运算次数。用此法改进了算法，T(n)=O(n~2.81).

 

2.4分治法解决合并排序。定义=合并排序算法是用分治策略实现对n个元素进行排序的算法

  基本思想：将待排序元素分成大小大致相同的两个子集合，分别对两个子集合进行排序，最终将排好序的子集合合并成所要求的排好序的集合。

  合并排序算法可递归地描述如下：

    template<class Type>

void MergerSort(Type a[], int left, int right)

{

if(left < right)//至少有2个元素

{

int middle = (left + right)/2;//取中点

MergeSort(a, left, middle);

MergerSort(a, middle + 1, right);

Merge(a, b, left, middle, right);//合并到数组b

Copy(a, b, left, right);//赋值回数组a

}

}

template<class Type>

void Merge(Type c[], Type d[], int n, int m, int r)

{//合并c[n:m]和c[m+1:r]到d[n:r]

int i = n, j = m + 1, k = n;

while((i <= m) && (j <= r))

{

if(c[i] <= c[j]) d[k++] = d[i++];

else d[k++] = c[j++];

}

if(i > m)

for(; j <= r; j++) d[k++] = c[j];

else for(; i <= m; i++) d[k++] = c[i];

}

   

消去递归后的合并排序算法可描述如下：

此处略去。

2.5分治法解决快速排序。定义=快速排序算法是基于分治策略的另一个排序算法那。

  基本思想：对于输入的子数组a[p:r]，按以下三个步骤进行排序。

  1）分解：以a[p]为基准，分数组为两部分，左边的均小于a[p],右边的均大于a[p]。

  2）递归求解：通过递归调用快速排序法分别对a[p:q-1]和a[q+1:r]进行排序。

  3）合并：对两部分排好序后，不需要任何计算，a[p:r]就已经排好序了。

    template<class Type>

void QuickSort(Type a[], int p, int r)

{

if(p < r)

{

int q = Partition(a,p,r);

QuickSort(a, p, q - 1);//对左半段排序

QuickSort(a, q + 1, r);//对右半段排序

}

}

tempplate<class Type>

int Partition(Type a[], int p, int r)

{

int i = p,j = r + 1;

Type x = a[p];

//将小于x的元素交换到左边区域

//将大于x的元素交换到右边区域

while(true)

{

while(a[++i] < x && i < r);

while(a[--j] >);

if(i >= j) break;

Swap(a[i], a[j]);

a[j] = x;

return j;

}

}