zoukankan      html  css  js  c++  java
  • 算法 二叉树遍历

    三种遍历方式

    1.先序:根左右

    2.后序:左右根

    3.中序:左根右

    先定义一个二叉树类

     class TreeNode {
            int value;
            TreeNode left;
            TreeNode right;

    public TreeNode(){}
    public TreeNode(int value, TreeNode left, TreeNode right) { this.value = value; this.left = left; this.right = right; } public TreeNode(int value) { this.value = value; } public int getValue() { return value; } public void setValue(int value) { this.value = value; } public TreeNode getLeft() { return left; } public void setLeft(TreeNode left) { this.left = left; } public TreeNode getRight() { return right; } public void setRight(TreeNode right) { this.right = right; } }

    递归遍历

    //先序递归遍历
        private static void recursionPreOrder(TreeNode root) {
            if (root==null){
                return;
            }
            System.out.print(root.value);
            recursionPreOrder(root.left);
            recursionPreOrder(root.right);
        }
    
        //后序递归遍历
        private static void recursionBackOrder(TreeNode root) {
            if (root==null){
                return;
            }
            recursionBackOrder(root.left);
            recursionBackOrder(root.right);
            System.out.print(root.value);
        }
    
        //中序递归遍历
        private static void recursionMiddleOrder(TreeNode root) {
            if (root==null){
                return;
            }
            recursionMiddleOrder(root.left);
            System.out.print(root.value);
            recursionMiddleOrder(root.right);
        }

    非递归式遍历

    因为递归方法是将栈的管理交给了系统,非递归式则需要我们自己去管理,所以我们使用栈去实现它

    //非递归式
        //先序
        private static void preOrder(TreeNode root) {
            Stack<TreeNode> nodeStack = new Stack<>();
            while (root != null || !nodeStack.isEmpty()) {
                while (root != null) {
                    System.out.println(root.value);
                    nodeStack.push(root);
                    root = root.left;
                }
                if (!nodeStack.isEmpty()) {
                    root = nodeStack.pop().right;
                }
            }
        }
    
        //中序
        private static void middleOrder(TreeNode root) {
            Stack<TreeNode> nodeStack = new Stack<>();
            while (root != null || !nodeStack.isEmpty()) {
                while (root != null) {
                    nodeStack.push(root);
                    root = root.left;
                }
    
                if (!nodeStack.isEmpty()) {
                    root = nodeStack.pop();
                    System.out.println(root.value);
                    root = root.right;
                }
            }
        }
    
        //后序
        private static void backOrder(TreeNode root) {
            Stack<TreeNode> nodeStack = new Stack<>();
            TreeNode lastNode = root;
            while (root != null || !nodeStack.isEmpty()) {
                while (root != null) {
                    nodeStack.push(root);
                    root = root.left;
                }
                root = nodeStack.peek();
                if (root.right == null || root.right == lastNode) {
                    System.out.println(root.value);
                    nodeStack.pop();
                    lastNode = root;
                    root = null;
                } else {
                    root = root.right;
                }
            }
        }

    测试代码

     class TreeNode {
            int value;
            TreeNode left;
            TreeNode right;
    
            public TreeNode() {
            }
    
            public TreeNode(int value, TreeNode left, TreeNode right) {
                this.value = value;
                this.left = left;
                this.right = right;
            }
    
            public TreeNode(int value) {
                this.value = value;
            }
    
            public int getValue() {
                return value;
            }
    
            public void setValue(int value) {
                this.value = value;
            }
    
            public TreeNode getLeft() {
                return left;
            }
    
            public void setLeft(TreeNode left) {
                this.left = left;
            }
    
            public TreeNode getRight() {
                return right;
            }
    
            public void setRight(TreeNode right) {
                this.right = right;
            }
        }
    public static void main(String args[]) {
            //二叉树遍历
            TreeNode node1 = new TreeNode(7);
            TreeNode node2 = new TreeNode(8);
            TreeNode node3 = new TreeNode(6, node1, node2);
    
            TreeNode node4 = new TreeNode(4);
            node4.right = node3;
    
            TreeNode node5 = new TreeNode(2);
            node5.left = node4;
    
            TreeNode root = new TreeNode(1);
            root.left = node5;
    
            TreeNode node6 = new TreeNode(5);
    
            TreeNode node7 = new TreeNode(3);
    
            node7.right = node6;
    
            root.right = node7;
    
    //        System.out.println("先序");
    //        recursionPreOrder(root);
    //        System.out.println();
    //        System.out.println("后序");
    //        recursionBackOrder(root);
    //        System.out.println();
    //        System.out.println("中序");
    //        recursionMiddleOrder(root);
    
    //        preOrder(root);
            backOrder(root);
    //        middleOrder(root);
    //        postorderTraversal(root);
    }
  • 相关阅读:
    C#对象深度克隆(转)
    .Net Core 图片文件上传下载(转)
    事件总线(Event Bus)知多少(转)
    深入理解C#:编程技巧总结(一)(转)
    asp.net core源码飘香:Configuration组件(转)
    asp.net core源码飘香:Logging组件(转)
    基于C#.NET的高端智能化网络爬虫(下)(转)
    基于C#.NET的高端智能化网络爬虫(转)
    30分钟掌握 C#7(转)
    30分钟掌握 C#6(转)
  • 原文地址:https://www.cnblogs.com/xiangtingsulinlin/p/9343314.html
Copyright © 2011-2022 走看看