首先创建一个结点类

no：结点的编号，也就是在树中的序号
value：结点的值
leftNode：当前结点的左结点
rightNode：当前结点的右节点

然后将这些属性封装起来，并重写toString方法，用于打印结点的信息

这些都属于结点的属性，所以都写在结点类中

package tree.binaryTreeSearcch;

/**
 * 创建一个结点
 */
class TreeNode {
    // 结点编号
    private int no;
    // 结点的值
    private int value;
    // 左结点
    private TreeNode leftNode;
    // 右节点
    private TreeNode rightNode;

    TreeNode(int no, int value) {
        this.no = no;
        this.value = value;
    }

    // 设置左结点
    public void setLeftNode(TreeNode leftNode) {
        this.leftNode = leftNode;
    }
    // 设置右节点
    public void setRightNode(TreeNode rightNode) {
        this.rightNode = rightNode;
    }

    public void setNo(int no) {
        this.no = no;
    }

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

    public int getNo() {
        return no;
    }

    public int getValue() {
        return value;
    }

    public TreeNode getLeftNode() {
        return leftNode;
    }

    public TreeNode getRightNode() {
        return rightNode;
    }

    @Override
    public String toString() {
        return "no : " + this.no + ", value : " + this.value;
    }
}

然后创建一个二叉树框架

其实在创建这个二叉树的时候，只设置一个根结点，而其它结点都是在根结点上依次往下相连的

在查找中，设置了一个target，用于接收找到的结点

如果找到目标结点，则返回这个结点
那么上一层target接收的就是找到的结点
然后在下面判断target是否为空时，向上一层返回的还是找到的那个结点
这样最终返回的依然是找到的结点

package tree.binaryTreeSearcch;

import java.util.LinkedList;
import java.util.Queue;

/**
 * 创建一个空的二叉树框架
 */
public class BinaryTree {

    private TreeNode root;

    // 设置根结点
    public void setNode(TreeNode root) {
        this.root = root;
    }
    // 获取根结点
    public TreeNode getNode() {
        return root;
    }
    /**
     * 实现二叉树的一些查找方法
     */
    // 先序查找指定结点
    public TreeNode preorderSearch(int no, TreeNode curNode) {
        TreeNode target = null;
        if (curNode == null) {
            return null;
        }
        // 如果找到目标结点，则返回这个结点
        // 那么上一层接收到的target也是这个结点
        // 然后在下面判断target是否为空时，向上一层返回的还是找到的那个结点
        // 这样最终返回的就是找到的结点
        if (curNode.getNo() == no) {
            return curNode;
        }
        target = preorderSearch(no, curNode.getLeftNode());
        if (target != null) { // 说明找到了
            return target;
        }
        target = preorderSearch(no, curNode.getRightNode());
        if (target != null) { // 说明找到了
            return target;
        }
        return target;
    }
    // 中序查找指定结点
    public TreeNode inorderSearch(int no, TreeNode curNode) {
        TreeNode target = null;
        if (curNode == null) {
            return null;
        }
        target = inorderSearch(no, curNode.getLeftNode());
        if (target != null) {
            return target;
        }
        if (curNode.getNo() == no) {
            return curNode;
        }
        target = inorderSearch(no, curNode.getRightNode());
        if (target != null) {
            return target;
        }
        return target;
    }
    // 后序查找指定结点
    public TreeNode postorderSearch(int no, TreeNode curNode) {
        TreeNode target = null;
        if (curNode == null) {
            return null;
        }
        target = postorderSearch(no, curNode.getLeftNode());
        if (target != null) {
            return target;
        }
        target = postorderSearch(no, curNode.getRightNode());
        if (target != null) {
            return target;
        }
        if (curNode.getNo() == no) {
            target = curNode;
            return curNode;
        }
        return target;
    }
    // 层次查找指定结点
    public TreeNode levelSearch(int no, TreeNode curNode) {
        TreeNode target = null;
        if (curNode == null) {
            return null;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(curNode);
        while (!queue.isEmpty()) {
            TreeNode treeNode = queue.poll();
            if (treeNode.getNo() == no) {
                return treeNode;
            }
            if (treeNode.getLeftNode() != null) {
                queue.offer(treeNode.getLeftNode());
            }
            if (treeNode.getRightNode() != null) {
                queue.offer(treeNode.getRightNode());
            }
        }
        return target;
    }
}

最后创建主方法，为二叉树赋予结点

查找返回的是一个结点，所以还需判断这个结点是否为空

如果为空，则说明没有找到
如果不为空，则说明找到了，然后打印出结点的信息

package tree.binaryTreeSearcch;

public class MainTest {
    public static void main(String[] args) {
        // 创建一个空的二叉树框架
        BinaryTree binaryTree = new BinaryTree();
        // 创建一个根结点
        TreeNode root = new TreeNode(0, 0);
        // 将根结点设置为二叉树的根
        binaryTree.setNode(root);
        // 创建其它结点
        TreeNode leftNode1 = new TreeNode(1, 11);
        TreeNode rightNode1 = new TreeNode(2, 22);
        TreeNode leftNode2 = new TreeNode(3, 33);
        TreeNode rightNode2 = new TreeNode(4, 44);
        // 将结点连接起来
        root.setLeftNode(leftNode1);
        root.setRightNode(rightNode1);
        leftNode1.setLeftNode(leftNode2);
        leftNode1.setRightNode(rightNode2);
        // 此时二叉树已经创建完成
        // 按序号查找指定结点
        // 先序查找
        TreeNode preResult = binaryTree.preorderSearch(1, root);
        if (preResult != null) {
            System.out.println("前序查找--> " + preResult.toString());
        } else {
            System.out.println("前序查找：没有找到此结点");
        }
        // 中序查找
        TreeNode inResult = binaryTree.inorderSearch(2, root);
        if (inResult != null) {
            System.out.println("中序查找--> " + inResult.toString());
        } else {
            System.out.println("中序查找：没有找到此结点");
        }
        // 后序查找
        TreeNode postResult = binaryTree.postorderSearch(3, root);
        if (postResult != null) {
            System.out.println("后序查找--> " + postResult.toString());
        } else {
            System.out.println("后序查找：没有找到此结点");
        }
        // 层次查找
        TreeNode levelResult = binaryTree.levelSearch(4, root);
        if (levelResult != null) {
            System.out.println("层次查找--> " + levelResult.toString());
        } else {
            System.out.println("层次查找：没有找到此结点");
        }
    }
}