二叉樹的遍歷想必大家都不陌生，主要有三種遍歷方式：前序遍歷（pre-order traversal），中序遍歷（in-order ~）還有后序遍歷（post-order ~）。所謂前中后，就是遍歷根節點相對于遍歷子樹的順序。這里假設讀者已經了解了最基礎的三種遍歷的定義，不再贅述。
這篇文章的目的就是用代碼實現二叉樹的遍歷。不僅要實現，還要多種方法實現，還要讓讀者能記住一些寫法。因為二叉樹遍歷應用實在很廣，是很基礎很實用的算法，不得不熟悉。
本篇文章編程語言為Kotlin（Python：？？？）。不熟悉這門語言的也沒關系，大致應該還是能看懂。
樹節點的定義：
class TreeNode(var value: Int = 0, var left: TreeNode? = null, var right: TreeNode? = null)
簡單的遞歸
二叉樹簡直就是為遞歸而生的。一棵二叉樹可以看成左子樹，根節點和右子樹，也就是說往往可以對左右子樹遞歸調用。
對于遍歷，遞歸無疑是最簡單的解決方式。遞歸的思維是這樣的：假設遞歸函數的作用就是以某種方式遍歷樹，那么再來看左子樹，根節點和右子樹，無非就是按照某個順序對左右子樹調用并把根節點放到結果里。
還是看代碼吧，真的很簡單（x?.let{}表示如果x不為null就執行括號里面的內容，it在括號內指代x）：
// T:O(n) S:O(h)
fun inOrderRecur(root: TreeNode): List<Int> {
val ret = mutableListOf<Int>()
root.left?.let { ret.addAll(inOrderRecur(it)) }
ret.add(root.value)
root.right?.let { ret.addAll(inOrderRecur(it)) }
return ret
}
// T:O(n) S:O(h)
fun preOrderRecur(root: TreeNode): List<Int> {
val ret = mutableListOf<Int>()
ret.add(root.value)
root.left?.let { ret.addAll(preOrderRecur(it)) }
root.right?.let { ret.addAll(preOrderRecur(it)) }
return ret
}
// T:O(n) S:O(h)
fun postOrderRecur(root: TreeNode): List<Int> {
val ret = mutableListOf<Int>()
root.left?.let { ret.addAll(postOrderRecur(it)) }
root.right?.let { ret.addAll(postOrderRecur(it)) }
ret.add(root.value)
return ret
}
可以看到，遞歸代碼真的很短，也非常好記憶。
不過遞歸畢竟是遞歸，這里也并沒有tail recursion，效率總是不如迭代方法的。如何用非遞歸方法來實現遍歷呢？
模仿遞歸的棧解法
一個很科學的思路就是把遞歸“翻譯”成迭代。既然我已經有了這么簡單方便的遞歸方法，我只需要把它們轉化成迭代方法，不就可以了嗎？
那么這里的關鍵就是：如何“翻譯”？
要模仿遞歸的思路，首先需要棧，因為遞歸雖然沒有聲明棧，但是系統提供了棧。
再仔細思考一下會發現節點的遍歷順序很重要，有些節點會留在之后再遍歷。
有沒有一種類似于遞歸的棧解法，用很相似的代碼來實現三種遍歷？
有的。訣竅就是引入一個表示是否已經遍歷過的布爾值isVisited。遞歸其實也是有這么一個過程的，從第一次調用，到子問題，然后再回來。
節點第一次進棧時，布爾值為false，之后再出現的時候，假設是true，那么添加到結果里，否則改為true再按照遍歷順序進棧。
代碼如下：
// T:O(n) S:O(h)
fun inOrder(root: TreeNode): List<Int> {
val stk = Stack<Pair<TreeNode?, Boolean>>()
val ret = mutableListOf<Int>()
stk.push(Pair(root, false))
while (stk.isNotEmpty()) {
val p = stk.pop()
val cur = p.first
val isVisited = p.second
if (cur == null) {
continue
} else {
if (isVisited) {
ret.add(cur.value)
} else {
stk.push(Pair(cur.right, false))
stk.push(Pair(cur, true))
stk.push(Pair(cur.left, false))
}
}
}
return ret
}
// T:O(n) S:O(h)
fun preOrder(root: TreeNode): List<Int> {
val stk = Stack<Pair<TreeNode?, Boolean>>()
val ret = mutableListOf<Int>()
stk.push(Pair(root, false))
while (stk.isNotEmpty()) {
val p = stk.pop()
val cur = p.first
val isVisited = p.second
if (cur == null) {
continue
} else {
if (isVisited) {
ret.add(cur.value)
} else {
stk.push(Pair(cur.right, false))
stk.push(Pair(cur.left, false))
stk.push(Pair(cur, true))
}
}
}
return ret
}
// T:O(n) S:O(h)
fun postOrder(root: TreeNode): List<Int> {
val stk = Stack<Pair<TreeNode?, Boolean>>()
val ret = mutableListOf<Int>()
stk.push(Pair(root, false))
while (stk.isNotEmpty()) {
val p = stk.pop()
val cur = p.first
val isVisited = p.second
if (cur == null) {
continue
} else {
if (isVisited) {
ret.add(cur.value)
} else {
stk.push(Pair(cur, true))
stk.push(Pair(cur.right, false))
stk.push(Pair(cur.left, false))
}
}
}
return ret
}
這種解法代碼稍長一點，好在三種解法幾乎一模一樣，除了進棧的順序不同。這里進棧的順序就是對遍歷順序倒著來，因為先進后出。
各顯神通的棧解法
另一種思路是拋棄遞歸的思路，而分別針對三種遞歸的特性來用棧實現遍歷。這樣一來，每種解法都顯得更加優雅，但是不同解法之間又不太一樣，至少像上面那樣只需要記一種解法是不可能的了。
代碼：
// T:O(n) S:O(h)
fun inOrderWithStack(root: TreeNode): List<Int> {
val stk = Stack<TreeNode>()
val ret = mutableListOf<Int>()
var cur: TreeNode? = root
while (cur != null || stk.isNotEmpty()) {
while (cur != null) {
stk.push(cur)
cur = cur.left
}
cur = stk.pop()
ret.add(cur.value)
cur = cur.right
}
return ret
}
// T:O(n) S:O(h)
fun preOrderWithStack(root: TreeNode): List<Int> {
val stk = Stack<TreeNode>()
val ret = mutableListOf<Int>()
stk.push(root)
while (stk.isNotEmpty()) {
val cur = stk.pop()
ret.add(cur.value)
cur.right?.let { stk.push(it) }
cur.left?.let { stk.push(it) }
}
return ret
}
// T:O(n) S:O(h)
fun postOrderWithDoubleStacks(root: TreeNode): List<Int> {
val stk1 = Stack<TreeNode>()
val stk2 = Stack<TreeNode>()
stk1.push(root)
while (stk1.isNotEmpty()) {
val cur = stk1.pop()
stk2.push(cur)
cur.left?.let { stk1.push(it) }
cur.right?.let { stk1.push(it) }
}
return stk2.map { it.value }.reversed()
}
三種解法雖然不同，但又有千絲萬縷的聯系。中序、前序都只需要一個棧，后序需要兩個棧，但后序和前序其實很相似。
挑戰：Morris遍歷
說到樹的遍歷，不提及Morris遍歷總是不完整的。
Morris遍歷能以O(n)的時間復雜度和O(1)的空間復雜度來實現三種遍歷，相對應的代價就是代碼更為復雜。
在實際面試中，除非明確要求，或者把握很大，且又是瓶頸，不然沒必要為了這O(n)的空間復雜度來用Morris，尤其是最復雜的后序遍歷。當然，做出解答之后也許可以提一下，說用Morris能得到更好的空間復雜度。
既然是O(1)的空間復雜度，說明Morris算法不用棧，那么如何回到以前遍歷過的節點呢？
答案就是指針。
原本樹的葉子節點，左右兩個指針都是空的，Morris就在這方面“耍花招”，讓其右指針指向遍歷順序該返回的節點。
中序
以中序遍歷為例，考慮以下這棵樹：
1
/
3
/
4 2
/
5
遍歷的結果應該是54321，也就是說5的返回點是4，4的返回點是3，2的返回點應該是1。
還是來看代碼吧：
// T:O(n) S:O(1)
fun inOrderMorris(root: TreeNode): List<Int> {
val ret = mutableListOf<Int>()
var cur: TreeNode? = root
while (cur != null) {
if (cur.left == null) {
ret.add(cur.value)
cur = cur.right
} else {
var node: TreeNode = cur.left!!
while (node.right != null && node.right != cur)
node = node.right!!
if (node.right == null) {
node.right = cur
cur = cur.left
} else {
ret.add(cur.value)
node.right = null
cur = cur.right
}
}
}
return ret
}
解釋一下這個代碼對于上面那棵樹的執行過程：
- cur為1，此時把2的右指針指向1，cur往左走一步；
- cur為3，把4的右指針指向3，cur往左走一步；
- cur為4，把5的右指針指向4，cur往左走一步；
- cur為5，此時把5加入結果，通過右指針返回4；
- cur為4，此時5的右指針還指向4，說明4是第二次來了，把5的右指針復原，把4加入結果，cur往右走一步；
- cur為3，類似地把4的右指針復原，把3加入結果，cur往右走一步；
- cur為2，把2加入結果，通過右指針返回1；
- cur為1，把2的右指針復原，把1加入結果，往右走一步；
- cur為null，結束
可以發現，Morris遍歷其實要走兩遍節點，第一遍主要是架設“后路”。
仔細思考，根節點左子樹的最右節點，不就是中序遍歷里面根節點的前一個元素嗎？因為是左子樹的最右節點，說明左子樹的中序已經完成，接下來就是返回根節點了。
第二遍就是獲得結果并復原指針。通過是否有“后路”來確定是不是第二遍，然后再做行動。
總而言之，非常巧妙。
Morris本人其實就提出了中序遍歷，其他人根據中序遍歷，推出了前序和后序遍歷的Morris方法。
前序
再來看看前序遍歷：
// T:O(n) S:O(1)
fun preOrderMorris(root: TreeNode): List<Int> {
val ret = mutableListOf<Int>()
var cur: TreeNode? = root
while (cur != null) {
if (cur.left == null) {
ret.add(cur.value)
cur = cur.right
} else {
var node = cur.left
while (node?.right != null && node.right != cur)
node = node.right
if (node?.right == null) {
ret.add(cur.value)
node?.right = cur
cur = cur.left
} else {
node.right = null
cur = cur.right
}
}
}
return ret
}
這個代碼明顯和中序非常像。總的來說，架設“后路”的思路還是一樣的，只不過加入結果的時機不同。
還是以上面那棵樹為例：
- cur為1，先把1加入結果，再讓2指向1，cur往左走一步；
- cur為3，把3加入結果，讓4指向3，cur往左走一步；
- cur為4，把4加入結果，讓5指向4，cur往左走一步；
- cur為5，把5加入結果，往右走一步，通過后路返回4；
- cur為4，把5的后路復原，往右走一步，通過后路返回3；
- cur為3，把4的后路復原，往右走一步；
- cur為2，把2加入結果，往右走一步，通過后路返回1；
- cur為1，把2的后路復原，往右走一步；
- cur為null，結束
可以看到，中序和前序的行動軌跡是完全一樣的，而且都在最左端加入結果。區別在于，中序是回來的時候加入結果，前序是第一次就加入結果。
后序
Morris的后序又是另一個故事了，比前序和中序都要復雜很多。
// T:O(n) S:O(1)
fun postOrderMorris(root: TreeNode): List<Int> {
val dummy = TreeNode()
dummy.left = root
val ret = mutableListOf<Int>()
var cur: TreeNode? = dummy
while (cur != null) {
if (cur.left == null) {
cur = cur.right
} else {
var node = cur.left
while (node?.right != null && node.right != cur)
node = node.right
if (node?.right == null) {
node?.right = cur
cur = cur.left
} else {
ret.addAll(traceBack(cur.left!!, node))
node.right = null
cur = cur.right
}
}
}
return ret
}
fun traceBack(from: TreeNode, to: TreeNode): List<Int> {
val ret = mutableListOf<Int>()
var cur: TreeNode = from
while (cur !== to) {
ret.add(cur.value)
cur = cur.right!!
}
ret.add(to.value)
return ret.reversed()
}
試推演執行步驟如下：
- cur為dummy，將1的右指針指向dummy，cur往左走一步；
- cur為1，將2的右指針指向1，cur往左走一步；
- cur為3，將4的右指針指向3，cur往左走一步；
- cur為4，將5的右指針指向4，cur往左走一步；
- cur為5，此時直接通過后路返回4；
- cur為4，將5加入結果，并復原5的右指針，通過后路返回3；
- cur為3，類似地將4加入結果，復原4的右指針，向右走一步；
- cur為2，通過后路返回1；
- cur為1，將2、3加入結果，復原2的右指針，向右走一步；
- cur為dummy，將1加入結果，復原1的右指針，向右走一步；
- cur為null，結束
架設路徑仍舊是老套路，只是這次不僅使用了一個dummy node，而且還需要一個子函數來配合獲取結果，確實復雜了很多。
