五、二叉树的（前序、中序、后序、层次等遍历的）递归和非递归解法

最新推荐文章于 2022-10-02 18:54:00 发布

Gordon_run

最新推荐文章于 2022-10-02 18:54:00 发布

阅读量262

点赞数

CC 4.0 BY-SA版权

分类专栏：数据结构和算法数据结构和算法（Java语言）

本文链接：https://blog.youkuaiyun.com/Angel_guoo/article/details/88946275

数据结构和算法同时被 2 个专栏收录

25 篇文章

订阅专栏

数据结构和算法（Java语言）

22 篇文章

订阅专栏

本文详细介绍了二叉树的基本概念及其多种遍历方法，包括递归与非递归实现，并提供了具体代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

二叉树是一种非常重要的数据结构，其他很多数据结构都是基于二叉树基础演变而来的。

在我刷 剑指offer 中，碰到了 “ 二叉搜索树与双向链表 ” 这样的题目，对于里面的非递归解法很不理解，所以我就又重新复习了一遍二叉树的前序、中序、后序和层次遍历，以及求树的深度，广度等。

闲话少说，直接上代码，如果代码看不太懂，就自己画一颗二叉树，自己按照程序走一遍，多走几遍，然后看看相关文章的注释，就能弄懂了。

比如：

                   10

         7               12

   6          8       11         14

前序遍历： 10 ，7，6，8，12，11, 14, 10

后序遍历： 6, 8, 7, 11, 14, 12, 10

中序遍历： 6，7, 8, 9, 10, 11, 12, 14

层次遍历： 10， 7， 12， 6 ， 8 ， 11 ， 14

深度： 3

广度： 4

我这里只给出类似的代码，具体的相应修改，需要大家自己动手啦^_^

节点定义：

public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode(int x) {
            val = x;
        }
    }

1，前序遍历（递归解法）

    public static void preOrder(TreeNode treeNode) {
        if (treeNode != null) {
            System.out.print(treeNode.val + " ");
            preOrder(treeNode.left);
            preOrder(treeNode.right);
        }
    }

2.1，前序遍历（非递归解法①）

    /**
     * 先序非递归：
     * 这种实现类似于图的深度优先遍历（DFS）。
     * 维护一个栈，将根节点入栈，然后只要栈不为空，出栈并访问，
     * 接着依次将访问节点的右节点、左节点入栈。
     * 这种方式应该是对先序遍历的一种特殊实现（看上去简单明了），
     * 但是不具备很好的扩展性，在中序和后序方式中不适用
     *
     * @param root
     */
    public static void preOrderStack(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode treeNode = stack.pop();
            System.out.print(treeNode.val + " ");
            if (treeNode.right != null) {
                stack.push(treeNode.right);
            }
            if (treeNode.left != null) {
                stack.push(treeNode.left);
            }
        }
    }

2.2 先序遍历（非递归解法②）

/**
     * 先序非递归2：
     * 利用栈模拟递归过程实现循环先序遍历二叉树。
     * 这种方式具备扩展性，它模拟递归的过程，将左子树点不断的压入栈，直到null，
     * 然后处理栈顶节点的右子树。
     *
     * @param root
     */
    public static void preOrderStack2(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        TreeNode treeNode = root;
        while (treeNode != null || !stack.isEmpty()) {
            //将左子树点不断的压入栈
            while (treeNode != null) {
                //先访问再入栈
                System.out.print(treeNode.val + " ");
                stack.push(treeNode);
                treeNode = treeNode.left;
            }
            //出栈并处理右子树
            if (!stack.isEmpty()) {
                treeNode = stack.pop();
                treeNode = treeNode.right;
            }

        }

    }

3，中序遍历（递归解法）

    public static void inOrder(TreeNode treeNode) {
        if (treeNode != null) {
            inOrder(treeNode.left);
            System.out.print(treeNode.val + " ");
            inOrder(treeNode.right);
        }
    }

4，中序遍历（非递归解法）

    /**
     * 中序非递归：
     * 利用栈模拟递归过程实现循环中序遍历二叉树。
     * 思想和上面的先序非递归2相同，
     * 只是访问的时间是在左子树都处理完直到null的时候出栈并访问。
     *
     * @param treeNode
     */
    public static void inOrderStack(TreeNode treeNode) {
        Stack<TreeNode> stack = new Stack<>();
        while (treeNode != null || !stack.isEmpty()) {
            while (treeNode != null) {
                stack.push(treeNode);
                treeNode = treeNode.left;
            }
            //左子树进栈完毕
            if (!stack.isEmpty()) {
                treeNode = stack.pop();
                System.out.print(treeNode.val + " ");
                treeNode = treeNode.right;
            }
        }
    }

5，后序遍历（递归解法）

    public static void postOrder(TreeNode treeNode) {
        if (treeNode != null) {
            postOrder(treeNode.left);
            postOrder(treeNode.right);
            System.out.print(treeNode.val + " ");
        }
    }

6，后序遍历（非递归解法①）

