分治规模

分治规模

递归：一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，

它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。

【1】求n!的阶乘

(1)循环实现

int fun(int n)

{

     int sum = 1;

     for (int i = 1; i <= n; ++i)

     {

          sum = sum * i;

     }

     return sum;

}

（2）递归实现

int fac(int n )

{

  if(n<1)

{

return 1;

}

return fac(n-1)*n;

}

【2】计算第n位斐波那契数列

//计算第n位斐波那契数列

【1】有重复性 

（1）循环实现

int fun(int n)

{

     int a = 1, b = 1, c = 1;

     for (int i = 3; i <= n; ++i)

     {

          c = a + b;

          b = a;

          a = c;

     }

     return c;

}

（2）递归实现

int num = 0;

int fac(int n)                

{

num +=1;

if(n <= 2) return 1;

else return fac(n-1) + fac(n-2);

}

int main()

                                 {

int n = 5;

int sum = fac(n);

cout<<sum<<endl;

cout<<num<<endl;

return 0;

}

{2}消除了重复性

int fac(int n, int a,int b)                                                 

{

     if (n <= 2)return a;

     else return fac(n - 1, a + b, a);

}

int fun(int n)

{

     int a = 1, b = 1;

     return fac(n, a, b);

}

int main()

{

     for (int i = 0; i <= 5; ++i)

     {

          cout << i << "=>" << fun(i) << endl;

     }

     return 0;

}

【3】二分查找

[1]一般方法实现（若有连续的重复的）

int findvalue(const int *ar, const int n, const int x)

{

     int pos = -1; 

     if (ar == NULL || n < 1) return pos;

     int left = 0;

     int right = n - 1;

     while (left <= right)

     {

          int mid = (right - left + 1) / 2 + left;

          if (ar[mid] == x)

          {

              while (mid>left&&ar[mid - 1] == x)

              {

                   --mid;

              }

          

              pos = mid;

              break;

          }

          if (x < ar[mid]){ right = mid - 1; }

          else{ left = mid + 1; }

     }

     return pos;

}

int main()

{

     int ar[] = { 12, 23, 34, 45, 56, 67, 78, 89, 90,100, 110, 120 };

     int n = sizeof(ar) / sizeof(ar[0]);

     int x;

     int pos;

     cin >> x;

    pos = findvalue(ar,n,x);      //pos = searchvalue();

     cout << pos << endl;

}

【2】用递归来实现 

static int search(const int *ar, int left, int right, int  x)

{

     int pos = -1;

     if (left <= right)

     {

          int mid = (right - left + 1) / 2 + left;

          if (x < ar[mid])

          {

              pos = search(ar, left, mid - 1, x);

          }

          else if (x > ar[mid])

          {

              pos = search(ar, mid + 1, right, x);

          }

          else

          {

              while (mid > left && ar[mid - 1] == x)  --mid;

              pos = mid;

          }

     }

     return pos;

}

int searchvalue(const int *ar, int n, int x)

{

     if (ar == NULL || n < 1) return -1;

     else return search(ar, 0, n - 1, x);

}

int main()

{

     int ar[] = { 12, 23, 34, 45, 56, 67, 78, 89, 90,  100, 110, 120 };

     int n = sizeof(ar) / sizeof(ar[0]);cout << searchvalue(ar, n, 23) << endl;

}

//一次实现

int searchvalue(const int val, const int ar[], int len,  int index)

{

     if (index<0 || index>len - 1)return -1;

     if (val == ar[index])

     {

          return index;

     }

     else if (val > ar[index])

     {

          return searchvalue(val, ar, len, index + (len -  index) / 2);

     }

     else

     {

          return searchvalue(val, ar, len, index / 2);

     }

}int main()

{

     int ar[] = { 12, 23, 34, 45, 56, 67, 78, 89, 90,  100, 110, 120 };

    cout << searchvalue(45, ar, n, n / 2) << endl;

    return 0;

     }     

【4】打印数据

void PrintAr(const int *ar, int n)

{

     if (ar == NULL || n < 1) return;

     for (int i = 0; i<n; ++i)

     {

          cout << ar[i] << " ";

     }

     cout << endl;

}

int main()

{

     int ar[] = { 12, 23, 34 };

     int n = sizeof(ar) / sizeof(ar[0]);

     PrintAr(ar, n);

     return 0;

}

(2)循环改为递归式打印

void Print(const int *ar, int n)

{

     if (n > 0)

     {

          Print(ar, --n);

          cout << ar[n] << " ";

     }

}

void PrintAr(const int *ar, int n)

{

     if (ar == NULL || n < 1) return;

     Print(ar, n);

     cout << endl;

}

int main()

{

     int ar[] = { 12, 23, 34 };

     int n = sizeof(ar) / sizeof(ar[0]);