二叉树的分层遍历的汇总

最新推荐文章于 2022-09-17 21:26:14 发布

李意文

最新推荐文章于 2022-09-17 21:26:14 发布

阅读量790

点赞数

分类专栏：算法文章标签：二叉树的分层遍历的汇总从上到下分层遍历每层从左到右从下到上分层遍历每层从左往右

本文链接：https://blog.csdn.net/u014698348/article/details/53967704

版权

算法专栏收录该内容

34 篇文章

订阅专栏

本文详细介绍了二叉树的分层遍历，包括从上到下每层从左到右、从右到左，从下到上每层从左到右、从右到左以及之字形分层输出的遍历方法，并提供了相应的Java代码实现。通过示例二叉树的控制台输出展示了各种遍历的结果。

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

二叉树的分层遍历分成一下五种。

1、从上到下分层遍历，每层从左到右，设置双指针，一个指针指向队列中二叉树一层的第一个节点，另外一个指针表示这一层的结尾节点的下一个节点


2、从上到下分层遍历，每层从右到左， 2有1改变左右孩子的入队列顺序即可。

3、从下到上分层遍历，每层从左往右， 要标示出二叉树的分层。之后逆序输出。

4、从下到上分层遍历，每层从右往左，4由三变化左右孩子的入队列顺序即可

5、按之字形分层输出,用双栈实现

测试二叉树的形状入下图所示：

控制台输出：

从上到下分层遍历，每层从左到右
1   
2   3   
4   5   6   
7   8   
从上到下分层遍历，每层从右到左
1   
3   2   
6   5   4   
8   7   
从下到上分层遍历，每层从左往右
7   8   
4   5   6   
2   3   
1   
从下到上分层遍历，每层从右往左
8   7   
6   5   4   
3   2   
1   
按之字形分层输出,用双栈实现
1   
3   2   
4   5   6   
8   7

代码如下：

import java.util.ArrayList;
import java.util.Stack;

/**
 * @author liyiwen1
 * @date 2016/12/27
 */
public class TreeBuilder{
    public static void main(String[] args) {
        Tree tree = builde(new Integer[]{1,2,3,4,5,6,null,null,null, 7,8});
        System.out.println("从上到下分层遍历，每层从左到右");
        tree.fencengLefeToRight();
        System.out.println("从上到下分层遍历，每层从右到左");
        tree.fencengRightToLeft();
        System.out.println("从下到上分层遍历，每层从左往右");
        tree.fencengDownUpLeftToRight();
        System.out.println("\r\n从下到上分层遍历，每层从右往左");
        tree.fencengDownUpRightToLeft();
        System.out.println("\r\n按之字形分层输出,用双栈实现");
        tree.fencengZprint();
    }

    public static Tree builde(Integer[] values){
        if (values != null && values.length != 0){
            Tree tree = new Tree();
            TreeNode[] nodes = new TreeNode[values.length];
            for (int i = 0; i < values.length; ++i){
                if (values[i] != null){
                    TreeNode node = new TreeNode();
                    node.value = values[i];
                    nodes[i] = node;
                    int parent = (i - 1) / 2;//父节点
                    if (parent >= 0 && nodes[parent] != null){
                        if (i % 2 == 0){//偶数为右孩子，奇数为左孩子
                            nodes[parent].right = node;
                        }else{
                            nodes[parent].left = node;
                        }
                    }
                }

            }
            if (nodes[0] != null){
                tree.root = nodes[0];
            }
            return tree;
        }
        return null;
    }

    public static class Tree{
        private TreeNode root;

        //从上到下分层遍历，每层从左到右
        public void fencengLefeToRight(){
            if (root != null){
                ArrayList<TreeNode> nodes = new ArrayList<TreeNode>();
                int index = 0; int lastIndex = 1;
                nodes.add(root);
                while (index != lastIndex){
                    while (index != lastIndex){
                        TreeNode node = nodes.get(index);
                        System.out.print(node.value + "   ");
                        if (node.left != null){
                            nodes.add(node.left);
                        }
                        if (node.right != null){
                            nodes.add(node.right);
                        }
                        ++index;
                    }
                    if (lastIndex == index){
                        System.out.print("\r\n");
                    }
                    index = lastIndex;
                    lastIndex = nodes.size();
                }
            }
        }

