java迭代是什麼意思
⑴ java迭代是什麼意思
JAVA中的迭代分為迭代器還是演算法。
不知你想知道哪種
如果是迭代器的話，那沒什麼好說的，就是封裝一個類而已。
如果是演算法，下面附上代碼，研究下便理解。
/**
*Filsename: SortArray.java
*Task: 數組的迭代插入排序演算法
*/
public class SortArray{
public static void main(String[] args)
{
int array[]={8,9,1,4,2,3,0,6,5,7};
display(array);
insertionSort(array,array.length);
display(array);
}
public static void insertionSort(int[] a,int n)
{
for(int unsorted=1;unsorted<n;unsorted++)
{
insertInOrder(a[unsorted],a,0,unsorted-1);
}
}
private static void insertInOrder(int num,int[] a,int first,int last)
{
while(first<=last&&num<a[last])
{
a[last+1]=a[last];
last--;
}
a[last+1]=num;
}
public static void display(int[] a)
{
for(int i=0;i<a.length;i++)
System.out.print(a[i]+" ");
System.out.println();
}
}
⑵ 迭代是什麼意思
迭代
[dié dài]
迭代是重復反饋過程的活動，其目的通常是為了逼近所需目標或結果。每一次對過程的重復稱為一次「迭代」，而每一次迭代得到的結果會作為下一次迭代的初始值。
重復執行一系列運算步驟，從前面的量依次求出後面的量的過程。此過程的每一次結果，都是由對前一次所得結果施行相同的運算步驟得到的。例如利用迭代法*求某一數學問題的解。
對計算機特定程序中需要反復執行的子程序*(一組指令)，進行一次重復，即重復執行程序中的循環，直到滿足某條件為止，亦稱為迭代。
參考資料：
迭代-網路
迭代法-網路
⑶ java中」遍歷「，」迭代「是什麼意思
我認為迭代是遍歷的一種吧,遍歷是查找的意思吧
迭代器模式(Iterator pattern)
一、 引言
迭代這個名詞對於熟悉Java的人來說絕對不陌生。我們常常使用JDK提供的迭代介面進行java collection的遍歷：
Iterator it = list.iterator();
while(it.hasNext()){
//using 「it.next();」do some businesss logic
}
而這就是關於迭代器模式應用很好的例子。
二、 定義與結構
迭代器（Iterator）模式，又叫做游標（Cursor）模式。GOF給出的定義為：提供一種方法訪問一個容器（container）對象中各個元素，而又不需暴露該對象的內部細節。
從定義可見，迭代器模式是為容器而生。很明顯，對容器對象的訪問必然涉及到遍歷演算法。你可以一股腦的將遍歷方法塞到容器對象中去；或者根本不去提供什麼遍歷演算法，讓使用容器的人自己去實現去吧。這兩種情況好像都能夠解決問題。
然而在前一種情況，容器承受了過多的功能，它不僅要負責自己「容器」內的元素維護（添加、刪除等等），而且還要提供遍歷自身的介面；而且由於遍歷狀態保存的問題，不能對同一個容器對象同時進行多個遍歷。第二種方式倒是省事，卻又將容器的內部細節暴露無遺。
而迭代器模式的出現，很好的解決了上面兩種情況的弊端。先來看下迭代器模式的真面目吧。
迭代器模式由以下角色組成：
1) 迭代器角色（Iterator）：迭代器角色負責定義訪問和遍歷元素的介面。
2) 具體迭代器角色（Concrete Iterator）：具體迭代器角色要實現迭代器介面，並要記錄遍歷中的當前位置。
3) 容器角色（Container）：容器角色負責提供創建具體迭代器角色的介面。
4) 具體容器角色（Concrete Container）：具體容器角色實現創建具體迭代器角色的介面——這個具體迭代器角色於該容器的結構相關。
迭代器模式的類圖如下：
從結構上可以看出，迭代器模式在客戶與容器之間加入了迭代器角色。迭代器角色的加入，就可以很好的避免容器內部細節的暴露，而且也使得設計符號「單一職責原則」。
注意，在迭代器模式中，具體迭代器角色和具體容器角色是耦合在一起的——遍歷演算法是與容器的內部細節緊密相關的。為了使客戶程序從與具體迭代器角色耦合的困境中脫離出來，避免具體迭代器角色的更換給客戶程序帶來的修改，迭代器模式抽象了具體迭代器角色，使得客戶程序更具一般性和重用性。這被稱為多態迭代。
三、 舉例
由於迭代器模式本身的規定比較鬆散，所以具體實現也就五花八門。我們在此僅舉一例，根本不能將實現方式一一呈現。因此在舉例前，我們先來列舉下迭代器模式的實現方式。
1．迭代器角色定義了遍歷的介面，但是沒有規定由誰來控制迭代。在Java collection的應用中，是由客戶程序來控制遍歷的進程，被稱為外部迭代器；還有一種實現方式便是由迭代器自身來控制迭代，被稱為內部迭代器。外部迭代器要比內部迭代器靈活、強大，而且內部迭代器在java語言環境中，可用性很弱。
2．在迭代器模式中沒有規定誰來實現遍歷演算法。好像理所當然的要在迭代器角色中實現。因為既便於一個容器上使用不同的遍歷演算法，也便於將一種遍歷演算法應用於不同的容器。但是這樣就破壞掉了容器的封裝——容器角色就要公開自己的私有屬性，在java中便意味著向其他類公開了自己的私有屬性。
那我們把它放到容器角色里來實現好了。這樣迭代器角色就被架空為僅僅存放一個遍歷當前位置的功能。但是遍歷演算法便和特定的容器緊緊綁在一起了。
而在Java Collection的應用中，提供的具體迭代器角色是定義在容器角色中的內部類。這樣便保護了容器的封裝。但是同時容器也提供了遍歷演算法介面，你可以擴展自己的迭代器。
好了，我們來看下Java Collection中的迭代器是怎麼實現的吧。
//迭代器角色，僅僅定義了遍歷介面
public interface Iterator {
boolean hasNext();
Object next();
void remove();
}
//容器角色，這里以List為例。它也僅僅是一個介面，就不羅列出來了
//具體容器角色，便是實現了List介面的ArrayList等類。為了突出重點這里指羅列和迭代器相關的內容
//具體迭代器角色，它是以內部類的形式出來的。AbstractList是為了將各個具體容器角色的公共部分提取出來而存在的。
public abstract class AbstractList extends AbstractCollection implements List {
……
//這個便是負責創建具體迭代器角色的工廠方法
public Iterator iterator() {
return new Itr();
}
//作為內部類的具體迭代器角色
private class Itr implements Iterator {
int cursor = 0;
int lastRet = -1;
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size();
}
public Object next() {
checkForComodification();
try {
Object next = get(cursor);
lastRet = cursor++;
return next;
} catch(IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
public void remove() {
if (lastRet == -1)
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.remove(lastRet);
if (lastRet < cursor)
cursor--;
lastRet = -1;
expectedModCount = modCount;
} catch(IndexOutOfBoundsException e) {
throw new ();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ();
}
}
至於迭代器模式的使用。正如引言中所列那樣，客戶程序要先得到具體容器角色，然後再通過具體容器角色得到具體迭代器角色。這樣便可以使用具體迭代器角色來遍歷容器了……
四、 實現自己的迭代器
在實現自己的迭代器的時候，一般要操作的容器有支持的介面才可以。而且我們還要注意以下問題：
在迭代器遍歷的過程中，通過該迭代器進行容器元素的增減操作是否安全呢？
在容器中存在復合對象的情況，迭代器怎樣才能支持深層遍歷和多種遍歷呢？
以上兩個問題對於不同結構的容器角色，各不相同，值得考慮。
五、 適用情況
由上面的講述，我們可以看出迭代器模式給容器的應用帶來以下好處：
1) 支持以不同的方式遍歷一個容器角色。根據實現方式的不同，效果上會有差別。
2) 簡化了容器的介面。但是在java Collection中為了提高可擴展性，容器還是提供了遍歷的介面。
3) 對同一個容器對象，可以同時進行多個遍歷。因為遍歷狀態是保存在每一個迭代器對象中的。
由此也能得出迭代器模式的適用范圍：
1) 訪問一個容器對象的內容而無需暴露它的內部表示。
2) 支持對容器對象的多種遍歷。
3) 為遍歷不同的容器結構提供一個統一的介面（多態迭代）。
⑷ Java中 迭代 遍歷 遞歸 這幾個概念怎麼理解
遍歷：對於集合數據而言，訪問所有的數據即為遍歷。遍歷的方法可以用遞歸或者迭代。
迭代：一般是用同一個參數來表示每個集合元素，用循環來實現。
遞歸：是利用計算機的堆棧的概念，一般通過調用相同的函數來實現，函數中一般會設置終止的語句。舉個例子
int
fun(int
n){
if
(1
==
n)
{//終止語句
return
1;
}
else
{
return
n*fun(n-1);
//遞歸
}
}
希望有幫助
⑸ 迭代是什麼意思
迭代，就是遍歷一個集合，
在java中有三類集合：List，Set，Map
其中List和Set類的都實現了一個迭代器方法iterator(),它的返回值就是一個Iterator（迭代器）
while(it.hasNext())
{
System.out.println(it.next());
}
這樣就可以把集合里的每個元素遍歷一邊了....
⑹ java中什麼叫「迭代」，什麼叫「迭代器」
迭代
通俗點說 叫 一個個數過去，
實現這樣一個個數過去功能的東西，叫迭代器。
java迭代器 較多使用在容器中，如數組鏈表 ArrayList(反正就是能裝東西的玩意兒)
舉個例子：
//我們先往鏈表中裝東西
ArrayList a = new ArrayList();
a.add("東西1");
a.add("東西2");
//從鏈表中取東西怎麼辦呢，自然就用到了迭代器
//用法是這樣的
Iterator iter = a.iterator() ; //iter迭代器對象，可以用它來數了
while(iter.hasNext()){ //先往左數，如果有東西就執行{}里的語句
String m = (String)iter.next(); //數到什麼就拿出來 賦值給m
System.out.println(m); //拿出m用一下，即列印
}
⑺ java中的迭代器是什麼東西，有什麼作用，求通俗易懂解釋，
您好，提問者：
Java中的迭代器就是遍歷容器的，比如，我先寫個數組。
//String[]遍歷
String[]arr=newString[]{"aaa","bbb","ccc"};
for(inti=0;i<arr.length;i++){
System.out.println(arr[i]);
}
//下面講一下迭代器的用戶，迭代器比如：Iterator，用於迭代集合
List<String>list=newArrayList<String>();
for(Iterator<String>it=list.iterator();it.hasNext();){
Stringname=list.next();
System.out.println(name);
}
//其實ArrayList的底層就是一個數組，也可以使用循環來做
for(inti=0;i<list.size();i++){
System.out.println(list.get(i));
}
⑻ java中」遍歷「，」迭代「是什麼意思
首先解釋迭代。
迭代簡單的理解，重文字上可以才分為 迭(疊)加，代入(數)
是利用計算機高速、可從重復性高的特點進行計算的模式
迭代的最簡單應用就是，把四維整型數組，中的內容全部輸出。那就用四層循環慢慢取吧。
每次循環做的事情基本上是一件事，無外乎就是角標自增，然後取數。
再說遍歷。
遍歷很好理解，通過某種方式，不論是重頭到尾，還是用Hash演算法，
反正是從頭到尾把數據結構（鏈表、數組、樹、圖）所有的節點都訪問一遍，就叫遍歷。
像剛才，四維數組取數，就是一個遍歷的過程，
簡單的使用迭代的方式，從第一個元素一直遍歷（取）到最後一個元素。
稍微復雜的還有遍歷二叉樹，遍歷歐拉圖等。都用相應的演算法。
⑼ java中什麼叫迭代，什麼叫迭代器
迭代：
是重復反饋過程的活動，其目的通常是為了逼近所需目標或結果。每一次對過程的重復稱為一次「迭代」，而每一次迭代得到的結果會作為下一次迭代的初始值。
重復執行一系列運算步驟，從前面的量依次求出後面的量的過程。此過程的每一次結果，都是由對前一次所得結果施行相同的運算步驟得到的。例如利用迭代法*求某一數學問題的解。
對計算機特定程序中需要反復執行的子程序*(一組指令)，進行一次重復，即重復執行程序中的循環，直到滿足某條件為止，亦稱為迭代。
迭代器（Iterator）模式：
又叫做游標模式，它的含義是，提供一種方法訪問一個容器對象中各個元素，而又不需暴露該對象的內部細節。
注意：Java的集合框架的集合類，有的時候也稱為容器。
從定義上看，迭代器是為容器而生，它本質上就是一種遍歷的演算法。因為容器的實現千差萬別，很多時候不可能知道如何去遍歷一個集合對象的元素。Java為我們提供了使用迭代的介面，Java的所有集合類丟失進行迭代的。
簡單的說，迭代器就是一個介面Iterator，實現了該介面的類就叫做可迭代類，這些類多數時候指的就是java.util包下的集合類。
總結：
迭代器，提供一種訪問一個集合對象各個元素的途徑，同時又不需要暴露該對象的內部細節。java通過提供Iterator和Iterable倆個介面來實現集合類的可迭代性，迭代器主要的用法是：首先用hasNext（）作為循環條件，再用next（）方法得到每一個元素，最後在進行相關的操作。
(9)java迭代是什麼意思擴展閱讀
首先，創建了一個List的集合對象，並放入了倆個字元串對象，然後通過iterator()方法得到迭代器。iterator()方法是由Iterable介面規定的，ArrayList對該方法提供了具體的實現，在迭代器Iteartor介面中，有以下3個方法：
1、hasNext()該方法英語判斷集合對象是否還有下一個元素，如果已經是最後一個元素則返回false
2、next()把迭代器的指向移到下一個位置，同時，該方法返回下一個元素的引用
3、remove() 從迭代器指向的Collection中移除迭代器返回的最後一個元素，該操作使用的比較少。
注意：從Java5.0開始，迭代器可以被foreach循環所替代，但是foreach循環的本質也是使用Iterator進行遍歷的。
⑽ 什麼叫迭代啊。。
迭代演算法是用計算機解決問題的一種基本方法。它利用計算機運算速度快、適合做重復性操作的特點，讓計算機對一組指令（或一定步驟）進行重復執行，在每次執行這組指令（或這些步驟）時，都從變數的原值推出它的一個新值。
利用迭代演算法解決問題，需要做好以下三個方面的工作：
一、確定迭代變數。在可以用迭代演算法解決的問題中，至少存在一個直接或間接地不斷由舊值遞推出新值的變數，這個變數就是迭代變數。
二、建立迭代關系式。所謂迭代關系式，指如何從變數的前一個值推出其下一個值的公式（或關系）。迭代關系式的建立是解決迭代問題的關鍵，通常可以使用遞推或倒推的方法來完成。
三、對迭代過程進行控制。在什麼時候結束迭代過程？這是編寫迭代程序必須考慮的問題。不能讓迭代過程無休止地重復執行下去。迭代過程的控制通常可分為兩種情況：一種是所需的迭代次數是個確定的值，可以計算出來；另一種是所需的迭代次數無法確定。對於前一種情況，可以構建一個固定次數的循環來實現對迭代過程的控制；對於後一種情況，需要進一步分析出用來結束迭代過程的條件。
例 1 ： 一個飼養場引進一隻剛出生的新品種兔子，這種兔子從出生的下一個月開始，每月新生一隻兔子，新生的兔子也如此繁殖。如果所有的兔子都不死去，問到第 12 個月時，該飼養場共有兔子多少只？
分析： 這是一個典型的遞推問題。我們不妨假設第 1 個月時兔子的只數為 u 1 ，第 2 個月時兔子的只數為 u 2 ，第 3 個月時兔子的只數為 u 3 ，……根據題意，「這種兔子從出生的下一個月開始，每月新生一隻兔子」，則有
u 1 ＝ 1 ， u 2 ＝ u 1 ＋ u 1 × 1 ＝ 2 ， u 3 ＝ u 2 ＋ u 2 × 1 ＝ 4 ，……
根據這個規律，可以歸納出下面的遞推公式：
u n ＝ u n － 1 × 2 (n ≥ 2)
對應 u n 和 u n － 1 ，定義兩個迭代變數 y 和 x ，可將上面的遞推公式轉換成如下迭代關系：
y=x*2
x=y
讓計算機對這個迭代關系重復執行 11 次，就可以算出第 12 個月時的兔子數。參考程序如下：
cls
x=1
for i=2 to 12
y=x*2
x=y
next i
print y
end
例 2 ： 阿米巴用簡單分裂的方式繁殖，它每分裂一次要用 3 分鍾。將若干個阿米巴放在一個盛滿營養參液的容器內， 45 分鍾後容器內充滿了阿米巴。已知容器最多可以裝阿米巴 2 20 個。試問，開始的時候往容器內放了多少個阿米巴？請編程序算出。
分析： 根據題意，阿米巴每 3 分鍾分裂一次，那麼從開始的時候將阿米巴放入容器裡面，到 45 分鍾後充滿容器，需要分裂 45/3=15 次。而「容器最多可以裝阿米巴 2 20 個」，即阿米巴分裂 15 次以後得到的個數是 2 20 。題目要求我們計算分裂之前的阿米巴數，不妨使用倒推的方法，從第 15 次分裂之後的 2 20 個，倒推出第 15 次分裂之前（即第 14 次分裂之後）的個數，再進一步倒推出第 13 次分裂之後、第 12 次分裂之後、……第 1 次分裂之前的個數。
設第 1 次分裂之前的個數為 x 0 、第 1 次分裂之後的個數為 x 1 、第 2 次分裂之後的個數為 x 2 、……第 15 次分裂之後的個數為 x 15 ，則有
x 14 =x 15 /2 、 x 13 =x 14 /2 、…… x n-1 =x n /2 (n ≥ 1)
因為第 15 次分裂之後的個數 x 15 是已知的，如果定義迭代變數為 x ，則可以將上面的倒推公式轉換成如下的迭代公式：
x=x/2 （ x 的初值為第 15 次分裂之後的個數 2 20 ）
讓這個迭代公式重復執行 15 次，就可以倒推出第 1 次分裂之前的阿米巴個數。因為所需的迭代次數是個確定的值，我們可以使用一個固定次數的循環來實現對迭代過程的控制。參考程序如下：
cls
x=2^20
for i=1 to 15
x=x/2
next i
print x
end
例 3 ： 驗證谷角猜想。日本數學家谷角靜夫在研究自然數時發現了一個奇怪現象：對於任意一個自然數 n ，若 n 為偶數，則將其除以 2 ；若 n 為奇數，則將其乘以 3 ，然後再加 1 。如此經過有限次運算後，總可以得到自然數 1 。人們把谷角靜夫的這一發現叫做「谷角猜想」。
要求：編寫一個程序，由鍵盤輸入一個自然數 n ，把 n 經過有限次運算後，最終變成自然數 1 的全過程列印出來。
分析： 定義迭代變數為 n ，按照谷角猜想的內容，可以得到兩種情況下的迭代關系式：當 n 為偶數時， n=n/2 ；當 n 為奇數時， n=n*3+1 。用 QBASIC 語言把它描述出來就是：
if n 為偶數 then
n=n/2
else
n=n*3+1
end if
這就是需要計算機重復執行的迭代過程。這個迭代過程需要重復執行多少次，才能使迭代變數 n 最終變成自然數 1 ，這是我們無法計算出來的。因此，還需進一步確定用來結束迭代過程的條件。仔細分析題目要求，不難看出，對任意給定的一個自然數 n ，只要經過有限次運算後，能夠得到自然數 1 ，就已經完成了驗證工作。因此，用來結束迭代過程的條件可以定義為： n=1 。參考程序如下：
cls
input "Please input n=";n
do until n=1
if n mod 2=0 then
rem 如果 n 為偶數，則調用迭代公式 n=n/2
n=n/2
print "—";n;
else
n=n*3+1
print "—";n;
end if
loop
end
迭代法
迭代法是用於求方程或方程組近似根的一種常用的演算法設計方法。設方程為f(x)=0，用某種數學方法導出等價的形式x=g(x)，然後按以下步驟執行：
（1） 選一個方程的近似根，賦給變數x0；
（2） 將x0的值保存於變數x1，然後計算g(x1)，並將結果存於變數x0；
（3） 當x0與x1的差的絕對值還小於指定的精度要求時，重復步驟（2）的計算。
若方程有根，並且用上述方法計算出來的近似根序列收斂，則按上述方法求得的x0就認為是方程的根。上述演算法用C程序的形式表示為：
【演算法】迭代法求方程的根
{ x0=初始近似根；
do {
x1=x0；
x0=g(x1)； /*按特定的方程計算新的近似根*/
} while ( fabs(x0-x1)>Epsilon)；
printf(「方程的近似根是%f\n」，x0)；
}
迭代演算法也常用於求方程組的根，令
X=（x0，x1，…，xn-1）
設方程組為：
xi=gi(X) (I=0，1，…，n-1)
則求方程組根的迭代演算法可描述如下：
【演算法】迭代法求方程組的根
{ for (i=0;i
x=初始近似根;
do {
for (i=0;i
y=x;
for (i=0;i
x=gi(X);
for (delta=0.0,i=0;i
if (fabs(y-x)>delta) delta=fabs(y-x)；
} while (delta>Epsilon)；
for (i=0;i
printf(「變數x[%d]的近似根是 %f」，I，x)；
printf(「\n」)；
}
具體使用迭代法求根時應注意以下兩種可能發生的情況：
（1） 如果方程無解，演算法求出的近似根序列就不會收斂，迭代過程會變成死循環，因此在使用迭代演算法前應先考察方程是否有解，並在程序中對迭代的次數給予限制；
（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
# 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);
}
【問題】 背包問題
問題描述：有不同價值、不同重量的物品n件，求從這n件物品中選取一部分物品的選擇方案，使選中物品的總重量不超過指定的限制重量，但選中物品的價值之和最大。
設n 件物品的重量分別為w0、w1、…、wn-1，物品的價值分別為v0、v1、…、vn-1。採用遞歸尋找物品的選擇方案。設前面已有了多種選擇的方案，並保留了其中總價值最大的方案於數組option[ ]，該方案的總價值存於變數maxv。當前正在考察新方案，其物品選擇情況保存於數組cop[ ]。假定當前方案已考慮了前i-1件物品，現在要考慮第i件物品；當前方案已包含的物品的重量之和為tw；至此，若其餘物品都選擇是可能的話，本方案能達到的總價值的期望值為tv。演算法引入tv是當一旦當前方案的總價值的期望值也小於前面方案的總價值maxv時，繼續考察當前方案變成無意義的工作，應終止當前方案，立即去考察下一個方案。因為當方案的總價值不比maxv大時，該方案不會被再考察，這同時保證函數後找到的方案一定會比前面的方案更好。
對於第i件物品的選擇考慮有兩種可能：
（1） 考慮物品i被選擇，這種可能性僅當包含它不會超過方案總重量限制時才是可行的。選中後，繼續遞歸去考慮其餘物品的選擇。
（2） 考慮物品i不被選擇，這種可能性僅當不包含物品i也有可能會找到價值更大的方案的情況。
按以上思想寫出遞歸演算法如下：
try(物品i，當前選擇已達到的重量和，本方案可能達到的總價值tv)
{ /*考慮物品i包含在當前方案中的可能性*/
if(包含物品i是可以接受的)
{ 將物品i包含在當前方案中；
if (i
try(i+1,tw+物品i的重量,tv);
else
/*又一個完整方案，因為它比前面的方案好，以它作為最佳方案*/
以當前方案作為臨時最佳方案保存;
恢復物品i不包含狀態；
}
/*考慮物品i不包含在當前方案中的可能性*/
if (不包含物品i僅是可男考慮的)
if (i
try(i+1,tw,tv-物品i的價值)；
else
/*又一個完整方案，因它比前面的方案好，以它作為最佳方案*/
以當前方案作為臨時最佳方案保存;
}
為了理解上述演算法，特舉以下實例。設有4件物品，它們的重量和價值見表：
物品 0 1 2 3
重量 5 3 2 1
價值 4 4 3 1
並設限制重量為7。則按以上演算法，下圖表示找解過程。由圖知，一旦找到一個解，演算法就進一步找更好的佳。如能判定某個查找分支不會找到更好的解，演算法不會在該分支繼續查找，而是立即終止該分支，並去考察下一個分支。
按上述演算法編寫函數和程序如下：
【程序】
# include
# define N 100
double limitW,totV,maxV;
int option[N],cop[N];
struct { double weight;
double value;
}a[N];
int n;
void find(int i,double tw,double tv)
{ int k;
/*考慮物品i包含在當前方案中的可能性*/
if (tw+a.weight<=limitW)
{ cop=1;
if (i
else
{ for (k=0;k
option[k]=cop[k];
maxv=tv;
}
cop=0;
}
/*考慮物品i不包含在當前方案中的可能性*/
if (tv-a.value>maxV)
if (i
else
{ for (k=0;k
option[k]=cop[k];
maxv=tv-a.value;
}
}
void main()
{ int k;
double w,v;
printf(「輸入物品種數\n」);
scanf((「%d」,&n);
printf(「輸入各物品的重量和價值\n」);
for (totv=0.0,k=0;k
{ scanf(「%1f%1f」,&w,&v);
a[k].weight=w;
a[k].value=v;
totV+=V;
}
printf(「輸入限制重量\n」);
scanf(「%1f」,&limitV);
maxv=0.0;
for (k=0;k find(0,0.0,totV);
for (k=0;k
if (option[k]) printf(「%4d」,k+1);
printf(「\n總價值為%.2f\n」,maxv);
}
作為對比，下面以同樣的解題思想，考慮非遞歸的程序解。為了提高找解速度，程序不是簡單地逐一生成所有候選解，而是從每個物品對候選解的影響來形成值得進一步考慮的候選解，一個候選解是通過依次考察每個物品形成的。對物品i的考察有這樣幾種情況：當該物品被包含在候選解中依舊滿足解的總重量的限制，該物品被包含在候選解中是應該繼續考慮的；反之，該物品不應該包括在當前正在形成的候選解中。同樣地，僅當物品不被包括在候選解中，還是有可能找到比目前臨時最佳解更好的候選解時，才去考慮該物品不被包括在候選解中；反之，該物品不包括在當前候選解中的方案也不應繼續考慮。對於任一值得繼續考慮的方案，程序就去進一步考慮下一個物品。
【程序】
# include
# define N 100
double limitW;
int cop[N];
struct ele { double weight;
double value;
} a[N];
int k,n;
struct { int ;
double tw;
double tv;
}twv[N];
void next(int i,double tw,double tv)
{ twv.=1;
twv.tw=tw;
twv.tv=tv;
}
double find(struct ele *a,int n)
{ int i,k,f;
double maxv,tw,tv,totv;
maxv=0;
for (totv=0.0,k=0;k
totv+=a[k].value;
next(0,0.0,totv);
i=0;
While (i>=0)
{ f=twv.;
tw=twv.tw;
tv=twv.tv;
switch(f)
{ case 1: twv.++;
if (tw+a.weight<=limitW)
if (i
{ next(i+1,tw+a.weight,tv);
i++;
}
else
{ maxv=tv;
for (k=0;k
cop[k]=twv[k].!=0;
}
break;
case 0: i--;
break;
default: twv.=0;
if (tv-a.value>maxv)
if (i
{ next(i+1,tw,tv-a.value);
i++;
}
else
{ maxv=tv-a.value;
for (k=0;k
cop[k]=twv[k].!=0;
}
break;
}
}
return maxv;
}
void main()
{ double maxv;
printf(「輸入物品種數\n」);
scanf((「%d」,&n);
printf(「輸入限制重量\n」);
scanf(「%1f」,&limitW);
printf(「輸入各物品的重量和價值\n」);
for (k=0;k
scanf(「%1f%1f」,&a[k].weight,&a[k].value);
maxv=find(a,n);
printf(「\n選中的物品為\n」);
for (k=0;k
if (option[k]) printf(「%4d」,k+1);
printf(「\n總價值為%.2f\n」,maxv);
}
遞歸的基本概念和特點
程序調用自身的編程技巧稱為遞歸（ recursion）。
一個過程或函數在其定義或說明中又直接或間接調用自身的一種方法，它通常把一個大型復雜的問題層層轉化為一個與原問題相似的規模較小的問題來求解，遞歸策略只需少量的程序就可描述出解題過程所需要的多次重復計算，大大地減少了程序的代碼量。遞歸的能力在於用有限的語句來定義對象的無限集合。用遞歸思想寫出的程序往往十分簡潔易懂。
一般來說，遞歸需要有邊界條件、遞歸前進段和遞歸返回段。當邊界條件不滿足時，遞歸前進；當邊界條件滿足時，遞歸返回。
注意：
(1) 遞歸就是在過程或函數里調用自身;
(2) 在使用遞增歸策略時，必須有一個明確的遞歸結束條件，稱為遞歸出口。