演算法是在內

『壹』 求一個程序把幾種排序演算法包含在內，有一個直觀的比較。主要是能運行的完整代碼。。C語言,C++都可以

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<math.h>
#include<string.h>
#include<windows.h>
#pragma comment(lib,"winmm.lib")
#define TRUE 1
#define FALSE 0
#define SNUM 7
int comp[SNUM]={0},move[SNUM]={0};
void Insert(int a[],int n){//直接插入排序
int i,j,temp;
for(i=1;i<n;i++){
comp[0]++;
if(a[i]<a[i-1]){
temp=a[i];move[0]++;
for(j=i-1;j>=0&&temp<a[j];j--){
a[j+1]=a[j];move[0]++;comp[0]++;
}
a[j+1]=temp;move[0]++;
}
}
}
void Shell(int a[],int n){//希爾排序
int i,j,temp,dk;
for(dk=n/2;dk>0;dk=dk/2)
for(i=dk;i<n;i++){
comp[1]++;
if(a[i]<a[i-dk]){
temp=a[i];move[1]++;
for(j=i-dk;j>=0&&temp<a[j];j-=dk)
{a[j+dk]=a[j];move[1]++;comp[0]++;}
a[j+dk]=temp;move[1]++;
}
}
}
void Bubble(int a[],int n){ //冒泡排序
int temp,i,j;
int NOSWAP;
for(i=n-1;i>0;--i){
NOSWAP=TRUE;
for(j=0;j<i;j++){
comp[2]++;
if(a[j]>a[j+1]){
temp=a[j];a[j]=a[j+1];
a[j+1]=temp;NOSWAP=FALSE;
move[2]+=3;
}
}
if(NOSWAP)break;
}
}
void Quick(int a[],int low,int high){ //快速排序
int temp,L=low,H=high;
if(low<high){
temp=a[low];move[3]++; //用區間的第1個記錄作為基準
while(low<high){
while(low<high&&a[high]>=temp)
{high--;comp[3]++;}
a[low]=a[high];move[3]++;
while(low<high&&a[low]<=temp)
{low++;comp[3]++;}
a[high]=a[low];move[3]++;
}
a[low]=temp; move[3]++; //low的值相當於pivotkey
Quick(a,L,low-1);//對左區間遞歸排序
Quick(a,low+1,H);//對右區間遞歸排序
}
}
void SelectSort(int a[],int n){ //簡單選擇排序
int i,j,k,tmp;
for(i=0;i<n-1;i++){
k=i;
for(j=i+1;j<n;j++){
comp[4]++;
if(a[j]<a[k])k=j;
}
if(i!=k){
tmp=a[i];a[i]=a[k];
a[k]=tmp;move[4]+=3;
}
}
}
void HeapAdjust(int a[],int s,int m){ //使H.r[s..m]成為一個大頂堆
int j,tmp;
tmp=a[s]; move[5]++;
for(j=2*s+1;j<=m;j*=2){ //j為s的左孩子，所以j=2*s+1
comp[5]++;
if(j<m&&a[j]<a[j+1])++j;
if(tmp>=a[j]) break;
a[s]=a[j];move[5]++;
s=j;
}
a[s]=tmp;
}
void HeapSort(int a[],int n){ //堆排序
int i,tmp;
for(i=n/2-1;i>=0;--i)
//從最後一個元素的下標j(=n-1)=2*i+1開始，所以i=n/2-1
HeapAdjust(a,i,n-1); //將初始待排記錄建成一個大頂堆
for(i=n-1;i>0;--i){
tmp=a[i];a[i]=a[0];a[0]=tmp;
move[5]+=3;
HeapAdjust(a,0,i-1);
}
}
void Merge(int a[],int low,int m,int high)
{//將兩個有序的子序列a[low..m)和a[m+1..high]歸並成一個
//有序的子序列a[low..high]
int *b; //b為輔助數組基址
b=(int*)malloc((high-low+1)*sizeof(int));
for(int i=low,j=m+1,k=0;i<=m&&j<=high;++k){
//兩子序列均非空時取其小者輸出到b[k]上
if(a[j]<a[i])b[k]=a[j++];
else b[k]=a[i++];
move[6]++;comp[6]++;
}
while(i<=m) //若第1個子序列非空，則復制剩餘記錄到b中
{b[k++]=a[i++];move[6]++;}
while(j<=high) //若第2個子序列非空，則復制剩餘記錄到b中
{b[k++]=a[j++];move[6]++;}
for(k=0,i=low;i<=high;k++,i++,move[6]++)
a[i]=b[k];//歸並完成後將結果復制回a[low..high]
free(b);
}
void MergeSort(int a[],int low,int high){
//用分治法對a[low..high]進行二路歸並排序
int mid;
if(low<high){//區間長度大於1
mid=(low+high)/2;//分解
MergeSort(a,low,mid);//遞歸地對a[low..mid]排序
MergeSort(a,mid+1,high); //遞歸地對a[mid+1..high]排序
Merge(a,low,mid,high);//組合，將兩個有序區歸並為一個有序區
}
}
_int64 Runtime(int *b,int n,char TYPE){
int *a;
LARGE_INTEGER ft;
_int64 begin_t,end_t;
a=(int*)malloc(n*sizeof(int));
if(!a)exit(0);
for(int i=0;i<n;i++)a[i]=b[i];
QueryPerformanceCounter(&ft);
begin_t=ft.QuadPart;
switch(TYPE){
case'I':Insert(a,n);break;
case'S':Shell(a,n);break;
case'B':Bubble(a,n);break;
case'Q':Quick(a,0,n-1);break;
case'J':SelectSort(a,n);break;
case'H':HeapSort(a,n);break;
case'2':MergeSort(a,0,n-1);
}
QueryPerformanceCounter(&ft);
end_t=ft.QuadPart;
free(a);
return end_t-begin_t;
}
void Disp(int n,double e[]){
static num;
int s[SNUM];
for(int i=0;i<SNUM;i++)s[i]=comp[i]+move[i];
printf(" 第%d次測試結果 \n",num++);
printf("-----------------------------------------------------------\n");
printf("| 排序演算法 | 比較次數 | 移動次數 | 總次數 | 耗費時間 | \n");
printf("-----------------------------------------------------------\n");
printf("|直接插入排序| %10u %10u %10u %6.2fms\n",comp[0],move[0],s[0],e[0]);
printf("| 希爾排序 | %10u %10u %10u %6.2fms\n",comp[1],move[1],s[1],e[1]);
printf("| 起泡排序 | %10u %10u %10u %6.2fms\n",comp[2],move[2],s[2],e[2]);
printf("| 快速排序 | %10u %10u %10u %6.2fms\n",comp[3],move[3],s[3],e[3]);
printf("|簡單選擇排序| %10u %10u %10u %6.2fms\n",comp[4],move[4],s[4],e[4]);
printf("| 堆排序 | %10u %10u %10u %6.2fms\n",comp[5],move[5],s[5],e[5]);
printf("|2-路歸並排序| %10u %10u %10u %6.2fms\n",comp[6],move[6],s[6],e[6]);
printf("-----------------------------------------------------------\n");
}
void main()
{
int i,n,*b;
LARGE_INTEGER ft;
_int64 k,j,tmp,zhp;
double sum,e[SNUM]={0};
srand(time(NULL));
QueryPerformanceFrequency(&ft);
zhp=ft.QuadPart;
do{
QueryPerformanceCounter(&ft);
k=ft.QuadPart;
printf("輸入待排序元素個數(輸入0結束)：");
scanf("%d",&n);
b=(int*)malloc(n*sizeof(int));
for(i=0;i<n;i++)b[i]=rand()*rand()%100000;
tmp=Runtime(b,n,'I');
e[0]=(double)tmp/(double)zhp*1000;
tmp=Runtime(b,n,'S');
e[1]=(double)tmp/(double)zhp*1000;
tmp=Runtime(b,n,'B');
e[2]=(double)tmp/(double)zhp*1000;
tmp=Runtime(b,n,'Q');
e[3]=(double)tmp/(double)zhp*1000;
tmp=Runtime(b,n,'J');
e[4]=(double)tmp/(double)zhp*1000;
tmp=Runtime(b,n,'H');
e[5]=(double)tmp/(double)zhp*1000;
tmp=Runtime(b,n,'2');
e[6]=(double)tmp/(double)zhp*1000;
if(n>0)Disp(n,e);
QueryPerformanceCounter(&ft);
j=ft.QuadPart;
sum=(double)(j-k)/(double)zhp*1000;
printf("\n程序運行總時間為：%1.2fms\n",sum);
for(i=0;i<SNUM;i++)comp[i]=move[i]=0;//初始化
free(b);
}while(n>0);
system("pause");
}

