devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

计算机算法设计与分析（1-6章 复习笔记）_算法设计与分析章节

作者：花生_TL007 | 2024-04-27 11:28:59

赞

踩

算法设计与分析章节

计算机算法设计与分析

最近发现一些刷题的网站，牛客、力扣，很适合用来熟悉算法和语言知识点。

第1章 算法概述

1.1 算法与程序

算法 是解决问题的一种方法或一个过程。

     严格地说，算法是由若干条指令组成的有穷序列，且满足下述4条性质。

  1. 输入
  2. 输出：至少产生一个量作为输出。
  3. 确定性：每条指令清晰、无歧义。
  4. 有限性：执行次数、时间有限

程序和算法不同。程序不一定满足上述4条性质。

1.2 算法复杂性分析

最坏时间复杂度：O；时间上界；

1.3 NP完全性理论

可在多项式时间内求解的判断问题构成    P类问题。

第2章 递归与分治策略

  分治法的思想：将一个难以直接解决的大问题分解为一些规模较小的相同问题，以便各个击破，分而治之。

2.1 递归的概念

直接或间接调用自身的算法称为递归算法。

【例2-1】阶乘函数。

阶乘函数可递归的定义为：

n!  = 1            ,n=0

    = n(n-1)!   ,  n>0

递归式的第一式给出了这个函数的 初始值，是非递归定义的（直接给出）。每个递归函数都必须有非递归定义的初始值，否则会一直递归下去。

递归式的第二式用较小的自变量的函数值来表示较大自变量的函数值的方法来定义n的阶乘。

用代码表示：

  1. int factorial(int n){
  2.  
  3.     if (n==0)
  4.  
  5.         return 1;
  6.  
  7.     else
  8.  
  9.         return n*factorial(n-1);
  10.  
  11. }

【例2-6】Hanoi塔问题

问题略。

可用递归方法解决：

当n=1时，只要将当前盘子从当前位置塔a放在目标塔b即可。

当n>1时，需要利用塔c作为辅助塔，将n-1个圆盘移动到c上，然后将剩下的最大圆盘移动到b上。即n个圆盘的问题变成两次n-1个圆盘的问题。

用代码表示：

  1. //4个参数依次是剩余数量，起点，终点，中间点
  2.  
  3. void hanoi(int n, char a, char b, char c){
  4.  
  5.     if (n==1)
  6.  
  7.         move(a,b);
  8.  
  9.     else
  10.  
  11.     {
  12.  
  13.        hanoi(n-1,a,c,b);
  14.  
  15.        move(a,b);
  16.  
  17.        hanoi(n-1,c,b,a);
  18.  
  19.     }
  20.  
  21.        
  22.  
  23. }
  24.  
  25. void move(char begin,char end){
  26.  
  27. cout<<begin<<"--->"<<end<<"\n";
  28.  
  29. }

2.2 分治法的基本思想

分治法的基本思想是将一个规模为n的问题分解为k个规模较小的子问题，子问题之间相互独立且与原问题类型相同。

2.3二分搜索技术

二分搜索是分治的典型例子。

给定已排好序（为了简便，设为升序排序）的n个元素a[0,n-1],要在其中找到一特定元素x。

如果用顺序搜索（从头开始依次往后比较），最坏情况需要n次比较；

二分搜索采用分治策略，最坏情况用O（logn）时间完成。

二分搜索的基本思想：将n个元素分成数量基本相同的两份，取a[n/2]与x比较，如果x 等于a[n/2]，则找到，算法终止；如果x<a[n/2]，则x较小，只要在数组a的左半部继续搜索；

如果x>a[n/2]，则x较大，只要在数组a的右半边继续搜索。

  1. /*二分搜索 */
  2.  
  3. template<class Type>
  4.  
  5. int BinarySearch(Type a[],const Type& x, int n){
  6.  
  7.     int left = 0;
  8.  
  9.     int right = n-1;
  10.  
  11.     while(left<=right)
  12.  
  13.     {
  14.  
  15.         int middle = (left+right)/2;
  16.  
  17.         if (x==a[middle])
  18.  
  19.             return middle;
  20.  
  21.         if (x>a[middle])
  22.  
  23.             left = middle+1;
  24.  
  25.         if (x<a[middle])
  26.  
  27.             right = middle-1;
  28.  
  29.     }
  30.  
  31.     return -1;
  32.  
  33. }
  34.  
  35.  
  36.  
  37. //递归形式
  38.  
  39. int  BinarySearch(int a[],int x,int left,int right){
  40.  
  41.     if(left>right)
  42.  
  43.         return -1;
  44.  
  45.     int middle = (left+right)/2;
  46.  
  47.     if (x==a[middle])
  48.  
  49.         return middle;
  50.  
  51.     if(x<a[middle])
  52.  
  53.         return BinarySearch(a,x,left,middle-1);
  54.  
  55.     if(x>a[middle])
  56.  
  57.         return BinarySearch(a,x,middle+1,right);
  58.  
  59. }

