二叉树的前、中、后序遍历以及查找-Java实现

对于遍历不过多的赘述，关于查找有关的思想，关键是如何实现查找的顺序以及结果的回传；附代码

package dataSrtuct;

public class BinaryTreeDemo {
    public static void main(String[] args) {
        BinaryTree binaryTree=new BinaryTree();
        TreeNode root=new TreeNode(1,"MLQ");
        TreeNode node1=new TreeNode(2,"ZBB");
        TreeNode node2=new TreeNode(3,"MXP");
        TreeNode node3=new TreeNode(4,"MYP");
        root.setLeftNext(node1);
        root.setRightNext(node2);
        node2.setRightNext(node3);
        binaryTree.setRoot(root);
        System.out.println("遍历结果1为");
        binaryTree.preOrder();
        System.out.println("遍历结果2为");
        binaryTree.infixOrder();
        System.out.println("遍历结果3为");
        binaryTree.postOrder();
        System.out.println("查找结果1为");
        System.out.println(binaryTree.preOrderSearch(3)+"查找的次数为："+TreeNode.countPre);
        System.out.println("查找结果2为");
        System.out.println(binaryTree.infixOrderSearch(3)+"查找的次数为："+TreeNode.countInfix);
        System.out.println("查找结果3为");
        System.out.println(binaryTree.postOrderSearch(3)+"查找的次数为："+TreeNode.countPost);
    }

}
//二叉树
class BinaryTree{
    private TreeNode root;

    public TreeNode getRoot() {
        return root;
    }

    public void setRoot(TreeNode root) {
        this.root = root;
    }
    //先序遍历
    public void preOrder(){
        if (this.root!=null)
            this.root.preOrder();
        else
            System.out.println("二叉树为空，不能遍历");
    }
    ///中序遍历
    public void infixOrder(){
        if (this.root!=null)
            this.root.infixOrder();
        else
            System.out.println("二叉树为空，不能遍历");
    }
    //后序遍历
    public void postOrder(){
        if (this.root!=null)
            this.root.postOrder();
        else
            System.out.println("二叉树为空，不能遍历");
    }
    //前、后、中序查找
    //先序查找
    public TreeNode preOrderSearch(int val){
        if (this.root!=null)
            return this.root.preOrderSearch(val);
        else {
            System.out.println("二叉树为空，不能遍历");
            return null;
        }
    }
    //中序查找
    public TreeNode infixOrderSearch(int val){
        if (this.root!=null)
            return this.root.infixOrderSearch(val);
        else {
            System.out.println("二叉树为空，不能遍历");
            return null;
        }
    }
    //后序查找
    public TreeNode postOrderSearch(int val){
        if (this.root!=null)
            return this.root.postOrderSearch(val);
        else {
            System.out.println("二叉树为空，不能遍历");
            return null;
        }

    }
}
//树节点
class TreeNode{
    private int val;
    private String name;
    private TreeNode leftNext;
    private TreeNode rightNext;
    public static int countPre;
    public static int countInfix;
    public static int countPost;
    static {
        countPre=0;
        countInfix=0;
        countPost=0;
    }

    public TreeNode(int val, String name) {
        this.val = val;
        this.name = name;
    }

    public int getVal() {
        return val;
    }

    public void setVal(int val) {
        this.val = val;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public TreeNode getLeftNext() {
        return leftNext;
    }

    public void setLeftNext(TreeNode leftNext) {
        this.leftNext = leftNext;
    }

    public TreeNode getRightNext() {
        return rightNext;
    }

    public void setRightNext(TreeNode rightNext) {
        this.rightNext = rightNext;
    }

    @Override
    public String toString() {
        return "TreeNode{" +
                "val=" + val +
                ", name='" + name + '\'' +
                '}';
    }
    //先序查找
    public TreeNode preOrderSearch(int val){
        TreeNode.countPre++;
        if (this.val==val)
            return this;
        TreeNode tempNode=null;
        if (this.leftNext!=null)
            tempNode=this.leftNext.preOrderSearch(val);
        if (tempNode!=null)
            return tempNode;
        if (this.rightNext!=null)
            tempNode= this.rightNext.preOrderSearch(val);
        return tempNode;
    }
    //中序查找
    public TreeNode infixOrderSearch(int val){
        TreeNode.countInfix++;
        TreeNode tempNode=null;
        if (this.leftNext!=null)
            tempNode=this.leftNext.infixOrderSearch(val);
        if (tempNode!=null)
            return tempNode;
        if (this.val==val)
            return this;
        if (this.rightNext!=null)
            tempNode=this.rightNext.infixOrderSearch(val);
        return tempNode;
    }
    //后序查找
    public TreeNode postOrderSearch(int val){
        TreeNode.countPost++;
        TreeNode tempNode=null;
        if (this.leftNext!=null)
            tempNode=this.leftNext.postOrderSearch(val);
        if (tempNode!=null)
            return tempNode;
        if (this.rightNext!=null)
            tempNode=this.rightNext.postOrderSearch(val);
        if (tempNode!=null)
            return tempNode;
        if (this.val==val)
            return this;
        return tempNode;

    }
    //先序遍历
    public void preOrder(){
        System.out.println(this);
        if (this.leftNext!=null)
            this.leftNext.preOrder();
        if (this.rightNext!=null)
            this.rightNext.preOrder();
    }
    ///中序遍历
    public void infixOrder(){
        if (this.leftNext!=null)
            this.leftNext.infixOrder();
        System.out.println(this);
        if (this.rightNext!=null)
            this.rightNext.infixOrder();
    }
    //后序遍历
    public void postOrder(){
        if (this.leftNext!=null)
            this.leftNext.postOrder();
        if (this.rightNext!=null)
            this.rightNext.postOrder();
        System.out.println(this);
    }
}