二叉树

public class TreeNode {
    
    private int value;
    private TreeNode leftTreeNode;
    private TreeNode RightTreeNode;
    
    public TreeNode(int value) {
        this.value = value;
    }

    //Getters/Setters
}

public class TreeRoot {
    
    private TreeNode treeNode;

    public TreeNode getTreeNode() {
        return treeNode;
    }

    public void setTreeNode(TreeNode treeNode) {
        this.treeNode = treeNode;
    }
}

public void creatTree(TreeRoot treeRoot,int value){
    
    //第一次访问,若根为空，则设置第一个值为树根
    //一定要有树根，第一次就是和树根比
    if(treeRoot.getTreeNode() == null){
        treeRoot.setTreeNode(new TreeNode(value));
    }else{
        
        //保存临时结点
        TreeNode tempNode = treeRoot.getTreeNode();

        while(tempNode != null){
            
            //当前值大于当前结点，往右走
            if(value > tempNode.getValue()){
                
                //当前结点的右节点为空，即插入
                if(tempNode.getRightTreeNode() == null){
                    tempNode.setRightTreeNode(new TreeNode(value));
                    return ;
                }else{
                    //当前结点的右节点不为空，先去右节点
                    tempNode = tempNode.getRightTreeNode();
                }
            //当前值小于等于当前结点，往左走
            }else{
                //当前结点的左节点为空，即插入
                if(tempNode.getLeftTreeNode() == null){
                    tempNode.setLeftTreeNode(new TreeNode(value));
                    return ;
                }else{
                    //当前结点的左节点不为空，先去左节点
                    tempNode = tempNode.getLeftTreeNode();
                }
            }
        }
    }
}

public void preTree(TreeNode treeNode){
    
    if(treeNode != null){

                //访问根节点
        System.out.println(treeNode.getValue());
        
                //访问左节点
        preTree(treeNode.getLeftTreeNode());
        
        //访问右节点
        preTree(treeNode.getRightTreeNode());
    }
}

public void inTree(TreeNode treeNode){
    
    if(treeNode != null){
        
        //访问左节点
        inTree(treeNode.getLeftTreeNode());
        
        //访问根节点
        System.out.println(treeNode.getValue());
        
        //访问右节点
        inTree(treeNode.getRightTreeNode());
    }
}

public void postTree(TreeNode treeNode){
    
    if(treeNode != null){
        
        //访问左节点
        postTree(treeNode.getLeftTreeNode());
        
        //访问右节点
        postTree(treeNode.getRightTreeNode());
        
        //访问根节点
        System.out.println(treeNode.getValue());
    }
}

public static void main(String[] args) {
    
    int[] arrs = {6,2,3,4,5,7,9,10};
    
    TreeRoot treeRoot = new TreeRoot();
    
    for(int arr : arrs){
        createTree(treeRoot,arr);
    }
    
    //先序遍历
    preTree(treeRoot.getTreeNode());
}

6 2 3 4 5 7 9 10

public class TreeNode {
    public int val;
    public TreeNode left;
    public TreeNode right;
    public TreeNode(int x) { 
        val = x; 
    }
}

//剑指offer第四题
//传入数组的序列
public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        
        //判断是否空数组
        if(pre.length == 0 || in.length == 0){
            return null;
        }
        
        //创建当前树的根节点
        TreeNode treeNode = new TreeNode(pre[0]);
        for(int i = 0;i < pre.length;i++){
            //找出根在中序的位置
            if(pre[0] == in[i]){
                
                //左子树继续构建
                treeNode.left = reConstructBinaryTree(Arrays.copyOfRange(pre, 1, i+1),Arrays.copyOfRange(in, 0, i));
                //右子树继续构建
                treeNode.right = reConstructBinaryTree(Arrays.copyOfRange(pre, i+1, pre.length),Arrays.copyOfRange(in, i+1, in.length));
                //找到位置就停止循环
                break;
            }
        }
        //返回当前树的根节点
        return treeNode;
    }
}