『貳』 在計算機中，演算法是指什麼

演算法（Algorithm）是對問題求解方法的精確描述
，也就是說，能夠對一定規范的輸入，在有限時間內獲得所要求的輸出。如果一個演算法有缺陷，或不適合於某個問題，執行這個演算法將不會解決這個問題。不同的演算法可能用不同的時間、空間或效率來完成同樣的任務。一個演算法的優劣可以用
空間復雜度
與
時間復雜度
來衡量。
演算法可以理解為有基本運算及規定的運算順序所構成的完整的解題步驟。或者看成按照要求設計好的有限的確切的計算序列，並且這樣的步驟和序列可以解決一類問題。
一個演算法應該具有以下五個重要的特徵：
1、
有窮性
：
一個演算法必須保證執行有限步之後結束；
2、
明確性
：
演算法的每一步驟必須意義明確；
3、
輸入
：一個演算法有0個或多個輸入，以刻畫運算對象的初始情況，所謂0個輸入是指演算法本身定除了初始條件；
4、
輸出
：一個演算法有一個或多個輸出，以反映對輸入數據加工後的結果。沒有輸出的演算法是毫無意義的；
5、
可執行性
：
所採用的演算法必須能夠在計算機上執行。
計算機科學家尼克勞斯-沃思曾著過一本著名的書《數據結構十演算法=
程序》，可見演算法在計算機科學界與計算機應用界的地位。

『叄』 在計算機中，演算法是指什麼

計算機演算法是以一步接一步的方式來詳細描述計算機如何將輸入轉化為所要求的輸出的過程，或者說，演算法是對計算機上執行的計算過程的具體描述。

一個演算法必須具備以下性質：

（1）演算法首先必須是正確的，即對於任意的一組輸入，包括合理的輸入與不合理的輸入，總能得到預期的輸出。如果一個演算法只是對合理的輸入才能得到預期的輸出，而在異常情況下卻無法預料輸出的結果，那麼它就不是正確的。

（2）演算法必須是由一系列具體步驟組成的，並且每一步都能夠被計算機所理解和執行，而不是抽象和模糊的概念。

（3）每個步驟都有確定的執行順序，即上一步在哪裡；下一步是什麼，都必須明確，無二義性。

（4）無論演算法有多麼復雜，都必須在有限步之後結束並終止運行；即演算法的步驟必須是有限的。在任何情況下，演算法都不能陷入無限循環中。

一個問題的解決方案可以有多種表達方式；但只有滿足以上4個條件的解才能稱之為演算法。

(3)演算法是在內擴展閱讀：

演算法可大致分為基本演算法、數據結構的演算法、數論與代數演算法、計算幾何的演算法、圖論的演算法、動態規劃以及數值分析、加密演算法、排序演算法、檢索演算法、隨機化演算法、並行演算法，厄米變形模型，隨機森林演算法。

演算法可以宏泛的分為三類：

一，有限的，確定性演算法 這類演算法在有限的一段時間內終止。他們可能要花很長時間來執行指定的任務，但仍將在一定的時間內終止。這類演算法得出的結果常取決於輸入值。

