老師推薦：
2024年計算機等級考試易考寶典軟件
2024年計算機等級考試網絡輔導課程
2024年計算機等級考試輔導用書
2024年計算機等級考試易考套餐

常用算法設計方法

寧波高等專科學校電子系 周文革

    要使計算機能完成人們預定的工作，首先必須為如何完成預定的工作設計一個算法，然后再根據算法編寫程序。計算機程序要對問題的每個對象和處理規則給出正確詳盡的描述，其中程序的數據結構和變量用來描述問題的對象，程序結構、函數和語句用來描述問題的算法。算法數據結構是程序的兩個重要方面。

    算法是問題求解過程的精確描述，一個算法由有限條可完全機械地執行的、有確定結果的指令組成。指令正確地描述了要完成的任務和它們被執行的順序。計算機按算法指令所描述的順序執行算法的指令能在有限的步驟內終止，或終止于給出問題的解，或終止于指出問題對此輸入數據無解。

    通常求解一個問題可能會有多種算法可供選擇，選擇的主要標準是算法的正確性和可靠性，簡單性和易理解性。其次是算法所需要的存儲空間少和執行更快等。

    算法設計是一件非常困難的工作，經常采用的算法設計技術主要有迭代法、窮舉搜索法、遞推法、貪婪法、回溯法、分治法、動態規劃法等等。另外，為了更簡潔的形式設計和藐視算法，在算法設計時又常常采用遞歸技術，用遞歸描述算法。

一、迭代法

    迭代法是用于求方程或方程組近似根的一種常用的算法設計方法。設方程為f(x)=0，用某種數學方法導出等價的形式x=g(x)，然后按以下步驟執行：

（1）       選一個方程的近似根，賦給變量x₀；

（2）       將x₀的值保存于變量x1，然后計算g(x₁)，并將結果存于變量x₀；

（3）       當x₀與x₁的差的絕對值還小于指定的精度要求時，重復步驟（2）的計算。

    若方程有根，并且用上述方法計算出來的近似根序列收斂，則按上述方法求得的x₀就認為是方程的根。上述算法用C程序的形式表示為：

【算法】迭代法求方程的根

{     x0=初始近似根；

       do {

              x1=x0；

              x0=g(x1)；    /*按特定的方程計算新的近似根*/

              } while ( fabs(x0-x1)>Epsilon)；

       printf(“方程的近似根是%f\n”，x0)；

}

迭代算法也常用于求方程組的根，令

              X=（x₀，x₁，…，x_n-1）

設方程組為：

              x_i=g_i(X)         (I=0，1，…，n-1)

則求方程組根的迭代算法可描述如下：