        //从上到下分层遍历，每层从右到左
        public void fencengRightToLeft(){
            if (root != null){
                ArrayList<TreeNode> nodes = new ArrayList<TreeNode>();
                int index = 0; int lastIndex = 1;
                nodes.add(root);
                while (index != lastIndex){
                    while (index != lastIndex){
                        TreeNode node = nodes.get(index);
                        System.out.print(node.value + "   ");
                        if (node.right != null){
                            nodes.add(node.right);
                        }
                        if (node.left != null){
                            nodes.add(node.left);
                        }
                        ++index;
                    }
                    if (lastIndex == index){
                        System.out.print("\r\n");
                    }
                    index = lastIndex;
                    lastIndex = nodes.size();
                }
            }
        }

        //从下到上分层遍历，每层从左往右
        public void fencengDownUpLeftToRight(){
            if (root != null){
                ArrayList<TreeNode> nodes = new ArrayList<TreeNode>();
                nodes.add(root);
                nodes.add(null);
                int index = 0;
                while (index < nodes.size() && nodes.get(index) != null){//将节点放入队列，每层用null来区分
                    while (nodes.get(index) != null){
                        if (nodes.get(index).right != null){//右孩子先入队列
                            nodes.add(nodes.get(index).right);
                        }
                        if (nodes.get(index).left != null){
                            nodes.add(nodes.get(index).left);
                        }
                        ++index;
                    }
                    if (index != nodes.size() - 1){
                        nodes.add(null);
                    }
                    ++index;
                }
                for (int i = nodes.size() - 1 ; i >= 0; --i){
                    if (nodes.get(i) != null){
                        System.out.print(nodes.get(i).value + "   ");
                    }else{
                        if (i != nodes.size() - 1){
                            System.out.print("\r\n");
                        }
                    }
                }
            }
        }

        //从下到上分层遍历，每层从右往左
        public void fencengDownUpRightToLeft(){
            if (root != null){
                ArrayList<TreeNode> nodes = new ArrayList<TreeNode>();
                nodes.add(root);
                nodes.add(null);
                int index = 0;
                while (index < nodes.size() && nodes.get(index) != null){//将节点放入队列，每层用null来区分
                    while (nodes.get(index) != null){
                        if (nodes.get(index).left != null){//左孩子先入队列
                            nodes.add(nodes.get(index).left);
                        }
                        if (nodes.get(index).right != null){
                            nodes.add(nodes.get(index).right);
                        }

                        ++index;
                    }
                    if (index != nodes.size() - 1){
                        nodes.add(null);
                    }
                    ++index;
                }
                for (int i = nodes.size() - 1 ; i >= 0; --i){
                    if (nodes.get(i) != null){
                        System.out.print(nodes.get(i).value + "   ");
                    }else{
                        if (i != nodes.size() - 1){
                            System.out.print("\r\n");
                        }
                    }
                }
            }
        }

        //按之字形分层输出,用双栈实现
        public void fencengZprint(){
            Stack<TreeNode> oushu = new Stack<TreeNode>();
            Stack<TreeNode> jishu = new Stack<TreeNode>();
            oushu.add(this.getRoot());
            while (!oushu.isEmpty() || !jishu.isEmpty()){
                if (!oushu.isEmpty()){
                    while (!oushu.isEmpty()){
                        TreeNode node = oushu.pop();
                        System.out.print(node.value + "   ");
                        if (node.left != null){//左孩子先入栈
                            jishu.push(node.left);
                        }
                        if (node.right != null){
                            jishu.push(node.right);
                        }
                    }
                    System.out.print("\r\n");
                }else if (!jishu.isEmpty()){
                    while (!jishu.isEmpty()){
                        TreeNode node = jishu.pop();
                        System.out.print(node.value + "   ");
                        if (node.right != null){//右孩子先入栈
                            oushu.push(node.right);
                        }
                        if (node.left != null){
                            oushu.push(node.left);
                        }
                    }
                    System.out.print("\r\n");
                }
            }

        }

        public TreeNode getRoot() {
            return root;
        }

        private void setRoot(TreeNode root) {
            this.root = root;
        }

        public void preOrder(){
            preOrder(root);
        }

        public void midOrder(){
            midOrder(root);
        }

        private void preOrder(TreeNode node){
            if (node != null){
                System.out.println(node.value);
                preOrder(node.left);
                preOrder(node.right);
            }
        }

        private void midOrder(TreeNode node){
            if (node != null){
                midOrder(node.left);
                System.out.println(node.value);
                midOrder(node.right);
            }
        }

    }



    public static class TreeNode{
        private int value;
        private TreeNode left;
        private TreeNode right;

    }

}