二，有限的，非確定演算法 這類演算法在有限的時間內終止。然而，對於一個（或一些）給定的數值，演算法的結果並不是唯一的或確定的。

三，無限的演算法 是那些由於沒有定義終止定義條件，或定義的條件無法由輸入的數據滿足而不終止運行的演算法。通常，無限演算法的產生是由於未能確定的定義終止條件。

『肆』 演算法是什麼急!!!!

演算法 Algorithm

演算法是在有限步驟內求解某一問題所使用的一組定義明確的規則。通俗點說，就是計算機解題的過程。在這個過程中，無論是形成解題思路還是編寫程序，都是在實施某種演算法。前者是推理實現的演算法，後者是操作實現的演算法。

一個演算法應該具有以下五個重要的特徵：

1、有窮性： 一個演算法必須保證執行有限步之後結束；

2、確切性： 演算法的每一步驟必須有確切的定義；

3、輸入：一個演算法有0個或多個輸入，以刻畫運算對象的初始情況，所謂0個輸入是指演算法本身定除了初始條件；

4、輸出：一個演算法有一個或多個輸出，以反映對輸入數據加工後的結果。沒有輸出的演算法是毫無意義的；

5、可行性： 演算法原則上能夠精確地運行，而且人們用筆和紙做有限次運算後即可完成。

演算法的設計要求
1）正確性（Correctness）
有4個層次：
A．程序不含語法錯誤；
B．程序對幾組輸入數據能夠得出滿足規格要求的結果；
C．程序對精心選擇的、典型的、苛刻的、帶有刁難性的幾組輸入數據能夠得出滿足規格要求的結果；
D．程序對一切合法的輸入數據都能產生滿足規格要求的結果。
2）可讀性（Readability）
演算法的第一目的是為了閱讀和交流；
可讀性有助於對演算法的理解；
可讀性有助於對演算法的調試和修改。
3）高效率與低存儲量
處理速度快；存儲容量小
時間和空間是矛盾的、實際問題的求解往往是求得時間和空間的統一、折中。
演算法的描述 演算法的描述方式（常用的）
演算法描述 自然語言
流程圖 特定的表示演算法的圖形符號
偽語言 包括程序設計語言的三大基本結構及自然語言的一種語言
類語言 類似高級語言的語言，例如，類PASCAL、類C語言。

演算法的評價 演算法評價的標准：時間復雜度和空間復雜度。
1）時間復雜度 指在計算機上運行該演算法所花費的時間。用「O（數量級）」來表示，稱為「階」。
常見的時間復雜度有： O（1）常數階；O（logn）對數階；O（n）線性階；O（n＾2）平方階
2）空間復雜度 指演算法在計算機上運行所佔用的存儲空間。度量同時間復雜度。

時間復雜度舉例
（a） X：=X+1 ； O（1）
（b） FOR I：=1 TO n DO
X：= X+1； O（n）
（c） FOR I：= 1 TO n DO
FOR J：= 1 TO n DO
X：= X+1； O（n＾2）

「演算法」一詞最早來自公元 9世紀 波斯數學家比阿勒·霍瓦里松的一本影響深遠的著作《代數對話錄》。20世紀的 英國 數學家 圖靈 提出了著名的圖靈論點，並抽象出了一台機器，這台機器被我們稱之為 圖靈機 。圖靈的思想對演算法的發展起到了重要的作用。
演算法是 計算機 處理信息的本質，因為 計算機程序 本質上是一個演算法，告訴計算機確切的步驟來執行一個指定的任務，如計算職工的薪水或列印學生的成績單。 一般地，當演算法在處理信息時，數據會從輸入設備讀取，寫入輸出設備，可能保存起來以供以後使用。
這是演算法的一個簡單的例子。
我們有一串隨機數列。我們的目的是找到這個數列中最大的數。如果將數列中的每一個數字看成是一顆豆子的大小 可以將下面的演算法形象地稱為「撿豆子」：
首先將第一顆豆子（數列中的第一個數字）放入口袋中。
從第二顆豆子開始檢查，直到最後一顆豆子。如果正在檢查的豆子比口袋中的還大，則將它撿起放入口袋中，同時丟掉原先的豆子。 最後口袋中的豆子就是所有的豆子中最大的一顆。
下面是一個形式演算法，用近似於 編程語言 的 偽代碼 表示
給定：一個數列「list"，以及數列的長度"length(list)" largest = list[1] for counter = 2 to length(list): if list[counter] > largest: largest = list[counter] print largest
符號說明:
= 用於表示賦值。即：右邊的值被賦予給左邊的變數。
List[counter] 用於表示數列中的第 counter 項。例如：如果 counter 的值是5，那麼 List[counter] 表示數列中的第5項。
<= 用於表示「小於或等於」。
演算法的分類
（一）基本演算法 :
1.枚舉
2.搜索:
深度優先搜索
廣度優先搜索
啟發式搜索
遺傳演算法
（二）數據結構的演算法
（三）數論與代數演算法
（四）計算幾何的演算法：求凸包
（五）圖論 演算法：
1.哈夫曼編碼
2.樹的遍歷
3.最短路徑 演算法
4.最小生成樹 演算法
5.最小樹形圖
6.網路流 演算法
7.匹配演算法
（六）動態規劃
（七）其他：
1.數值分析
2.加密演算法
3.排序 演算法
4.檢索演算法
5.隨機化演算法

『伍』 演算法的性質有哪些

演算法的一般性質包括：
（1） 通用性 對於那些符合輸入類型的任意輸入數據，都能根據演算法進行問題求解，包保證計算結構的正確性。
（2） 有效性 組成演算法的每一條指令都必須是能夠被人或機器確切執行的。
（3） 確定性 演算法每執行一步之後，對於它的下一步，應該有明確的指示。即，保證每一步之後都有關於下一步動作的指令，不能缺乏下一步指令或僅僅含有模糊不清的指令。
（4） 有窮性 演算法的執行必須在有限步內結束。