public static class TagNode {
        TreeNode treeNode;
        boolean isFirst;
    }

    /**
     * 后序非递归：
     * 后序遍历不同于先序和中序，它是要先处理完左右子树，
     * 然后再处理根(回溯)。
     * <p>
     * <p>
     * 对于任一结点P，将其入栈，然后沿其左子树一直往下搜索，直到搜索到没有左孩子的结点，
     * 此时该结点出现在栈顶，但是此时不能将其出栈并访问，因此其右孩子还为被访问。
     * 所以接下来按照相同的规则对其右子树进行相同的处理，当访问完其右孩子时，该结点又出现在栈顶，
     * 此时可以将其出栈并访问。这样就保证了正确的访问顺序。
     * 可以看出，在这个过程中，每个结点都两次出现在栈顶，只有在第二次出现在栈顶时，才能访问它。
     * 因此需要多设置一个变量标识该结点是否是第一次出现在栈顶，这里是在树结构里面加一个标记，然后合成一个新的TagNode。
     *
     * @param treeNode
     */
    public static void postOrderStack(TreeNode treeNode) {
        Stack<TagNode> stack = new Stack<>();
        TagNode tagNode;
        while (treeNode != null || !stack.isEmpty()) {
            //沿左子树一直往下搜索，直至出现没有左子树的结点
            while (treeNode != null) {
                tagNode = new TagNode();
                tagNode.treeNode = treeNode;
                tagNode.isFirst = true;
                stack.push(tagNode);
                treeNode = treeNode.left;
            }

            if (!stack.isEmpty()) {
                tagNode = stack.pop();
                //表示是第一次出现在栈顶
                if (tagNode.isFirst == true) {
                    tagNode.isFirst = false;
                    stack.push(tagNode);
                    treeNode = tagNode.treeNode.right;
                } else {
                    //第二次出现在栈顶
                    System.out.print(tagNode.treeNode.val + " ");
                    treeNode = null;
                }
            }
        }
    }

7，后序遍历（非递归解法②）

    /**
     * 后序非递归2：
     * 要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，则可以直接访问它；
     * 或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。
     * 若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈顶元素的时候，左孩子在右孩子前面被访问，
     * 左孩子和右孩子都在根结点前面被访问。
     *
     * @param treeNode
     */
    public static void postOrderStack2(TreeNode treeNode) {
        Stack<TreeNode> stack = new Stack<>();
        TreeNode currentTreeNode;
        TreeNode preTreeNode = null;
        stack.push(treeNode);

        while (!stack.isEmpty()) {
            currentTreeNode = stack.peek();
            //如果当前结点没有孩子结点或者孩子节点都已被访问过
            if ((currentTreeNode.left == null && currentTreeNode.right == null) ||
                    (preTreeNode != null && (preTreeNode == currentTreeNode.left || preTreeNode == currentTreeNode.right))) {
                System.out.print(currentTreeNode.val + " ");
                stack.pop();
                preTreeNode = currentTreeNode;
            } else {
                if (currentTreeNode.right != null) {
                    stack.push(currentTreeNode.right);
                }
                if (currentTreeNode.left != null) {
                    stack.push(currentTreeNode.left);
                }
            }
        }
    }
}

8，层次遍历（递归解法）

public void levelOrder(BinaryNode<AnyType> Node) {
        if (Node == null) {
            return;
        }

        int depth = depth(Node);

        for (int i = 1; i <= depth; i++) {
            levelOrder(Node, i);
        }
    }

    private void levelOrder(BinaryNode<AnyType> Node, int level) {
        if (Node == null || level < 1) {
            return;
        }

        if (level == 1) {
            System.out.print(Node.element + "  ");
            return;
        }

        // 左子树
        levelOrder(Node.left, level - 1);

        // 右子树
        levelOrder(Node.right, level - 1);
    }

    public int depth(BinaryNode<AnyType> Node) {
        if (Node == null) {
            return 0;
        }

        int l = depth(Node.left);
        int r = depth(Node.right);
        if (l > r) {
            return l + 1;
        } else {
            return r + 1;
        }
    }

9，层序遍历（非递归解法）

public void levelOrder(BinaryTreeNode root){
	 Queue<BinaryTreeNode> queue=new LinkedList<BinaryTreeNode>();
	 queue.offer(root);
	 while(!queue.isEmpty()){
		 temp=queue.poll();
		 System.out.print(temp.getData()+"\t");
		 if(null!=temp.getLeft()) 
			 queue.offer(temp.getLeft());
		 if(null!=temp.getRight()){
			 queue.offer(temp.getRight());
		}
	}
}

10，求二叉树深度

// 获取最大深度
    public static int getMaxDepth(TreeNode root) {
        if (root == null)
            return 0;
        else {
            int left = getMaxDepth(root.left);
            int right = getMaxDepth(root.right);
            return 1 + Math.max(left, right);
        }
    }

11，求二叉树广度

// 获取最大宽度
    public static int getMaxWidth(TreeNode root) {
        if (root == null)
            return 0;

        Queue<TreeNode> queue = new ArrayDeque<TreeNode>();
        int maxWitdth = 1; // 最大宽度
        queue.add(root); // 入队

        while (true) {
            int len = queue.size(); // 当前层的节点个数
            if (len == 0)
                break;
            while (len > 0) {// 如果当前层，还有节点
                TreeNode t = queue.poll();
                len--;
                if (t.left != null)
                    queue.add(t.left); // 下一层节点入队
                if (t.right != null)
                    queue.add(t.right);// 下一层节点入队
            }
            maxWitdth = Math.max(maxWitdth, queue.size());
        }
        return maxWitdth;
    }

参考文章：

1， http://www.cnblogs.com/dolphin0520/archive/2011/08/25/2153720.html

2， https://www.cnblogs.com/wylwyl/p/10477528.html

3， https://blog.youkuaiyun.com/lr131425/article/details/60755706

4， https://blog.youkuaiyun.com/apandi_/article/details/52916523

5， https://www.cnblogs.com/qiuyong/p/6675492.html
6， https://www.cnblogs.com/morethink/p/7265817.html

7，https://www.cnblogs.com/liuyang0/p/6271324.html

8， https://blog.youkuaiyun.com/zhangxiangdavaid/article/details/37115355

9，https://www.cnblogs.com/xudong-bupt/p/4036190.html

10， https://blog.youkuaiyun.com/lr131425/article/details/60755706