经典算法与数据结构（6）—— 二叉树的常规遍历（递归+非递归+层次遍历）

最新推荐文章于 2023-11-23 16:27:14 发布

luqian1996

最新推荐文章于 2023-11-23 16:27:14 发布

阅读量159

点赞数

分类专栏：算法与数据结构

本文链接：https://blog.csdn.net/z892144672/article/details/103514847

版权

算法与数据结构专栏收录该内容

7 篇文章 0 订阅

订阅专栏

本文介绍了二叉树的三种遍历方法：递归遍历，包括前序、中序、后序；非递归遍历，重点讲解了前序遍历的栈实现；以及层次遍历，通过队列结构实现。递归遍历简洁易懂但效率较低，非递归遍历和层次遍历则提供了不同的思考角度。

摘要由CSDN通过智能技术生成

今天记录的是非常基础的二叉树的遍历，包括递归、非递归、层次遍历三个版本。最简单的当然就是递归版本的遍历啦，非递归版本还是要稍稍动点脑筋的。

递归遍历

递归版本的没啥好说的，对当前结点的打印有三个位置可以放，分别对应了前序、中序、后序遍历。简单易理解，但就是效率比较低。

public class TraverseRecursion {

    public static void traverse_preorder(TreeNode root){
        if(root == null)
            return;
        System.out.println(root.val);
        if(root.left != null)
            traverse_preorder(root.left);
        if(root.right != null)
            traverse_preorder(root.right);
    }


    public static void traverse_inorder(TreeNode root){
        if(root == null)
            return;
        if(root.left != null)
            traverse_inorder(root.left);
        System.out.println(root.val);
        if(root.right != null)
            traverse_inorder(root.right);
    }


    public static void traverse_postorder(TreeNode root){
        if(root == null)
            return;
        if(root.left != null)
            traverse_postorder(root.left);
        if(root.right != null)
            traverse_postorder(root.right);
        System.out.println(root.val);
    }
}

非递归遍历

前序遍历：利用栈结构，吐出并打印当前节点后，右孩子先进栈，左孩子再进栈。这样就相当于先遍历左子树，再遍历右子树。


public static void traverse_preorder(TreeNode root){
        if (root == null)
            return;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()){
            TreeNode node = stack.pop();
            System.out.println(node.val);
            if(node.right != null)
                stack.push(node.right);
            if(node.left != null)
                stack.push(node.left);
        }
    }

中序遍历：

public static void traverse_inorder(TreeNode root){
        if(root == null)
            return;
        Stack<TreeNode> stack = new Stack<>();

        while (!stack.isEmpty() || root!=null){
            if(root != null){
                stack.push(root);
                root = root.left;
            }
            else{
                root = stack.pop();
                System.out.println(root.val);
                root = root.right;
            }
        }
    }

后序遍历：先保留中–>右–>左的遍历结果，再逆序打印（使用辅助栈）。


public static void traverse_postorder(TreeNode root){
        if (root == null)
            return;
        Stack<TreeNode> stack = new Stack<>();
        Stack<Integer> help = new Stack<>();

        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            help.push(node.val);
            if (root.left != null)
                stack.push(root.left);
            if (root.right != null)
                stack.push(root.right);
        }
        while (!help.isEmpty())
            System.out.println(help.pop());
    }

层次遍历

利用队列结构：


public static void traverse_layer(TreeNode root){
        if(root == null)
            return;
        Queue<TreeNode> que = new LinkedList<>();
        que.offer(root);
        while (!que.isEmpty()){
            TreeNode node = que.poll();
            System.out.println(node.val);
            if(node.left != null)
                que.offer(node.left);
            if(node.right != null)
                que.offer(node.right);
        }
}