『陸』 簡便演算法是什麼

簡便演算法...顧名思義就是：使演算法 變得簡單。

舉個例子：
25×24=?就可以用簡便演算法 即：25×24=25×（4×6）=25×4×6=100×6=600
這樣的演算法就是 簡便演算法了 。

相關內容：

1、演算法（Algorithm）是指解題方案的准確而完整的描述，是一系列解決問題的清晰指令，演算法代表著用系統的方法描述解決問題的策略機制。也就是說，能夠對一定規范的輸入，在有限時間內獲得所要求的輸出。

2、如果一個演算法有缺陷，或不適合於某個問題，執行這個演算法將不會解決這個問題。不同的演算法可能用不同的時間、空間或效率來完成同樣的任務。一個演算法的優劣可以用空間復雜度與時間復雜度來衡量。

3、演算法中的指令描述的是一個計算，當其運行時能從一個初始狀態和（可能為空的）初始輸入開始，經過一系列有限而清晰定義的狀態，最終產生輸出並停止於一個終態。一個狀態到另一個狀態的轉移不一定是確定的。

4、隨機化演算法在內的一些演算法，包含了一些隨機輸入。形式化演算法的概念部分源自嘗試解決希爾伯特提出的判定問題，並在其後嘗試定義有效計算性或者有效方法中成形。

5、這些嘗試包括庫爾特·哥德爾、Jacques Herbrand和斯蒂芬·科爾·克萊尼分別於1930年、1934年和1935年提出的遞歸函數，阿隆佐·邱奇於1936年提出的λ演算，1936年Emil Leon Post的Formulation 1和艾倫·圖靈1937年提出的圖靈機。

6、即使在當前，依然常有知覺想法難以定義為形式化演算法的情況。

『柒』 在計算機中，演算法是指什麼

為了解決一個問題而採取的方法和步驟。
你學了C語言沒，那本書里有！

『捌』 演算法的基本特徵是

演算法

3分鍾了解今日頭條演算法原理（科普版）
02:43

什麼是演算法
04:28
概述
歷史發展
演算法分類
演算法特徵
演算法要素
演算法評定
目錄
1摘要
2基本信息
3概述
4歷史發展
5演算法分類
6演算法特徵
7演算法要素
數據的運算和操作
演算法的控制結構
8演算法評定
9描述方式
10史料記載
11基本方法
12參考資料
演算法是指解題方案的准確而完整的描述，是一系列解決問題的清晰指令，演算法代表著用系統的方法描述解決問題的策略機制；它是求解問題類的、機械的、統一的方法，常用於計算、數據處理（英語：Data processing）和自動推理。可以理解為有基本運算及規定的運算順序所構成的完整的解題步驟。或者看成按照要求設計好的有限的確切的計算序列，並且這樣的步驟和序列可以解決一類問題。

演算法中的指令描述的是一個計算，當其運行時能從一個初始狀態和（可能為空的）初始輸入開始，經過一系列有限而清晰定義的狀態，最終產生輸出並停止於一個終態。一個狀態到另一個狀態的轉移不一定是確定的。隨機化演算法在內的一些演算法，包含了一些隨機輸入。

基本信息
中文名
演算法

外文名
Algorithm

拼音
suanfa

出處
數學 計算機

定義
是指解題方案的准確而完整的描述，是一系列解決問題的清晰指令，演算法代表著用系統的方法描述解決問題的策略機制

展開全部
概述
求解問題類的、機械的、統一的方法，它由有限多個步驟組成，對於問題類中的每個給定的具體問題，機械地執行這些步驟就可以得到問題的解答。演算法的這種特性，使得計算不僅可以由人，而且可以由計算機來完成。用計算機解決問題的過程可以分成三個階段：分析問題、設計演算法和實現演算法。[1]

歷史發展
中國古代的籌算口決與珠算口決及其執行規則就是演算法的雛形,這里,所解決的問題類是算術運算。古希臘數學家歐幾里得在公元前3世紀就提出了一個演算法,來尋求兩個正整數的最大公約數，這就是有名的歐幾里得演算法,亦稱輾轉相除法。中國早已有「算術「、「演算法」等詞彙，但是它們的含義是指當時的全部數學知識和計算技能,與現代演算法的含義不盡相同。英文algorithm(演算法)一詞也經歷了一個演變過程，最初的拼法為algorism或algoritmi,原意為用阿拉伯數字進行計算的過程。這個詞源於公元 9世紀波斯數字家阿爾·花拉子米的名字的最後一部分。[1]

在古代，計算通常是指數值計算。現代計算已經遠遠地突破了數值計算的范圍,包括大量的非數值計算,例如檢索、表格處理、判斷、決策、形式邏輯演繹等。

在20世紀以前，人們普遍地認為，所有的問題類都是有演算法的。20世紀初，數字家們發現有的問題類是不存在演算法的,遂開始進行能行性研究。在這一研究中,現代演算法的概念逐步明確起來。30年代，數字家們提出了遞歸函數、圖靈機等計算模型，並提出了丘奇－圖靈論題（見可計算性理論），這才有可能把演算法概念形式化。按照丘奇-圖靈論題,任意一個演算法都可以用一個圖靈機來實現，反之，任意一個圖靈機都表示一個演算法。

按照上述理解，演算法是由有限多個步驟組成的，它有下述兩個基本特徵：每個步驟都明確地規定要執行何種操作；每個步驟都可以被人或機器在有限的時間內完成。人們對於演算法還有另一種不同的理解，它要求演算法除了上述兩個基本特徵外,還要具有第三個基本特徵:雖然有些步驟可能被反復執行多次，但是在執行有限多次之後，就一定能夠得到問題的解答。也就是說，一個處處停機（即對任意輸入都停機）的圖靈機才表示一個演算法，而每個演算法都可以被一個處處停機的圖靈機來實現[1]

