【Leetcode】二叉树的递归遍历

先序遍历

题目链接

【Leetcode】二叉树的递归遍历

代码一：

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func preorderTraversal(root *TreeNode) []int {
    ans := []int{}
    // 声明一个函数变量dfs
    var dfs func(*TreeNode)
    // 需要先声明函数变量，才能在函数内部使用
    dfs = func(node *TreeNode) {
        if node == nil {
            return 
        }
        ans = append(ans, node.Val)
        dfs(node.Left)
        dfs(node.Right)
    }
    dfs(root)
    return ans
}

代码二：

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */

func preorderTraversal(root *TreeNode) []int {
    if root == nil {
        return []int{};
    }
    ans := []int{}
    dfs(root, &ans)
    return ans
}

func dfs(root *TreeNode, ans *[]int){
    if root != nil{
        *ans = append(*ans, root.Val)
        dfs(root.Left, ans)
        dfs(root.Right, ans)
    }
}

迭代法

先序遍历：

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func preorderTraversal(root *TreeNode) []int {
    if root == nild {
        return []int{}
    }
    // 迭代法
    ans := []int{}
    // 辅助栈
    s := []*TreeNode{}
    // 只要栈中有元素 或者走到右孩子不为nil
    for len(s) > 0 || root != nil {
        // 走到最左左孩子
        for root != nil {
            // 添加结果
            ans = append(ans, root.Val)
            // 路径节点入栈
            s = append(s, root)
            // 跳到左孩子节点
            root = root.Left
        }
        // 让当前根节点的右孩子作为新的根节点，继续遍历逻辑
        root = s[len(s)-1].Right
        // 回溯一步
        s = s[:len(s)-1]
    }
    return ans
}

中序遍历：

func inorderTraversal(root *TreeNode) (res []int) {
	stack := []*TreeNode{}
	for root != nil || len(stack) > 0 {
		for root != nil {
			stack = append(stack, root)
			root = root.Left
		}
		root = stack[len(stack)-1]
		stack = stack[:len(stack)-1]
		// 执行处理逻辑
		res = append(res, root.Val)
		// 进入右子树遍历
		root = root.Right
	}
	return
}

后序遍历：

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func postorderTraversal(root *TreeNode) []int {
    ans := []int{}
    s := []*TreeNode{}
    // 记录上一次访问的节点
    var pre *TreeNode
    for len(s) > 0 || root != nil {
        // 走到最左子孩子
        for root != nil {
            s = append(s, root)
            root = root.Left
        }
        // 回溯一步
        root = s[len(s)-1]
        // 出栈
        s = s[:len(s)-1]
        // 如果右子树还没有遍历过，则缓存当前点，并进入到右孩子
        if root.Right != nil && root.Right != pre {
            // 存储当前节点
            s = append(s, root)
            // 进入到右孩子开始遍历
            root = root.Right
        }else {
            ans = append(ans, root.Val)
            // 更新最近一次走过的节点
            pre = root
            // 手动让root为nil，避免下一次循环重复遍历一遍左子树
            root = nil
        }
    }
    return ans
}