二叉树的递归遍历 二叉树的迭代遍历

二叉树的递归遍历 二叉树的迭代遍历

二叉树的递归遍历

思路

递归法
递归算法的三步思考
1.递归方法的参数和返回值
2.递归方法的终止条件
3.确认单层递归的处理逻辑

前序遍历

思路

递归法
递归算法的三步思考
1.递归方法的参数和返回值
2.递归方法的终止条件
3.确认单层递归的处理逻辑
前序遍历的参数：存储返回结果的数组，树结点 返回值void
终止条件：结点为空
处理逻辑：先处理根节点，然后左结点，然后右结点

代码如下

// 时间复杂度o(n)其中 n 为二叉树节点的个数。二叉树的遍历中每个节点会被访问一次且只会被访问一次。
// 空间复杂度o(n)空间复杂度取决于递归的栈深度，而栈深度在二叉树为一条链的情况下会达到 O(n)O(n)O(n) 的级别。
public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<>();
    preorder(result,root);
    return result;
}

public void preorder(List<Integer> result,TreeNode node){
    if(node == null){
        return;
    }

    result.add(node.val);
    preorder(result,node.left);
    preorder(result,node.right);
}

中序遍历

思路

递归法
递归算法的三步思考
1.递归方法的参数和返回值
2.递归方法的终止条件
3.确认单层递归的处理逻辑
中序遍历的参数：存储返回结果的数组，树结点 返回值void
终止条件：结点为空
处理逻辑：先处理左节点，然后中结点，然后右结点

代码如下

// 时间复杂度o(n)其中 n 为二叉树节点的个数。二叉树的遍历中每个节点会被访问一次且只会被访问一次。
// 空间复杂度o(n)空间复杂度取决于递归的栈深度，而栈深度在二叉树为一条链的情况下会达到 O(n)O(n)O(n) 的级别。
public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<>();
    inorder(result, root);
    return result;
}

public void inorder(List<Integer> result, TreeNode node) {
    if (node == null) {
        return;
    }

    inorder(result, node.left);
    result.add(node.val);

    inorder(result, node.right);
}

后序遍历

思路

递归法
递归算法的三步思考
1.递归方法的参数和返回值
2.递归方法的终止条件
3.确认单层递归的处理逻辑
后序遍历的参数：存储返回结果的数组，树结点 返回值void
终止条件：结点为空
处理逻辑：先处理左节点，然后右结点，然后中结点

代码如下

// 时间复杂度o(n)其中 n 为二叉树节点的个数。二叉树的遍历中每个节点会被访问一次且只会被访问一次。
// 空间复杂度o(n)空间复杂度取决于递归的栈深度，而栈深度在二叉树为一条链的情况下会达到 O(n)O(n)O(n) 的级别。
public List<Integer> postorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<>();
    postorder(result,root);
    return result;
}

public void postorder(List<Integer> result,TreeNode node){
    if(node == null){
        return;
    }

    postorder(result,node.left);
    postorder(result,node.right);
    result.add(node.val);

}

二叉树的迭代遍历

思路

迭代法（非递归）
递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因。
所以使用栈也可以实现非递归算法

前序遍历

思路

迭代法（非递归）
递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因。
所以使用栈也可以实现非递归算法
先将根节点入栈，然后出栈。
然后将根节点的左右结点入栈。注意是先入右节点，然后入左节点，最后依次出栈

代码如下

// 时间复杂度o(n)其中 n 为二叉树节点的个数。二叉树的遍历中每个节点会被访问一次且只会被访问一次。
// 空间复杂度o(n)空间复杂度取决于递归的栈深度，而栈深度在二叉树为一条链的情况下会达到 O(n)O(n)O(n) 的级别。

    public List<Integer> preorderTraversal1(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> result = new ArrayList<>();
        if(root == null){
            return result;
        }
        stack.push(root);
        while(!stack.isEmpty()){
            result.add(stack.peek().val);
            TreeNode leftNode = stack.peek().left;
            TreeNode rightNode = stack.peek().right;
            stack.pop();

            if(rightNode != null){
                stack.push(rightNode);
            }

            if(leftNode != null){
                stack.push(leftNode);
            }

        }
        return result;
    }

中序遍历

思路

迭代法（非递归）
递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因。
所以使用栈也可以实现非递归算法
为了解释清楚，我说明一下 刚刚在迭代的过程中，其实我们有两个操作：

处理：将元素放进result数组中
访问：遍历节点
分析一下为什么刚刚写的前序遍历的代码，不能和中序遍历通用呢，因为前序遍历的顺序是中左右，先访问的元素是中间节点，要处理的元素也是中间节点，所以刚刚才能写出相对简洁的代码，因为要访问的元素和要处理的元素顺序是一致的，都是中间节点。

那么再看看中序遍历，中序遍历是左中右，先访问的是二叉树顶部的节点，然后一层一层向下访问，直到到达树左面的最底部，再开始处理节点（也就是在把节点的数值放进result数组中），这就造成了处理顺序和访问顺序是不一致的。

那么在使用迭代法写中序遍历，就需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素。

代码如下

// 时间复杂度o(n)其中 n 为二叉树节点的个数。二叉树的遍历中每个节点会被访问一次且只会被访问一次。
// 空间复杂度o(n)空间复杂度取决于递归的栈深度，而栈深度在二叉树为一条链的情况下会达到 O(n)O(n)O(n) 的级别。
    public static List<Integer> inorderTraversal1(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            return result;
        }

        TreeNode cur = root;
        while (!stack.isEmpty() || cur != null) {
            if (cur != null) {
                stack.push(cur);
                cur = cur.left;
            } else {
                cur = stack.pop();
                result.add(cur.val);
                cur = cur.right;
            }

        }
        return result;
    }

后序遍历

思路

迭代法（非递归）
递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因。
所以使用栈也可以实现非递归算法
后序遍历顺序 左-右-中 .那么我们得到中-右-左的顺序将其翻转就可以
所以将前序遍历代码改动，先插入左子树然后插入右子树，那么输出的结果就是中右左

代码如下

// 时间复杂度o(n)其中 n 为二叉树节点的个数。二叉树的遍历中每个节点会被访问一次且只会被访问一次。
// 空间复杂度o(n)空间复杂度取决于递归的栈深度，而栈深度在二叉树为一条链的情况下会达到 O(n)O(n)O(n) 的级别。
public List<Integer> postorderTraversal1(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> result = new ArrayList<>();
        if(root == null){
            return result;
        }
        stack.push(root);
        while(!stack.isEmpty()){
            result.add(stack.peek().val);
            TreeNode leftNode = stack.peek().left;
            TreeNode rightNode = stack.peek().right;
            stack.pop();



            if(leftNode != null){
                stack.push(leftNode);
            }

            if(rightNode != null){
                stack.push(rightNode);
            }

        }
        Collections.reverse(result);
        return result;
    }