演算法分類
演算法可大致分為基本演算法、數據結構的演算法、數論與代數演算法、計算幾何的演算法、圖論的演算法、動態規劃以及數值分析、加密演算法、排序演算法、檢索演算法、隨機化演算法、並行演算法。[1]

演算法可以宏泛的分為三類：

有限的，確定性演算法 這類演算法在有限的一段時間內終止。他們可能要花很長時間來執行指定的任務，但仍將在一定的時間內終止。這類演算法得出的結果常取決於輸入值。

有限的，非確定演算法 這類演算法在有限的時間內終止。然而，對於一個（或一些）給定的數值，演算法的結果並不是唯一的或確定的。

無限的演算法 是那些由於沒有定義終止定義條件，或定義的條件無法由輸入的數據滿足而不終止運行的演算法。通常，無限演算法的產生是由於未能確定的定義終止條件。[1]

演算法特徵
1、輸入項：一個演算法有零個或多個輸入，以刻畫運算對象的初始情況。例如，在歐幾里得演算法中，有兩個輸入，即m和n。[1]

2、確定性：演算法的每一個步驟必須要確切地定義。即演算法中所有有待執行的動作必須嚴格而不含混地進行規定，不能有歧義性。例如，歐幾里得演算法中，步驟1中明確規定「以m除以n，而不能有類似以m除n以或n除以m這類有兩種可能做法的規定。

3、有窮性：一個演算法在執行有窮步滯後必須結束。也就是說，一個演算法，它所包含的計算步驟是有限的。例如，在歐幾里得演算法中，m和n均為正整數，在步驟1之後，r必小於n，若r不等於0，下一次進行步驟1時，n的值已經減小，而正整數的遞降序列最後必然要終止。因此，無論給定m和n的原始值有多大，步驟1的執行都是有窮次。

4、輸出：演算法有一個或多個的輸出，即與輸入有某個特定關系的量，簡單地說就是演算法的最終結果。例如，在歐幾里得演算法中只有一個輸出，即步驟2中的n。

5、能行性：演算法中有待執行的運算和操作必須是相當基本的，換言之，他們都是能夠精確地進行的，演算法執行者甚至不需要掌握演算法的含義即可根據該演算法的每一步驟要求進行操作，並最終得出正確的結果。[1]

『玖』 C語言中什麼叫演算法,演算法在程序設計中的重要作用

一、什麼是演算法
演算法是一系列解決問題的清晰指令，也就是說，能夠對一定規范的輸入，在有限時間內獲得所要求的輸出。演算法常常含有重復的步驟和一些比較或邏輯判斷。如果一個演算法有缺陷，或不適合於某個問題，執行這個演算法將不會解決這個問題。不同的演算法可能用不同的時間、空間或效率來完成同樣的任務。一個演算法的優劣可以用空間復雜度與時間復雜度來衡量。
演算法的時間復雜度是指演算法需要消耗的時間資源。一般來說，計算機演算法是問題規模n 的函數f(n)，演算法執行的時間的增長率與f(n) 的增長率正相關，稱作漸進時間復雜度（Asymptotic Time Complexity）。時間復雜度用「O（數量級）」來表示，稱為「階」。常見的時間復雜度有： O（1）常數階；O（log2n）對數階；O（n）線性階；O（n2）平方階。
演算法的空間復雜度是指演算法需要消耗的空間資源。其計算和表示方法與時間復雜度類似，一般都用復雜度的漸近性來表示。同時間復雜度相比，空間復雜度的分析要簡單得多。

二、演算法設計的方法
1.遞推法
遞推法是利用問題本身所具有的一種遞推關系求問題解的一種方法。設要求問題規模為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]×10m-1+a[m-1]×10m-2+ … +a[2]×101+a[1]×100
並用a[0]存儲長整數N的位數m，即a[0]=m。按上述約定，數組的每個元素存儲k的階乘k！的一位數字，並從低位到高位依次存於數組的第二個元素、第三個元素……。例如，5！=120，在數組中的存儲形式為：
3 0 2 1 ……
首元素3表示長整數是一個3位數，接著是低位到高位依次是0、2、1，表示成整數120。
計算階乘k！可採用對已求得的階乘(k-1)！連續累加k-1次後求得。例如，已知4！=24，計算5！，可對原來的24累加4次24後得到120。細節見以下程序。
# include <stdio.h>
# include <malloc.h>
......
2.遞歸
遞歸是設計和描述演算法的一種有力的工具，由於它在復雜演算法的描述中被經常採用，為此在進一步介紹其他演算法設計方法之前先討論它。
能採用遞歸描述的演算法通常有這樣的特徵：為求解規模為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);
}
遞歸演算法的執行過程分遞推和回歸兩個階段。在遞推階段，把較復雜的問題（規模為n）的求解推到比原問題簡單一些的問題（規模小於n）的求解。例如上例中，求解fib(n)，把它推到求解fib(n-1)和fib(n-2)。也就是說，為計算fib(n)，必須先計算fib(n-1)和fib(n-2)，而計算fib(n-1)和fib(n-2)，又必須先計算fib(n-3)和fib(n-4)。依次類推，直至計算fib(1)和fib(0)，分別能立即得到結果1和0。在遞推階段，必須要有終止遞歸的情況。例如在函數fib中，當n為1和0的情況。
在回歸階段，當獲得最簡單情況的解後，逐級返回，依次得到稍復雜問題的解，例如得到fib(1)和fib(0)後，返回得到fib(2)的結果，……，在得到了fib(n-1)和fib(n-2)的結果後，返回得到fib(n)的結果。
在編寫遞歸函數時要注意，函數中的局部變數和參數知識局限於當前調用層，當遞推進入「簡單問題」層時，原來層次上的參數和局部變數便被隱蔽起來。在一系列「簡單問題」層，它們各有自己的參數和局部變數。
由於遞歸引起一系列的函數調用，並且可能會有一系列的重復計算，遞歸演算法的執行效率相對較低。當某個遞歸演算法能較方便地轉換成遞推演算法時，通常按遞推演算法編寫程序。例如上例計算斐波那契數列的第n項的函數fib(n)應採用遞推演算法，即從斐波那契數列的前兩項出發，逐次由前兩項計算出下一項，直至計算出要求的第n項。
【問題】 組合問題
問題描述：找出從自然數1、2、……、n中任取r個數的所有組合。例如n=5，r=3的所有組合為： （1）5、4、3 （2）5、4、2 （3）5、4、1
（4）5、3、2 （5）5、3、1 （6）5、2、1
（7）4、3、2 （8）4、3、1 （9）4、2、1
（10）3、2、1
分析所列的10個組合，可以採用這樣的遞歸思想來考慮求組合函數的演算法。設函數為void comb(int m,int k)為找出從自然數1、2、……、m中任取k個數的所有組合。當組合的第一個數字選定時，其後的數字是從餘下的m-1個數中取k-1數的組合。這就將求m個數中取k個數的組合問題轉化成求m-1個數中取k-1個數的組合問題。設函數引入工作數組a[ ]存放求出的組合的數字，約定函數將確定的k個數字組合的第一個數字放在a[k]中，當一個組合求出後，才將a[ ]中的一個組合輸出。第一個數可以是m、m-1、……、k，函數將確定組合的第一個數字放入數組後，有兩種可能的選擇，因還未去頂組合的其餘元素，繼續遞歸去確定；或因已確定了組合的全部元素，輸出這個組合。細節見以下程序中的函數comb。
【程序】
# include <stdio.h>
# define MAXN 100
int a[MAXN];
void comb(int m,int k)
{ int i,j;
for (i=m;i>=k;i--)
{ a[k]=i;
if (k>1)
comb(i-1,k-1);
else
{ for (j=a[0];j>0;j--)
printf(「%4d」,a[j]);
printf(「\n」);
}
}
}