【算法】迭代法求方程組的根

       {     for (i=0;i

                     x[i]=初始近似根;

              do {

                     for (i=0;i

                            y[i]=x[i];

                     for (i=0;i

                            x[i]=gi(X);

                     for (delta=0.0,i=0;i

                            if (fabs(y[i]-x[i])>delta)        delta=fabs(y[i]-x[i])；

                     } while (delta>Epsilon)；

              for (i=0;i

                     printf(“變量x[%d]的近似根是 %f”，I，x[i])；

              printf(“\n”)；

       }

       具體使用迭代法求根時應注意以下兩種可能發生的情況：

（1）       如果方程無解，算法求出的近似根序列就不會收斂，迭代過程會變成死循環，因此在使用迭代算法前應先考察方程是否有解，并在程序中對迭代的次數給予限制；

（2）       方程雖然有解，但迭代公式選擇不當，或迭代的初始近似根選擇不合理，也會導致迭代失敗。

二、窮舉搜索法

       窮舉搜索法是對可能是解的眾多候選解按某種順序進行逐一枚舉和檢驗，并從眾找出那些符合要求的候選解作為問題的解。

【問題】       將A、B、C、D、E、F這六個變量排成如圖所示的三角形，這六個變量分別取[1，6]上的整數，且均不相同。求使三角形三條邊上的變量之和相等的全部解。如圖就是一個解。

    程序引入變量a、b、c、d、e、f，并讓它們分別順序取1至6的證書，在它們互不相同的條件下，測試由它們排成的如圖所示的三角形三條邊上的變量之和是否相等，如相等即為一種滿足要求的排列，把它們輸出。當這些變量取盡所有的組合后，程序就可得到全部可能的解。細節見下面的程序。

【程序1】

# include

void main()

{     int a,b,c,d,e,f;

       for (a=1;a<=6;a++)      

              for (b=1;b<=6;b++)              {

                     if (b==a)        continue;

                     for (c=1;c<=6;c++)              {

                            if (c==a)||(c==b)    continue;

                            for (d=1;d<=6;d++)              {

                                   if (d==a)||(d==b)||(d==c)      continue;

for (e=1;e<=6;e++)              {

       if (e==a)||(e==b)||(e==c)||(e==d) continue;

f=21-(a+b+c+d+e);

if ((a+b+c==c+d+e))&&(a+b+c==e+f+a))   {

printf(“%6d,a);

       printf(“%4d%4d”,b,f);

       printf(“%2d%4d%4d”,c,d,e);

       scanf(“%*c”);

}

                                          }

                                   }

                            }

                     }

              }

    按窮舉法編寫的程序通常不能適應變化的情況。如問題改成有9個變量排成三角形，每條邊有4個變量的情況，程序的循環重數就要相應改變。

       對一組數窮盡所有排列，還有更直接的方法。將一個排列看作一個長整數，則所有排列對應著一組整數。將這組整數按從小到大的順序排列排成一個整數，從對應最小的整數開始。按數列的遞增順序逐一列舉每個排列對應的每個整數，這能更有效地完成排列的窮舉。從一個排列找出對應數列的下一個排列可在當前排列的基礎上作部分調整來實現。倘若當前排列為1，2，4，6，5，3，并令其對應的長整數為124653。要尋找比長整數124653更大的排列，可從該排列的最后一個數字順序向前逐位考察，當發現排列中的某個數字比它前一個數字大時，如本例中的6比它的前一位數字4大，這說明還有對應更大整數的排列。但為了順序從小到大列舉出所有的排列，不能立即調整得太大，如本例中將數字6與數字4交換得到的排列126453就不是排列124653的下一個排列。為了得到排列124653的下一個排列，應從已經考察過的那部分數字中選出比數字大，但又是它們中最小的那一個數字，比如數字5，與數字4交換。該數字也是從后向前考察過程中第一個比4大的數字。5與4交換后，得到排列125643。在前面數字1，2，5固定的情況下，還應選擇對應最小整數的那個排列，為此還需將后面那部分數字的排列順序顛倒，如將數字6，4，3的排列順序顛倒，得到排列1，2，5，3，4，6，這才是排列1，2，4，6，5，3的下一個排列。按以上想法編寫的程序如下。

【程序2】

# include

# define SIDE_N    3

# define LENGTH  3

# define VARIABLES     6

int A,B,C,D,E,F;

int *pt[]={&A,&B,&C,&D,&E,&F};

int *side[SIDE_N][LENGTH]={&A,&B,&C,&C,&D,&E,&E,&F,&A};

int side_total[SIDE_N];

main{}

{     int i,j,t,equal;

       for (j=0;j

              *pt[j]=j+1;

       while(1)

       {     for (i=0;i

              {     for (t=j=0;j

                            t+=*side[i][j];

                     side_total[i]=t;

              }

              for (equal=1,i=0;equal&&i

                     if (side_total[i]!=side_total[i+1]     equal=0;

              if (equal)

              {     for (i=1;i

                            printf(“%4d”,*pt[i]);

                     printf(“\n”);

                     scanf(“%*c”);

              }

              for (j=VARIABLES-1;j>0;j--)

                     if (*pt[j]>*pt[j-1])  break;

              if (j==0)  break;

              for (i=VARIABLES-1;i>=j;i--)

                     if (*pt[i]>*pt[i-1])  break;

              t=*pt[j-1];* pt[j-1] =* pt[i]; *pt[i]=t;

              for (i=VARIABLES-1;i>j;i--,j++)

              {     t=*pt[j]; *pt[j] =* pt[i]; *pt[i]=t;   }

       }

}

    從上述問題解決的方法中，最重要的因素就是確定某種方法來確定所有的候選解。下面再用一個示例來加以說明。

【問題】       背包問題

    問題描述：有不同價值、不同重量的物品n件，求從這n件物品中選取一部分物品的選擇方案，使選中物品的總重量不超過指定的限制重量，但選中物品的價值之和最大。

    設n個物品的重量和價值分別存儲于數組w[ ]和v[ ]中，限制重量為tw。考慮一個n元組（x₀，x₁，…，x_n-1），其中x_i=0 表示第i個物品沒有選取，而x_i=1則表示第i個物品被選取。顯然這個n元組等價于一個選擇方案。用枚舉法解決背包問題，需要枚舉所有的選取方案，而根據上述方法，我們只要枚舉所有的n元組，就可以得到問題的解。

    顯然，每個分量取值為0或1的n元組的個數共為2ⁿ個。而每個n元組其實對應了一個長度為n的二進制數，且這些二進制數的取值范圍為0～2ⁿ-1。因此，如果把0～2ⁿ-1分別轉化為相應的二進制數，則可以得到我們所需要的2ⁿ個n元組。

【算法】

maxv=0;

for (i=0;i<2ⁿ;i++)

{     B[0..n-1]=0;

       把i轉化為二進制數，存儲于數組B中;

       temp_w=0;

       temp_v=0;

       for (j=0;j

       {     if (B[j]==1)

              {     temp_w=temp_w+w[j];

                     temp_v=temp_v+v[j];

              }

              if ((temp_w<=tw)&&(temp_v>maxv))

              {     maxv=temp_v;

                     保存該B數組；

              }

       }

}

三、遞推法

       遞推法是利用問題本身所具有的一種遞推關系求問題解的一種方法。設要求問題規模為N的解，當N=1時，解或為已知，或能非常方便地得到解。能采用遞推法構造算法的問題有重要的遞推性質，即當得到問題規模為i-1的解后，由問題的遞推性質，能從已求得的規模為1，2，…，i-1的一系列解，構造出問題規模為I的解。這樣，程序可從i=0或i=1出發，重復地，由已知至i-1規模的解，通過遞推，獲得規模為i的解，直至得到規模為N的解。

【問題】       階乘計算

    問題描述：編寫程序，對給定的n（n≦100），計算并輸出k的階乘k！（k=1，2，…，n）的全部有效數字。

    由于要求的整數可能大大超出一般整數的位數，程序用一維數組存儲長整數，存儲長整數數組的每個元素只存儲長整數的一位數字。如有m位成整數N用數組a[ ]存儲：

       N=a[m]×10^m-1+a[m-1]×10^m-2+ … +a[2]×10¹+a[1]×10⁰

    并用a[0]存儲長整數N的位數m，即a[0]=m。按上述約定，數組的每個元素存儲k的階乘k！的一位數字，并從低位到高位依次存于數組的第二個元素、第三個元素……。例如，5！=120，在數組中的存儲形式為：

    首元素3表示長整數是一個3位數，接著是低位到高位依次是0、2、1，表示成整數120。

       計算階乘k！可采用對已求得的階乘(k-1)！連續累加k-1次后求得。例如，已知4！=24，計算5！，可對原來的24累加4次24后得到120。細節見以下程序。

# include

# include

# define  MAXN   1000

void  pnext(int a[ ],int k)

{     int *b,m=a[0],i,j,r,carry;

       b=(int * ) malloc(sizeof(int)* (m+1));

       for ( i=1;i<=m;i++)        b[i]=a[i];

       for ( j=1;j<=k;j++)

       {     for ( carry=0,i=1;i<=m;i++)

              {     r=(i

                     a[i]=r%10;

                     carry=r/10;

              }

              if (carry)  a[++m]=carry;

       }

       free(b);

       a[0]=m;

}

void  write(int *a,int k)

{     int i;

       printf(“%4d！=”,k);

       for (i=a[0];i>0;i--)

              printf(“%d”,a[i]);

printf(“\n\n”);

}

void main()

{     int a[MAXN],n,k;

       printf(“Enter the number n:  “);

       scanf(“%d”,&n);

       a[0]=1;

       a[1]=1;

       write(a,1);

       for (k=2;k<=n;k++)

       {     pnext(a,k);

              write(a,k);

              getchar();

       }

}

四、遞歸

       遞歸是設計和描述算法的一種有力的工具，由于它在復雜算法的描述中被經常采用，為此在進一步介紹其他算法設計方法之前先討論它。

       能采用遞歸描述的算法通常有這樣的特征：為求解規模為N的問題，設法將它分解成規模較小的問題，然后從這些小問題的解方便地構造出大問題的解，并且這些規模較小的問題也能采用同樣的分解和綜合方法，分解成規模更小的問題，并從這些更小問題的解構造出規模較大問題的解。特別地，當規模N=1時，能直接得解。

【問題】       編寫計算斐波那契（Fibonacci）數列的第n項函數fib（n）。

       斐波那契數列為：0、1、1、2、3、……，即：

              fib(0)=0;

              fib(1)=1;

              fib(n)=fib(n-1)+fib(n-2)        （當n>1時）。

寫成遞歸函數有：

int fib(int n)

{     if (n==0)        return  0;

       if (n==1)        return  1;

       if (n>1)          return  fib(n-1)+fib(n-2);

}