递归创建二叉树

树的创建

我们都清楚，树可以看作是由一个一个节点（节点里面包含了 值：value、和左右子节点）组成

因此：

public class TreeCreate {
    public static void main(String[] args) {
        //创建根节点
        Node<String> root = new Node<>("1");
        //构建左子树
        root.leftnode = new Node<>("2");
        root.leftnode.leftnode=new Node<>("3");
        root.leftnode.rightnode=new Node<>("4");

        //构建右子树
        root.rightnode=new Node<>("5");
        root.rightnode.rightnode=new Node<>("6");

    }
}
class Node<T>{
    T t;
    Node<T> leftnode;
    Node<T> rightnode;

    public Node(T t) {
        this.t = t;

    }
}

这便是一颗简单的二叉树创建过程

二叉树的遍历

二叉树的遍历常见的来说有三种形式{前序遍历、中序遍历、后序遍历}

实现这些遍历的方法要么用循环迭代（太麻烦）要么用递归实现

以下使用递归实现的三种遍历方法：

public class MyNode<T> {
    T t;
    MyNode<T> leftnode;
    MyNode<T> rightnode;

    public MyNode(T t) {
        this.t = t;

    }

    //用来存储前序遍历结果的list
    ArrayList<T> list = new ArrayList<>();
    //用来存储中序遍历结果的list
    ArrayList<T> list1 = new ArrayList<>();
    //用来存储前序遍历结果的list
    ArrayList<T> list2 = new ArrayList<>();


    //递归实现前序遍历 根-左-右
    public void preTravel(MyNode<T> root){
        if (root==null){
            return;
        }
        //将根存储到list
        list.add(root.t);
        //调用递归遍历它的左子树，调用递归遍历它的右子树
        preTravel(root.leftnode);
        preTravel(root.rightnode);
    }



    //递归实现中序遍历 左-根-右
    public void middleTravel(MyNode<T> root){
        if (root==null){
            return;
        }
        //递归遍历左子树
        middleTravel(root.leftnode);
        //添加节点值
        list1.add(root.t);
        //递归遍历右子树
        middleTravel(root.rightnode);

    }


    //递归实现后序遍历 左-根-右
    public void postTravel(MyNode<T> root){
        if (root==null){
            return;
        }
        //递归遍历左子树
        postTravel(root.leftnode);
        //递归遍历右子树
        postTravel(root.rightnode);
        //添加节点值
        list2.add(root.t);

    }

}

递归的好处就看出来了，代码简洁，对于这部分遍历有个简单的记忆方法：在哪添加的节点，就是什么序遍历。例如我是在

 list.add(root.t);
 preTravel(root.leftnode)

 preTravel(root.rightnode);

三个位置的前面添加的，那就是前序遍历

二叉树的深度

这里为大家介绍了两种实现方法，一种是递归一种是循环迭代

public class Test {
    public static void main(String[] args) {
        //创建根节点
        MyNode<String> root  = new MyNode<>("1");
        //构建左子树


        root.leftNode = new MyNode<>("2");
        root.leftNode.leftNode=new MyNode<>("3");
        root.leftNode.rightNode=new MyNode<>("4");

        //构建右子树
        root.rightNode=new MyNode<>("5");
        root.rightNode.rightNode=new MyNode<>("6");


        System.out.println(maxDepth(root));
        System.out.println(maxDepth2(root));

    }



    //递归实现二叉树的最大深度
    public static int maxDepth(MyNode root){
        if (root==null){
            return 0;
        }
        return Math.max(maxDepth(root.rightNode),maxDepth(root.leftNode))+1;
    }

    //循环迭代的方式实现二叉树的最大深度
    public static int maxDepth2(MyNode root){
        //创建队列Queue 使用linkedLisi实现
        Queue<MyNode> queue = new LinkedList<>();
        //将根节点进队
        queue.offer(root);

        int depth = 0;

        while(!queue.isEmpty()){

            //size ；获取队列的长度=该层节点的个数
            int size = queue.size();

            //处理队列中节点的循环
            while(size>0){
                //获取出队节点，先进先出
                MyNode node = queue.poll();

                //判断每个子节点是否有左右子结点，有则添加，表示下一个层级结点
                if (node.leftNode!=null){
                    queue.offer(node.leftNode);
                }
                if (node.rightNode!=null){
                    queue.offer(node.rightNode);
                }
                //每出队一个结点 size-- 直到size==0 表示该层节点处理完了
                size--;

            }
            depth++;
        }
        return  depth;
    }
}

public class MyNode<T> {
    public T t;
    public MyNode<T> leftNode;
    public MyNode<T> rightNode;

    public MyNode(T t) {
        this.t = t;
    }
}