From 50b63f844131e703e2191cfa0442394079092708 Mon Sep 17 00:00:00 2001
From: konng <konng_0120@qq.com>
Date: Sun, 31 Oct 2021 13:19:47 +0800
Subject: [PATCH] =?UTF-8?q?=E6=9B=B4=E6=96=B0=20golang=20=E4=BA=8C?=
 =?UTF-8?q?=E5=8F=89=E6=A0=91=E9=81=8D=E5=8E=86=E7=9A=84=E6=89=80=E6=9C=89?=
 =?UTF-8?q?=E4=BB=A3=E7=A0=81=EF=BC=8C=E7=BD=AE=E6=8D=A2=E4=B8=BA=E5=92=8C?=
 =?UTF-8?q?=20c++=20=E6=A8=A1=E6=9D=BF=E7=9B=B8=E5=90=8C=E7=9A=84=E9=80=BB?=
 =?UTF-8?q?=E8=BE=91=EF=BC=8C=E8=80=8C=E4=B8=8D=E6=98=AF=E6=96=B0=E7=9A=84?=
 =?UTF-8?q?=E4=BB=A3=E7=A0=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

之前的 golang 代码很不美观，并且他的逻辑和 c++ 的不一样，谁还专门记两个模板啊，
并且连缩进也没有，所以我就重写了一份
现在的 golang 逻辑和 c++ 相同 并且也有缩进，也没有废话代码，舒服多了
---
 ...55\344\273\243\351\201\215\345\216\206.md" | 132 ++++++++----------
 1 file changed, 60 insertions(+), 72 deletions(-)

diff --git "a/problems/\344\272\214\345\217\211\346\240\221\347\232\204\350\277\255\344\273\243\351\201\215\345\216\206.md" "b/problems/\344\272\214\345\217\211\346\240\221\347\232\204\350\277\255\344\273\243\351\201\215\345\216\206.md"
index 6889ecc05f..7aff05413e 100644
--- "a/problems/\344\272\214\345\217\211\346\240\221\347\232\204\350\277\255\344\273\243\351\201\215\345\216\206.md"
+++ "b/problems/\344\272\214\345\217\211\346\240\221\347\232\204\350\277\255\344\273\243\351\201\215\345\216\206.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
 }
 ```