前言
本文收錄於專輯:http://dwz.win/HjK,點選解鎖更多資料結構與演算法的知識。
你好,我是彤哥,一個每天爬二十六層樓還不忘讀原始碼的硬核男人。
上一節,我們使用點陣圖介紹了12306搶票演算法的實現,沒有收到推送的同學可以點選上方專輯檢視,或者在公主號歷史訊息中檢視。
在上一節的最後,彤哥收到最新情報,說是所有的遞迴都可以改寫成非遞迴,是不是真的呢?如何實現呢?有沒有套路呢?
讓我們帶著這些問題進入今天的學習吧。
何為遞迴?
所謂遞迴,是指程式在執行的過程中呼叫自身的行為。
這種行為也不能無限制地進行下去,得有個出口,叫做邊界條件
,所以,遞迴可以分成三個段:前進段、達到邊界條件,返回段,在這三個段我們都可以做一些事,比如前進段對問題規模進行縮小,返回段對結果進行整理。
這麼說可能比較抽象,讓我們看一個簡單的案例:
如何用遞迴實現1到100的相加?
1到100相加使用迴圈大家都會解,程式碼如下:
public class Sum {
public static void main(String[] args) {
System.out.println(sumCircle(1, 100));
}
private static int sumCircle(int min, int max) {
int sum = 0;
for (int i = min; i <= max; i++) {
sum += i;
}
return sum;
}
}
那麼,如何使用遞迴實現呢?
如何快速實現遞迴?
首先,我們要找到這道題的邊界條件,1到100相加,邊界條件可以是1,也可以是100,如果從1開始,那麼邊界條件就是100,反之亦然。
找到了邊界條件之後,就是將問題規模縮小,對於這道題,計算1到100相加,那麼,能不能先計算1到99相加再把100加上呢?肯定是可以的,這樣問題的規模就縮小了,直到,問題規模縮小為1到1相加為止。
OK,讓我們看程式碼實現:
private static int sumRecursive(int min, int max) {
// 邊界條件
if (min >= max) {
return min;
}
// 問題規模縮小
int sum = sumRecursive(min, max - 1);
// 加上當前值
sum += max;
// 返回
return sum;
}
是不是很簡單?還可以更簡單:
private static int sumRecursive2(int min, int max) {
return min >= max ? min : sumRecursive2(min, max - 1) + max;
}
686?
所以,使用遞迴最重要的就是找到邊界條件,然後讓問題的規模朝著邊界條件的方向一直縮小,直到達到邊界條件,最後依次返回即可,這也是快速實現遞迴的套路。
這麼看來,使用遞迴似乎很簡單,但是,它有沒有什麼缺點呢?
要了解缺點就得從遞迴的本質入手。
遞迴的本質是什麼?
我們知道,JVM啟動的時候有個引數叫做-Xss
,它不是表示XSS攻擊哈,它是指每個執行緒可以使用的執行緒棧的大小。
那麼,什麼又是執行緒棧呢?
棧大家都理解了,我們在前面的章節也學習過了,使用棧,可以實現計算器的功能,非常方便。
執行緒棧,顧名思義,就是指執行緒執行過程中使用的棧。
那麼,執行緒在執行的過程中為什麼要使用棧呢?
這就不得不說方法呼叫的本質了。
舉個簡單的例子:
private static int a(int num) {
int a = 1;
return a + b(num);
}
private static int b(int num) {
int b = 2;
return c(num) + b;
}
private static int c(int num) {
int c = 3;
return c + num;
}
在這段程式碼中,方法a() 呼叫 方法b(),方法b() 呼叫 方法c(),在實際執行的過程中,是這樣處理的:呼叫方法a()時,發現需要呼叫方法b()才能返回,那就把方法a()及其狀態儲存到棧中,然後呼叫方法b(),同樣地,呼叫方法b()時,發現需要先呼叫方法c()才能返回,那就把方法b()及其狀態入棧,然後呼叫方法c(),呼叫方法c()時,不需要額外呼叫別的方法了,計算完畢返回,返回之後,從棧頂取出方法b()及當時的狀態,繼續執行方法b(),方法b()執行完畢,返回,再從棧中取出方法a()及當時的狀態,計算完畢,方法a()返回,程式等待結束。
還是上圖吧:
所以,方法呼叫的本質,就是棧的使用。
同理,遞迴的呼叫就是方法的呼叫,所以,遞迴的呼叫,也是棧的使用,不過,這個棧會變得非常大,比如,對於1到100相加,就有99次入棧出棧的操作。
因此,總結起來,遞迴有以下兩個缺點:
- 操作耗時,因為牽涉到大量的入棧出棧操作;
- 有可能導致執行緒棧溢位,因為遞迴呼叫佔用了執行緒棧很大的空間。
那麼,我們是不是就不要使用遞迴了呢?
當然不是,之所以使用遞迴,就是因為它使用起來非常簡單,能夠快速地解決我們的問題,合理控制遞迴呼叫鏈的長度,就是一個好遞迴。
既然,遞迴呼叫的本質,就是棧的使用,那麼,我們能不能自己模擬一個棧,將遞迴呼叫改成非遞迴呢?
當然可以。
修改遞迴為非遞迴的套路
還是使用上面的例子,現在我們需要把遞迴修改成非遞迴,且不是使用for迴圈的那種形式,要怎麼實現呢?
首先,我們要自己模擬一個棧;
然後,找到邊界條件;
最後,朝著邊界條件的方向縮小問題規模;
OK,上程式碼:
private static int sumNonRecursive(int min, int max) {
int sum = 0;
// 宣告一個棧
Stack<Integer> stack = new Stack<Integer>();
stack.push(max);
while (!stack.isEmpty()) {
if (max > min) {
// 要計算max,先計算max-1
stack.push(--max);
} else {
// 問題規模縮小到一定程度,計算返回
sum += stack.pop();
}
}
return sum;
}
好了,是不是很簡單,其實跟遞迴的套路是一樣的,只不過改成自己模擬棧來實現。
這個例子可能不是那麼明顯,我們再舉個二叉樹遍歷的例子來看一下。
public class BinaryTree {
Node root;
// 插入元素
void put(int value) {
if (root == null) {
root = new Node(value);
} else {
Node parent = root;
while (true) {
if (value <= parent.value) {
if (parent.left == null) {
parent.left = new Node(value);
return;
} else {
parent = parent.left;
}
} else {
if (parent.right == null) {
parent.right = new Node(value);
return;
} else {
parent = parent.right;
}
}
}
}
}
// 先序遍歷
void preTraversal(Node x) {
if (x == null) return;
System.out.print(x.value + ",");
preTraversal(x.left);
preTraversal(x.right);
}
static class Node {
int value;
Node left;
Node right;
public Node(int value) {
this.value = value;
}
}
public static void main(String[] args) {
BinaryTree binaryTree = new BinaryTree();
binaryTree.put(3);
binaryTree.put(1);
binaryTree.put(2);
binaryTree.put(7);
binaryTree.put(8);
binaryTree.put(5);
binaryTree.put(4);
binaryTree.put(6);
binaryTree.put(9);
binaryTree.put(0);
binaryTree.preTraversal(binaryTree.root);
}
}
我這裡隨手寫了一顆二叉樹,並實現了其先序遍歷,這個測試用例中的二叉樹長這個樣子:
所以,這個二叉樹的先序遍歷結果為3,1,0,2,7,5,4,6,8,9,
。
可以看到,使用遞迴先序遍歷二叉樹非常簡單,而且程式碼清晰易懂,那麼,它如何修改為非遞迴實現呢?
首先,我們要自己模擬一個棧;
然後,找到邊界條件,為節點等於空時;
最後,縮小問題規模,這裡是先把右子樹壓棧,再把左子樹壓棧,因為先左後右;
好了,來看程式碼實現:
// 先序遍歷非遞迴形式
void nonRecursivePreTraversal(Node x) {
// 自己模擬一個棧
Stack<Node> stack = new Stack<Node>();
stack.push(x);
while (!stack.isEmpty()) {
Node tmp = stack.pop();
// 隱含的邊界條件
if (tmp != null) {
System.out.print(tmp.value + ",");
// 縮小問題規模
stack.push(tmp.right);
stack.push(tmp.left);
}
}
}
掌握了這個套路是不是把遞迴改寫為非遞迴非常簡單,不過,改寫之後的程式碼顯然沒有遞迴那麼清晰。
好了,遞迴改寫為非遞迴的套路我們就講到這裡,不知道你Get到了沒有呢?你也可以找個遞迴自己來改寫試試看。
後記
本節,我們從遞迴的概念入手,學習瞭如何快速實現遞迴,以及遞迴的本質,最後,學習了遞迴改寫為非遞迴的套路。
本質上,這也是棧這種資料結構的常規用法。
既然講到了棧,不講佇列是不是有點過分?
所以,下一節,遍歷各種原始碼的彤哥將介紹如何實現高效能的佇列,想了解其中的套路嗎?還不快點來關注我!
關注公號主“彤哥讀原始碼”,解鎖更多原始碼、基礎、架構知識。