Merge pull request #883 from fengwei2002/patch-3

更新 golang 二叉树遍历的所有代码，置换为和 c++ 模板相同的逻辑，而不是新的代码

problems/二叉树的迭代遍历.md

@@ -299,108 +299,96 @@ class Solution:
 
 
 Go：
+
 > 迭代法前序遍历
 
 ```go
-//迭代法前序遍历
-/**
- type Element struct {
-    // 元素保管的值
-    Value interface{}
-    // 内含隐藏或非导出字段
-}
-
-func (l *List) Back() *Element 
-前序遍历：中左右
-压栈顺序：右左中
- **/
 func preorderTraversal(root *TreeNode) []int {
+    ans := []int{}
+
 	if root == nil {
-		return nil
+		return ans
 	}
-	var stack = list.New()
-    stack.PushBack(root.Right)
-    stack.PushBack(root.Left)
-    res:=[]int{}
-    res=append(res,root.Val)
-    for stack.Len()>0 {
-        e:=stack.Back()
-        stack.Remove(e)
-        node := e.Value.(*TreeNode)//e是Element类型，其值为e.Value.由于Value为接口，所以要断言
-        if node==nil{
-            continue
+
+	st := list.New()
+    st.PushBack(root)
+
+    for st.Len() > 0 {
+        node := st.Remove(st.Back()).(*TreeNode)
+
+        ans = append(ans, node.Val)
+        if node.Right != nil {
+            st.PushBack(node.Right)
+        }
+        if node.Left != nil {
+            st.PushBack(node.Left)
         }
-        res=append(res,node.Val)
-        stack.PushBack(node.Right)
-        stack.PushBack(node.Left)
     }
-    return res
+    return ans
 }
 ```
 
 > 迭代法后序遍历
 
 ```go
-//迭代法后序遍历
-//后续遍历：左右中
-//压栈顺序：中右左(按照前序遍历思路)，再反转结果数组
 func postorderTraversal(root *TreeNode) []int {
+    ans := []int{}
+
 	if root == nil {
-		return nil
+		return ans
 	}
-	var stack = list.New()
-    stack.PushBack(root.Left)
-    stack.PushBack(root.Right)
-    res:=[]int{}
-    res=append(res,root.Val)
-    for stack.Len()>0 {
-        e:=stack.Back()
-        stack.Remove(e)
-        node := e.Value.(*TreeNode)//e是Element类型，其值为e.Value.由于Value为接口，所以要断言
-        if node==nil{
-            continue
+
+	st := list.New()
+    st.PushBack(root)
+
+    for st.Len() > 0 {
+        node := st.Remove(st.Back()).(*TreeNode)
+
+        ans = append(ans, node.Val)
+        if node.Left != nil {
+            st.PushBack(node.Left)
+        }
+        if node.Right != nil {
+            st.PushBack(node.Right)
         }
-        res=append(res,node.Val)
-        stack.PushBack(node.Left)
-        stack.PushBack(node.Right)
     }
-    for i:=0;i<len(res)/2;i++{
-        res[i],res[len(res)-i-1] = res[len(res)-i-1],res[i]
+    reverse(ans)
+    return ans
+}
+
+func reverse(a []int) {
+    l, r := 0, len(a) - 1
+    for l < r {
+        a[l], a[r] = a[r], a[l]
+        l, r = l+1, r-1
     }
-    return res
 }
 ```
 
 > 迭代法中序遍历
 
 ```go
-//迭代法中序遍历
 func inorderTraversal(root *TreeNode) []int {
-    rootRes:=[]int{}
-    if root==nil{
-       return nil
+    ans := []int{}
+    if root == nil {
+        return ans
     }
-    stack:=list.New()
-    node:=root
-    //先将所有左节点找到，加入栈中
-    for node!=nil{
-        stack.PushBack(node)
-        node=node.Left
-    }
-    //其次对栈中的每个节点先弹出加入到结果集中，再找到该节点的右节点的所有左节点加入栈中
-    for stack.Len()>0{
-        e:=stack.Back()
-        node:=e.Value.(*TreeNode)
-        stack.Remove(e)
-        //找到该节点的右节点，再搜索他的所有左节点加入栈中
-        rootRes=append(rootRes,node.Val)
-        node=node.Right
-        for node!=nil{
-            stack.PushBack(node)
-            node=node.Left
+
+    st := list.New()
+    cur := root
+
+    for cur != nil || st.Len() > 0 {
+        if cur != nil {
+            st.PushBack(cur)
+            cur = cur.Left
+        } else {
+            cur = st.Remove(st.Back()).(*TreeNode)
+            ans = append(ans, cur.Val)
+            cur = cur.Right
         }
     }
-    return rootRes
+
+    return ans
 }
 ```