[Swift]LeetCode145. 二叉树的后序遍历 | Binary Tree Postorder Traversal

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9968229.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Given a binary tree, return the postorder traversal of its nodes' values.

Example:

Input: [1,null,2,3]
   1
    
     2
    /
   3

Output: [3,2,1]

Follow up: Recursive solution is trivial, could you do it iteratively?

---

 给定一个二叉树，返回它的 后序 遍历。

示例:

输入: [1,null,2,3]  
   1
    
     2
    /
   3 

输出: [3,2,1]

进阶: 递归算法很简单，你可以通过迭代算法完成吗？

---

 8ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */

struct NodeId {
    let node: TreeNode 
    let id: Int 
}

class Solution {

    func postorderTraversal(_ root: TreeNode?) -> [Int] {
        var node = root 
        var stack = [TreeNode]()
        var res = [Int]()
        
        while stack.count > 0 || node != nil {
            if node != nil {
                res.insert(node!.val, at: 0)
                stack.append(node!)
                node = node!.right 
                
            } else {
                node = stack.removeLast().left 
            }
        }
        
        return res 
    }
}

---

12ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func postorderTraversal(_ root: TreeNode?) -> [Int] {
        var res: [Int] = []
        
        if root?.left != nil{
            let left = postorderTraversal(root?.left)
            res.append(contentsOf: left)
        }
        
        if root?.right != nil{
            let right = postorderTraversal(root?.right)
            res.append(contentsOf: right)
        }
        
        if let rootval = root?.val{
            
            res.append(rootval)
        }
        
        return res
    }
}

---

 12ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func postorderTraversal(_ root: TreeNode?) -> [Int] {
        guard let node = root else { return [] }
        
        var results = [Int]()
        traverse(node, &results)
        return results
    }
    
    func traverse(_ root: TreeNode?, _ results: inout [Int]) {
        guard let node = root else { return }
        
        traverse(node.left, &results)
        traverse(node.right, &results)
        results.append(node.val)
    }
}

---

16ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func postorderTraversal(_ root: TreeNode?) -> [Int] {
        guard let root = root else {
            return []
        }
        
        var result = [Int]()
        var stack = [root]
        
        while !stack.isEmpty {
            let node = stack.removeLast()
            result.append(node.val)
            if let leftNode = node.left {
                stack.append(leftNode)
            }
            if let rightNode = node.right {
                stack.append(rightNode)
            }
        }
        
        return result.reversed()
    }
    
    func postorderTraversal_Rec(_ root: TreeNode?) -> [Int] {
        var result = [Int]()
        
        postorder(root, &result)
        
        return result
    }
    
    private func postorder(_ root: TreeNode?, _ result: inout [Int]) {
        guard let root = root else {
            return
        }
        
        postorder(root.left, &result)
        postorder(root.right, &result)
        result.append(root.val)
    }
}

---

20ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    var arr = [Int]()
    func postorderTraversal(_ root: TreeNode?) -> [Int] {
        if let r = root {
            postorderTraversal(r.left)
            postorderTraversal(r.right)
            arr.append(r.val)
            return arr
        }
        else {
            return arr
        }
    }
}

---

20ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func postorderTraversal(_ root: TreeNode?) -> [Int] {
        guard (root != nil) else {
            return []
        }
        var result = [Int]()
        result += self.postorderTraversal(root?.left)
        result += self.postorderTraversal(root?.right)
        result.append((root?.val)!)
        return result
    }
}

---

32ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func postorderTraversal(_ root: TreeNode?) -> [Int] {
        class Node {
            let elem: TreeNode?
            var n: Int
            init(elem: TreeNode?, n: Int = 0) {
              self.elem = elem
              self.n = n
            }
        }
        var result: [TreeNode] = []
        var stack: [Node] = []
        var node: Node = Node(elem: root, n: 0)
        while node.elem != nil || !stack.isEmpty {
            if node.elem != nil {
              node.n = node.n + 1
              stack.append(node)
              node = Node(elem: node.elem!.left, n: 0)
            } else {
              node = stack.last!
              node.n = node.n + 1
              if node.n == 3 {
                node = stack.removeLast()
                result.append(node.elem!)
                node = Node(elem: nil, n: 0)
              } else {
                node = Node(elem: node.elem!.right, n: 0)
              }
            }
        }
        let ans = result.map {
            $0.val
        }
        return ans
    }
}