zoukankan      html  css  js  c++  java
  • 二叉树 遍历 先序 中序 后序 深度 广度 MD

    Markdown版本笔记 我的GitHub首页 我的博客 我的微信 我的邮箱
    MyAndroidBlogs baiqiantao baiqiantao bqt20094 baiqiantao@sina.com

    二叉树 遍历 先序 中序 后序 深度 广度 MD


    目录

    二叉树遍历

    测试案例

    遍历结果:

    先序遍历:631254978
    中序遍历:123456789
    后序遍历:214538796
    广度优先:639157248
    

    构造二叉树

    public static Node init() {
        //注意必须逆序建立,先建立子节点,再逆序往上建立,因为非叶子结点会使用到下面的节点 
        Node J = new Node(8, null, null);
        Node H = new Node(4, null, null);
        Node G = new Node(2, null, null);
    
        Node F = new Node(7, null, J);
        Node E = new Node(5, H, null);
        Node D = new Node(1, null, G);
    
        Node C = new Node(9, F, null);
        Node B = new Node(3, D, E);
    
        Node A = new Node(6, B, C);
        return A; //返回根节点  
    }

    结点定义

    class Node {
        public int value;
        public Node left;
        public Node right;
    
        public Node(int value, Node left, Node right) {
            this.value = value;
            this.left = left;
            this.right = right;
        }
    }

    深度优先 Depth First Search

    使用递归遍历

    其过程简要来说是对每一个可能的分支路径深入到不能再深入为止,而且每个节点只能访问一次。

    public static void preOrderTraversal(Node root) {
        if (root != null) {
            System.out.print(root.value); //先(根)序遍历
            preOrderTraversal(root.left); //递归遍历左孩子
            preOrderTraversal(root.right); //递归遍历右孩子
        }
    }
    
    public static void inOrderTraversal(Node root) {
        if (root != null) {
            inOrderTraversal(root.left);
            System.out.print(root.value); //中(根)序遍历
            inOrderTraversal(root.right);
        }
    }
    
    public static void postOrderTraversal(Node root) {
        if (root != null) {
            postOrderTraversal(root.left);
            postOrderTraversal(root.right);
            System.out.print(root.value); //后(根)序遍历
        }
    }

    使用栈遍历

    public static void preOrderTraversalStack(Node root) {
        Stack<Node> stack = new Stack<>();
        while (root != null || !stack.isEmpty()) {
            if (root != null) {
                System.out.print(root.value); //压栈之前先访问,先序遍历
                stack.push(root); //压栈
                root = root.left; //访问左叶子节点
            } else { //没有左(右)叶子节点
                root = stack.pop(); //返回最近压入栈的结点【核心】
                root = root.right; //访问右叶子节点
            }
        }
    }
    
    public static void preOrderTraversalStack2(Node root) {
        Stack<Node> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            Node node = stack.pop();
            System.out.print(node.value); //先序遍历
            if (node.right != null) {
                stack.push(node.right);
            }
            if (node.left != null) {
                stack.push(node.left);
            }
        }
    }
    
    public static void inOrderTraversalStack(Node root) {
        Stack<Node> stack = new Stack<>();
        Node node = root;
        while (node != null || !stack.isEmpty()) {
            if (node != null) {
                stack.push(node);
                node = node.left;
            } else {
                node = stack.pop();
                System.out.print(node.value); //中序遍历
                node = node.right;
            }
        }
    }
    
    public static void postOrderTraversalStack(Node root) {
        Stack<Node> stack = new Stack<>();
        Stack<Node> output = new Stack<>();//构造一个中间栈来存储逆后序遍历的结果
        Node node = root;
        while (node != null || !stack.isEmpty()) {
            if (node != null) {
                output.push(node);
                stack.push(node);
                node = node.right;
            } else {
                node = stack.pop();
                node = node.left;
            }
        }
        while (!output.isEmpty()) {
            System.out.print(output.pop().value); //后序遍历
        }
    }

    广度优先 Breadth First Search

    又叫宽度优先搜索,或横向优先搜索。
    对每一层节点依次访问,访问完一层进入下一层,而且每个节点只能访问一次

    public static void levelTraversal(Node root) {
        LinkedList<Node> queue = new LinkedList<>(); //LinkedList是Java中最普通的一个队列(Queue)实现
        queue.offer(root); //add、addLast
        while (!queue.isEmpty()) {
            Node node = queue.poll();//removeFirst
            System.out.print(node.value);
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
    }

    2018-12-8

  • 相关阅读:
    linux报错jar包时出现“Exception in thread "main" java.lang.SecurityException: Invalid signature file digest for Manifest main attributes”
    重写ajax方法实现请求session过期时跳转登录页面
    C++学习之NVI
    C++学习之Pimpl
    C++学习之allocator
    C++ 强制类型转换
    C++中的volatile关键字
    C++强大背后
    C++学习之智能指针
    C++学习之异常
  • 原文地址:https://www.cnblogs.com/baiqiantao/p/10087670.html
Copyright © 2011-2022 走看看