void main()
{ a[0]=3;
comb(5,3);
}
3.回溯法
回溯法也稱為試探法，該方法首先暫時放棄關於問題規模大小的限制，並將問題的候選解按某種順序逐一枚舉和檢驗。當發現當前候選解不可能是解時，就選擇下一個候選解；倘若當前候選解除了還不滿足問題規模要求外，滿足所有其他要求時，繼續擴大當前候選解的規模，並繼續試探。如果當前候選解滿足包括問題規模在內的所有要求時，該候選解就是問題的一個解。在回溯法中，放棄當前候選解，尋找下一個候選解的過程稱為回溯。擴大當前候選解的規模，以繼續試探的過程稱為向前試探。

【問題】 組合問題
問題描述：找出從自然數1，2，…，n中任取r個數的所有組合。
採用回溯法找問題的解，將找到的組合以從小到大順序存於a[0]，a[1]，…，a[r-1]中，組合的元素滿足以下性質：
（1） a[i+1]>a，後一個數字比前一個大；
（2） a-i<=n-r+1。
按回溯法的思想，找解過程可以敘述如下：
首先放棄組合數個數為r的條件，候選組合從只有一個數字1開始。因該候選解滿足除問題規模之外的全部條件，擴大其規模，並使其滿足上述條件（1），候選組合改為1，2。繼續這一過程，得到候選組合1，2，3。該候選解滿足包括問題規模在內的全部條件，因而是一個解。在該解的基礎上，選下一個候選解，因a[2]上的3調整為4，以及以後調整為5都滿足問題的全部要求，得到解1，2，4和1，2，5。由於對5不能再作調整，就要從a[2]回溯到a[1]，這時，a[1]=2，可以調整為3，並向前試探，得到解1，3，4。重復上述向前試探和向後回溯，直至要從a[0]再回溯時，說明已經找完問題的全部解。按上述思想寫成程序如下：
【程序】
# define MAXN 100
int a[MAXN];
void comb(int m,int r)
{ int i,j;
i=0;
a=1;
do {
if (a-i<=m-r+1
{ if (i==r-1)
{ for (j=0;j<r;j++)
printf(「%4d」,a[j]);
printf(「\n」);
}
a++;
continue;
}
else
{ if (i==0)
return;
a[--i]++;
}
} while (1)
}

main()
{ comb(5,3);
}

4.貪婪法
貪婪法是一種不追求最優解，只希望得到較為滿意解的方法。貪婪法一般可以快速得到滿意的解，因為它省去了為找最優解要窮盡所有可能而必須耗費的大量時間。貪婪法常以當前情況為基礎作最優選擇，而不考慮各種可能的整體情況，所以貪婪法不要回溯。
例如平時購物找錢時，為使找回的零錢的硬幣數最少，不考慮找零錢的所有各種發表方案，而是從最大面值的幣種開始，按遞減的順序考慮各幣種，先盡量用大面值的幣種，當不足大面值幣種的金額時才去考慮下一種較小面值的幣種。這就是在使用貪婪法。這種方法在這里總是最優，是因為銀行對其發行的硬幣種類和硬幣面值的巧妙安排。如只有面值分別為1、5和11單位的硬幣，而希望找回總額為15單位的硬幣。按貪婪演算法，應找1個11單位面值的硬幣和4個1單位面值的硬幣，共找回5個硬幣。但最優的解應是3個5單位面值的硬幣。
【問題】 裝箱問題
問題描述：裝箱問題可簡述如下：設有編號為0、1、…、n-1的n種物品，體積分別為v0、v1、…、vn-1。將這n種物品裝到容量都為V的若干箱子里。約定這n種物品的體積均不超過V，即對於0≤i＜n，有0＜vi≤V。不同的裝箱方案所需要的箱子數目可能不同。裝箱問題要求使裝盡這n種物品的箱子數要少。
若考察將n種物品的集合分劃成n個或小於n個物品的所有子集，最優解就可以找到。但所有可能劃分的總數太大。對適當大的n，找出所有可能的劃分要花費的時間是無法承受的。為此，對裝箱問題採用非常簡單的近似演算法，即貪婪法。該演算法依次將物品放到它第一個能放進去的箱子中，該演算法雖不能保證找到最優解，但還是能找到非常好的解。不失一般性，設n件物品的體積是按從大到小排好序的，即有v0≥v1≥…≥vn-1。如不滿足上述要求，只要先對這n件物品按它們的體積從大到小排序，然後按排序結果對物品重新編號即可。裝箱演算法簡單描述如下：
{ 輸入箱子的容積；
輸入物品種數n；
按體積從大到小順序，輸入各物品的體積；
預置已用箱子鏈為空；
預置已用箱子計數器box_count為0；
for (i=0;i<n;i++)
{ 從已用的第一隻箱子開始順序尋找能放入物品i 的箱子j；
if （已用箱子都不能再放物品i）
{ 另用一個箱子，並將物品i放入該箱子；
box_count++；
}
else
將物品i放入箱子j；
}
}
上述演算法能求出需要的箱子數box_count，並能求出各箱子所裝物品。下面的例子說明該演算法不一定能找到最優解，設有6種物品，它們的體積分別為：60、45、35、20、20和20單位體積，箱子的容積為100個單位體積。按上述演算法計算，需三隻箱子，各箱子所裝物品分別為：第一隻箱子裝物品1、3；第二隻箱子裝物品2、4、5；第三隻箱子裝物品6。而最優解為兩只箱子，分別裝物品1、4、5和2、3、6。
若每隻箱子所裝物品用鏈表來表示，鏈表首結點指針存於一個結構中，結構記錄尚剩餘的空間量和該箱子所裝物品鏈表的首指針。另將全部箱子的信息也構成鏈表。以下是按以上演算法編寫的程序。
}