2.4 大整数的乘法

有二进制整数X和Y，要计算X * Y，

将X分成两份：A、B,

Y分解两份：C、D

XY = （A*2n/2 +B）(C*2n/2 +D）

  =AC*2n +((A-B)(D-C)+AC+BD)* 2n/2+BD  //利用数学变形，减少乘法次数

2.5 Strassen矩阵乘法

（直接分解再乘并不能减少乘法次数，通过一些变形增加加减法次数，减少乘法次数）。

2.7 合并排序

用分治策略对N个元素进行排序。

基本思想：将待排序的n个元素分成大小大致相同的两个子集，分别对两个子集进行排序，然后再合并两个子集。

  1. template<class Type>
  2.  
  3. void MergeSort(Type a[],Type b[], int left, int right) {
  4.  
  5.     if (left < right) {
  6.  
  7.         int i = (left + right) / 2;
  8.  
  9.         MergeSort(a, b,left, i);
  10.  
  11.         MergeSort(a, b,i + 1, right);
  12.  
  13.         Merge(a, b, left, i, right); //合并到b数组
  14.  
  15.         Copy(a, b, left, right);   //复制回a数组
  16.  
  17.     }
  18.  
  19.  
  20.  
  21. template<class Type>
  22.  
  23. void Merge(Type c[], Type d[], int l, int m, int r) {  //合并c[l:m]和c[m+1:r]到d[l:r]
  24.  
  25.     int i = l, j = m + 1;
  26.  
  27.     int pos = l;
  28.  
  29.     while ((i <= m) && (j <= r)) {
  30.  
  31.         if (c[i] <= c[j])
  32.  
  33.             d[pos++] = c[i++];
  34.  
  35.         else
  36.  
  37.             d[pos++] = c[j++];
  38.  
  39.         if (i > m) {    //第1个数组放完了，直接把第2个数组剩下的放到d
  40.  
  41.             for (int q = j; q <= r; q++)
  42.  
  43.                 d[pos++] = c[q];
  44.  
  45.         }
  46.  
  47.         if (j > r) {      //第2个数组放完了，直接把第1个数组剩下的放到d
  48.  
  49.             for (int q = i; q <= m; q++)
  50.  
  51.                 d[pos++] = c[q];
  52.  
  53.         }
  54.  
  55.     }
  56.  
  57. }
  58.  
  59.  
  60.  
  61. template<class Type>
  62.  
  63. void Copy(Type a[], Type b[], int left, int right) {
  64.  
  65.     for (int i = left; i <= right; i++)
  66.  
  67.         a[i] = b[i];
  68.  
  69. }

2.8 快速排序

对于数组a[p:r]按三个 步骤排序：

1. 分解（Divide）：以a[p]为基准元素，a[p:r]分解为3段：a[p:q-1].a[q]]和a[q+1:r]

使得a[p:q-1]中的元素都<=a[q] , a[q+1:r]>=a[q],下标q在划分过程中确定。

2.递归求解（Conquer）：使用递归对a[p:q-1]和a[q+1:r]进行排序。

3.合并（Merge）：a[p:q-1]和a[q+1:r]排序好后，不需要进行操作就已经排好序了。

  1. template<class Type>
  2.  
  3. void QuickSort(Type a[],int p,int r){
  4.  
  5.     if(p<r){
  6.  
  7.         int q = Partition(a,p,r);
  8.  
  9.         QuickSort(a,p,q-1);
  10.  
  11.         QuickSort(a,q+1,r);
  12.  
  13.     }
  14.  
  15. }
  16.  
  17.  
  18.  
  19. template<class Type>
  20.  
  21. int Partition(Type a[],int p, int r){
  22.  
  23.     int i=p+1, j =r;
  24.  
  25.     Type x = a[p];
  26.  
  27.     while(true){
  28.  
  29.         while(a[i]<x && i<r)   //直到找到a[i]>=x
  30.  
  31.             i++;
  32.  
  33.         while(a[j]>x)           //直到找到a[j]<=x
  34.  
  35.             j--;
  36.  
  37.         if(i>=j)
  38.  
  39.             break;
  40.  
  41.         swap(a[i],a[j]);    //交换a[i],a[j],使得左边都小于x，右边>x
  42.  
  43.     }
  44.  
  45.    swap(a[p],a[j]);
  46.  
  47.     return j;
  48.  
  49. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/496516
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号