二叉树

import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Test {
    /**
     * 树结构
     */
    static class Tree {
        private Node root;

        public Node getRoot() {
            return root;
        }

        public void setRoot(Node root) {
            this.root = root;
        }
    }

    /**
     * 节点结构
     */
    static class Node {
        private int value;
        private Node left;
        private Node right;

        public Node(int value) {
            this.value = value;
        }
    }

    /**
     * 动态创建二叉树
     *
     * @param root
     * @param value
     */
    public static void createTree(Tree root, int value) {
        if (root.getRoot() == null) {
            root.setRoot(new Node(value));
            return;
        }
        Node temp = root.getRoot();
        while (temp != null) {
            if (value < temp.value) {
                if (temp.left == null) {
                    temp.left = new Node(value);
                    return;
                }
                temp = temp.left;
            } else {
                if (temp.right == null) {
                    temp.right = new Node(value);
                    return;
                }
                temp = temp.right;
            }
        }
    }

    /**
     * 先序遍历 root->left->right
     *
     * @param root
     */
    public static void preOrderTraverse(Node root) {
        if (root != null) {
            System.out.println(root.value);
            preOrderTraverse(root.left);
            preOrderTraverse(root.right);
        }
    }

    /**
     * 中序遍历 left->root->right
     *
     * @param root
     */
    public static void inOrderTraverse(Node root) {
        if (root != null) {
            inOrderTraverse(root.left);
            System.out.println(root.value);
            inOrderTraverse(root.right);
        }
    }

    /**
     * 后序遍历 left->right->root
     *
     * @param root
     */
    public static void postOrderTraverse(Node root) {
        if (root != null) {
            postOrderTraverse(root.left);
            postOrderTraverse(root.right);
            System.out.println(root.value);
        }
    }

    /**
     * 获取二叉树的深度
     *
     * @param root
     * @return
     */
    public static int getTreeHeight(Node root) {
        if (root == null) {
            return 0;
        }
        int left = getTreeHeight(root.left);
        int right = getTreeHeight(root.right);
        if (left > right) {
            return left + 1;
        }
        return right + 1;
    }

    /**
     * 查找二叉树最大值
     *
     * @param root
     * @return
     */
    public static int getMax(Node root) {
        if (root == null) {
            return -1;
        }
        int left = getMax(root.left);
        int right = getMax(root.right);
        int max = left;
        if (right > max) {
            max = right;
        }
        if (root.value > max) {
            max = root.value;
        }
        return max;
    }

    public static void main(String[] args) {
        int[] array = {6, 2, 3, 7, 1, 5, 8, 4, 9};
        Tree tree = new Tree();
        for (int value : array) {
            createTree(tree, value);
        }
        System.out.println("create end...");
        preOrderTraverse(tree.getRoot());
        System.out.println("----------");
        inOrderTraverse(tree.getRoot());
        System.out.println("----------");
        postOrderTraverse(tree.getRoot());
        System.out.printf("tree height:%d\n", getTreeHeight(tree.getRoot()));
        System.out.printf("tree max:%d\n", getMax(tree.getRoot()));
        Logger logger = Logger.getLogger("test");
        logger.setLevel(Level.ALL);
        logger.info("hello,test log");
        logger.info(logger.getLevel().toString());
        logger.throwing("hello", "log", new Exception("aaa"));
    }
}