二叉树的前中后遍历、层次遍历、树高，叶子节点、由两种遍历求树

二叉树的前序遍历

二叉树的中序遍历

二叉树的后序遍历

二叉树的前层次序遍历

求叶子节点

求树高

又前序遍历和中序遍历求树

Java代码拿去即可运行

package leetcode;

public class TreeNode {

    private Integer value;
    private TreeNode left;
    private TreeNode right;


    public TreeNode() {
    }

    public TreeNode(Integer value) {
        this.value=value;
    }

    public TreeNode(Integer value, TreeNode left, TreeNode right) {
        this.value = value;
        this.left = left;
        this.right = right;
    }

    public Integer getValue() {
        return value;
    }

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

    public TreeNode getLeft() {
        return left;
    }

    public void setLeft(TreeNode left) {
        this.left = left;
    }

    public TreeNode getRight() {
        return right;
    }

    public void setRight(TreeNode right) {
        this.right = right;
    }
}

package tree;

import leetcode.TreeNode;

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Objects;

public class Test {
    public static void main(String[] args) {
//        TreeNode treeNode1 = new TreeNode(1);
//        TreeNode treeNode2 = new TreeNode(2);
//        TreeNode treeNode3 = new TreeNode(3);
//        TreeNode treeNode4 = new TreeNode(4);
//        TreeNode treeNode5 = new TreeNode(5);
//        treeNode2.setLeft(treeNode4);
//        treeNode2.setRight(treeNode5);
//        treeNode1.setLeft(treeNode2);
//        treeNode1.setRight(treeNode3);
//        System.out.println(getHeight(treeNode1));
        int[] a={1,2,4,5,3};
        int[] b={4,2,5,1,3};
        TreeNode treeNode1=buildTree(a,b);
        LevelOrderTraversal(treeNode1);
    }

    /*************先序遍历****************/
    static void PreOrderTraversal(TreeNode treeNode) {
        if (treeNode != null) {
            System.out.println(treeNode.getValue()); // 打印根
            PreOrderTraversal(treeNode.getLeft());  // 进入左子树
            PreOrderTraversal(treeNode.getRight());  // 进入右子树
        }
    }

    /*************先序遍历****************/
    static void midOrderTraversal(TreeNode treeNode) {
        if (treeNode != null) {

            PreOrderTraversal(treeNode.getLeft());  // 进入左子树
            System.out.println(treeNode.getValue()); // 打印根
            PreOrderTraversal(treeNode.getRight());  // 进入右子树
        }
    }

    /*************先序遍历****************/
    static void lastOrderTraversal(TreeNode treeNode) {
        if (treeNode != null) {
            PreOrderTraversal(treeNode.getLeft());  // 进入左子树
            PreOrderTraversal(treeNode.getRight());  // 进入右子树
            System.out.println(treeNode.getValue()); // 打印根
        }
    }

    /**********层次遍历*************/
    public static void LevelOrderTraversal(TreeNode treeNode) {
        LinkedList<TreeNode> q = new LinkedList<>();   // 创建队列
        TreeNode node;
        if (Objects.isNull(treeNode))
            return;

        q.push(treeNode);  // treeNode 入队
        while (!q.isEmpty()) {
            node = q.getFirst();  // 访问队首元素
            q.pop();  // 出队
            System.out.println(node.getValue().toString());
            if (node.getLeft() != null) {// 如果存在左儿子结点
                q.addLast(node.getLeft());  // 入队
            }
            if (node.getRight() != null) {
                q.addLast(node.getRight());
            }
        }
    }

    /***************输出叶子结点********************/
    static void findLeaves(TreeNode treeNode) {
        if (treeNode != null) {
            if (Objects.isNull(treeNode.getLeft()) && Objects.isNull(treeNode.getRight())) {
                System.out.println(treeNode.getValue()); // 打印根
            }
            findLeaves(treeNode.getLeft());  // 进入左子树
            findLeaves(treeNode.getRight());  // 进入右子树
        }
    }

    /********************树的高度*****************/
    static int getHeight(TreeNode treeNode) {
        int hl, hr, maxh;
        if (treeNode != null) {
            hl = getHeight(treeNode.getLeft());  // 求左子树高度
            hr = getHeight(treeNode.getRight());  // 求右子树高度
            maxh = (hl > hr) ? hl : hr;
            return maxh + 1;  // 当前结点高度为左右子树最大的高度+1
        } else
            return 0;
    }
    /******************前序中序遍历序列构造二叉树**************************/
    public static TreeNode buildTree(int[] preorder, int[] inorder) {
        if(preorder.length==0)return null;
        TreeNode root = new TreeNode(preorder[0]);
        int num=0;
        for(int i =0; i<inorder.length; i++){
            if(inorder[i]==root.getValue()){
                num=i;
                break;
            }
        }
        int[] preLeft = Arrays.copyOfRange(preorder,1,num+1);
        int[] preRight = Arrays.copyOfRange(preorder,num+1,preorder.length);

        int[] inoLeft = Arrays.copyOfRange(inorder,0,num);
        int[] inoRight = Arrays.copyOfRange(inorder,num+1,inorder.length);
        root.setLeft(buildTree(preLeft,inoLeft));
        root.setRight(buildTree(preRight,inoRight));
        return root;
    }


}