5.分治法
任何一個可以用計算機求解的問題所需的計算時間都與其規模N有關。問題的規模越小，越容易直接求解，解題所需的計算時間也越少。例如，對於n個元素的排序問題，當n=1時，不需任何計算；n=2時，只要作一次比較即可排好序；n=3時只要作3次比較即可，…。而當n較大時，問題就不那麼容易處理了。要想直接解決一個規模較大的問題，有時是相當困難的。
分治法的設計思想是，將一個難以直接解決的大問題，分割成一些規模較小的相同問題，以便各個擊破，分而治之。
如果原問題可分割成k個子問題（1<k≤n），且這些子問題都可解，並可利用這些子問題的解求出原問題的解，那麼這種分治法就是可行的。由分治法產生的子問題往往是原問題的較小模式，這就為使用遞歸技術提供了方便。在這種情況下，反復應用分治手段，可以使子問題與原問題類型一致而其規模卻不斷縮小，最終使子問題縮小到很容易直接求出其解。這自然導致遞歸過程的產生。分治與遞歸像一對孿生兄弟，經常同時應用在演算法設計之中，並由此產生許多高效演算法。
分治法所能解決的問題一般具有以下幾個特徵：
（1）該問題的規模縮小到一定的程度就可以容易地解決；
（2）該問題可以分解為若干個規模較小的相同問題，即該問題具有最優子結構性質；
（3）利用該問題分解出的子問題的解可以合並為該問題的解；
（4）該問題所分解出的各個子問題是相互獨立的，即子問題之間不包含公共的子子問題。
上述的第一條特徵是絕大多數問題都可以滿足的，因為問題的計算復雜性一般是隨著問題規模的增加而增加；第二條特徵是應用分治法的前提，它也是大多數問題可以滿足的，此特徵反映了遞歸思想的應用；第三條特徵是關鍵，能否利用分治法完全取決於問題是否具有第三條特徵，如果具備了第一條和第二條特徵，而不具備第三條特徵，則可以考慮貪心法或動態規劃法。第四條特徵涉及到分治法的效率，如果各子問題是不獨立的，則分治法要做許多不必要的工作，重復地解公共的子問題，此時雖然可用分治法，但一般用動態規劃法較好。
分治法在每一層遞歸上都有三個步驟：
（1）分解：將原問題分解為若干個規模較小，相互獨立，與原問題形式相同的子問題；
（2）解決：若子問題規模較小而容易被解決則直接解，否則遞歸地解各個子問題；
（3）合並：將各個子問題的解合並為原問題的解。
6.動態規劃法
經常會遇到復雜問題不能簡單地分解成幾個子問題，而會分解出一系列的子問題。簡單地採用把大問題分解成子問題，並綜合子問題的解導出大問題的解的方法，問題求解耗時會按問題規模呈冪級數增加。
為了節約重復求相同子問題的時間，引入一個數組，不管它們是否對最終解有用，把所有子問題的解存於該數組中，這就是動態規劃法所採用的基本方法。以下先用實例說明動態規劃方法的使用。
【問題】 求兩字元序列的最長公共字元子序列
問題描述：字元序列的子序列是指從給定字元序列中隨意地（不一定連續）去掉若干個字元（可能一個也不去掉）後所形成的字元序列。令給定的字元序列X=「x0，x1，…，xm-1」，序列Y=「y0，y1，…，yk-1」是X的子序列，存在X的一個嚴格遞增下標序列<i0，i1，…，ik-1>，使得對所有的j=0，1，…，k-1，有xij=yj。例如，X=「ABCBDAB」，Y=「BCDB」是X的一個子序列。
考慮最長公共子序列問題如何分解成子問題，設A=「a0，a1，…，am-1」，B=「b0，b1，…，bm-1」，並Z=「z0，z1，…，zk-1」為它們的最長公共子序列。不難證明有以下性質：
（1） 如果am-1=bn-1，則zk-1=am-1=bn-1，且「z0，z1，…，zk-2」是「a0，a1，…，am-2」和「b0，b1，…，bn-2」的一個最長公共子序列；
（2） 如果am-1!=bn-1，則若zk-1!=am-1，蘊涵「z0，z1，…，zk-1」是「a0，a1，…，am-2」和「b0，b1，…，bn-1」的一個最長公共子序列；
（3） 如果am-1!=bn-1，則若zk-1!=bn-1，蘊涵「z0，z1，…，zk-1」是「a0，a1，…，am-1」和「b0，b1，…，bn-2」的一個最長公共子序列。
這樣，在找A和B的公共子序列時，如有am-1=bn-1，則進一步解決一個子問題，找「a0，a1，…，am-2」和「b0，b1，…，bm-2」的一個最長公共子序列；如果am-1!=bn-1，則要解決兩個子問題，找出「a0，a1，…，am-2」和「b0，b1，…，bn-1」的一個最長公共子序列和找出「a0，a1，…，am-1」和「b0，b1，…，bn-2」的一個最長公共子序列，再取兩者中較長者作為A和B的最長公共子序列。
代碼如下：
# include <stdio.h>
# include <string.h>
# define N 100
char a[N],b[N],str[N];

