二叉树

树是由若干个节点组成，节点连接起来就成了树，而节点由一个数据、两个指针组成。

因此，创建树实际上就是创建节点，然后连接节点。

二叉树：每个节点不能多于有两个儿子节点。

1）静态创建二叉树

public class TreeNode {
    //左节点
    private TreeNode leftNode;
    //右节点
    private TreeNode rightNode;
    //数据
    private int value;
    public TreeNode(int value){
        this.value=value;
    }

    public TreeNode getRightNode() {
        return rightNode;
    }

    public void setRightNode(TreeNode rightNode) {
        this.rightNode = rightNode;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public TreeNode getLeftNode() {
        return leftNode;
    }

    public void setLeftNode(TreeNode leftNode) {
        this.leftNode = leftNode;
    }
}

静态创建二叉树

    public static void main(String[] args) {
    // write your code here
        TreeNode node1=new TreeNode(10);
        TreeNode node2=new TreeNode(9);
        TreeNode node3=new TreeNode(20);
        TreeNode node4=new TreeNode(15);
        TreeNode node5=new TreeNode(35);
     }

三种遍历方法

1. 前序遍历(Preorder Traversal)：根节点--->左子树--->右子树
2. 中序遍历(Inorder Traversal)：左子树--->根节点--->右子树
3. 后序遍历(postorder Traversal)：左子树--->右子树--->根节点

 //先序遍历  根节点--->左子树--->右子树
    public static void preorderTraversal(TreeNode node){
        if(node!=null){
             System.out.print(node.getValue()+" ");
             preorderTraversal(node.getLeftNode());
             preorderTraversal(node.getRightNode());
        }
    }

    //中序遍历   左子树--->根节点--->右子树
    public static void inorderTraversal(TreeNode node){
        if(node!=null){
            inorderTraversal(node.getLeftNode());
            System.out.print(node.getValue()+" ");
            inorderTraversal(node.getRightNode());
        }
    }

    //后序遍历  左子树--->右子树--->根节点
    public static void postorderTraveral(TreeNode node){
        if(node!=null){
            postorderTraveral(node.getLeftNode());
            postorderTraveral(node.getRightNode());
            System.out.print(node.getValue()+" ");
        }
    }

通过先序遍历和中序遍历或者中序遍历和后序遍历可以还原出原始的二叉树。

2）动态创建二叉树

二叉查找树(Binary Seach Tree)：当前根节点的左边全部都比根节点小，当前根节点的右边全部比根节点大。

 public static TreeNode createTree(int[] arrays){
        if(arrays==null||arrays.length==0){
            return null;
        }
        int temp = arrays[0];
        TreeNode node = new TreeNode(temp);
        for (int i = 1; i < arrays.length; i++) {
            makeTree(node, arrays[i]);
        }
        return  node;
    }

    public static void makeTree(TreeNode n, int value) {
        if (n.getValue() > value) {
            if (n.getLeftNode() != null) {
                makeTree(n.getLeftNode(), value);
            } else {
                n.setLeftNode(new TreeNode(value));
            }
        } else {
            if (n.getRightNode() != null) {
                makeTree(n.getRightNode(), value);
            } else {
                n.setRightNode(new TreeNode(value));
            }
        }
    }

3）查询二叉树的高度

    public static int getTreeHeight(TreeNode node) {
        if (node == null) {
            return 0;
        } else {
            int left = getTreeHeight(node.getLeftNode());
            int right = getTreeHeight(node.getRightNode());
            int maxHeight = left + 1;
            if (left < right) {
                maxHeight = right + 1;
            }
            return maxHeight;
        }
    }

4）查询二叉树中的最大值

  public static int getMax(TreeNode node) {
        if (node == null) {
            return -1;
        } else {
            int left = getMax(node.getLeftNode());
            int right = getMax(node.getRightNode());
            int max=node.getValue();
            if(max<left){
                max=left;
            }
            if(max<right){
                max=right;
            }
            return max;
        }
    }