int lcs_len(char *a, char *b, int c[ ][ N])
{ int m=strlen(a), n=strlen(b), i,j;
for (i=0;i<=m;i++) c[0]=0;
for (i=0;i<=n;i++) c[0]=0;
for (i=1;i<=m;i++)
for (j=1;j<=m;j++)
if (a[i-1]==b[j-1])
c[j]=c[i-1][j-1]+1;
else if (c[i-1][j]>=c[j-1])
c[j]=c[i-1][j];
else
c[j]=c[j-1];
return c[m][n];
}

char *buile_lcs(char s[ ],char *a, char *b)
{ int k, i=strlen(a), j=strlen(b);
k=lcs_len(a,b,c);
s[k]=』』;
while (k>0)
if (c[j]==c[i-1][j]) i--;
else if (c[j]==c[j-1]) j--;
else { s[--k]=a[i-1];
i--; j--;
}
return s;
}

void main()
{ printf (「Enter two string（<%d）!\n」,N);
scanf(「%s%s」,a,b);
printf(「LCS=%s\n」,build_lcs(str,a,b));
}
7.迭代法
迭代法是用於求方程或方程組近似根的一種常用的演算法設計方法。設方程為f(x)=0，用某種數學方法導出等價的形式x=g(x)，然後按以下步驟執行：
（1） 選一個方程的近似根，賦給變數x0；
（2） 將x0的值保存於變數x1，然後計算g(x1)，並將結果存於變數x0；
（3） 當x0與x1的差的絕對值還小於指定的精度要求時，重復步驟（2）的計算。
若方程有根，並且用上述方法計算出來的近似根序列收斂，則按上述方法求得的x0就認為是方程的根。上述演算法用C程序的形式表示為：
程序如下：
【演算法】迭代法求方程組的根
{ for (i=0;i<n;i++)
x=初始近似根;
do {
for (i=0;i<n;i++)
y = x;
for (i=0;i<n;i++)
x = gi(X);
for (delta=0.0,i=0;i<n;i++)
if (fabs(y-x)>delta) delta=fabs(y-x)； } while (delta>Epsilon)；
for (i=0;i<n;i++)
printf(「變數x[%d]的近似根是 %f」，I，x)；
printf(「\n」)；
} 具體使用迭代法求根時應注意以下兩種可能發生的情況：
（1）如果方程無解，演算法求出的近似根序列就不會收斂，迭代過程會變成死循環，因此在使用迭代演算法前應先考察方程是否有解，並在程序中對迭代的次數給予限制；
（2）方程雖然有解，但迭代公式選擇不當，或迭代的初始近似根選擇不合理，也會導致迭代失敗。
8.窮舉搜索法
窮舉搜索法是對可能是解的眾多候選解按某種順序進行逐一枚舉和檢驗，並從眾找出那些符合要求的候選解作為問題的解。
【問題】 將A、B、C、D、E、F這六個變數排成如圖所示的三角形，這六個變數分別取[1，6]上的整數，且均不相同。求使三角形三條邊上的變數之和相等的全部解。如圖就是一個解。
程序引入變數a、b、c、d、e、f，並讓它們分別順序取1至6的整數，在它們互不相同的條件下，測試由它們排成的如圖所示的三角形三條邊上的變數之和是否相等，如相等即為一種滿足要求的排列，把它們輸出。當這些變數取盡所有的組合後，程序就可得到全部可能的解。程序如下：
按窮舉法編寫的程序通常不能適應變化的情況。如問題改成有9個變數排成三角形，每條邊有4個變數的情況，程序的循環重數就要相應改變。

『拾』 演算法是什麼意思 謝謝

演算法（Algorithm）是指解題方案的准確而完整的描述，是一系列解決問題的清晰指令，演算法代表著用系統的方法描述解決問題的策略機制。也就是說，能夠對一定規范的輸入，在有限時間內獲得所要求的輸出。如果一個演算法有缺陷，或不適合於某個問題，執行這個演算法將不會解決這個問題。不同的演算法可能用不同的時間、空間或效率來完成同樣的任務。一個演算法的優劣可以用空間復雜度與時間復雜度來衡量。

演算法中的指令描述的是一個計算，當其運行時能從一個初始狀態和（可能為空的）初始輸入開始，經過一系列有限而清晰定義的狀態，最終產生輸出並停止於一個終態。一個狀態到另一個狀態的轉移不一定是確定的。隨機化演算法在內的一些演算法，包含了一些隨機輸入。

(10)演算法是在內擴展閱讀：

演算法分類：

1、有限的，確定性演算法 這類演算法在有限的一段時間內終止。他們可能要花很長時間來執行指定的任務，但仍將在一定的時間內終止。這類演算法得出的結果常取決於輸入值。

2、有限的，非確定演算法 這類演算法在有限的時間內終止。然而，對於一個（或一些）給定的數值，演算法的結果並不是唯一的或確定的。

3、無限的演算法 是那些由於沒有定義終止定義條件，或定義的條件無法由輸入的數據滿足而不終止運行的演算法。通常，無限演算法的產生是由於未能確定的定義終止條件。