数据结构与算法单排日记-2020/4/1-树 & 二叉树查找

public class TreeNode {
    private int num;//节点标号
    private String name;//节点信息
    private TreeNode left; //左节点
    private TreeNode right;//右节点

    //构造方法
    public TreeNode(int num, String name) {
        this.num = num;
        this.name = name;
    }

    //setter和getter
    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

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

    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;
    }

    //toString
    @Override
    public String toString() {
        return "TreeNode{" +
                "num=" + num +
                ", name='" + name + '\'' +
                '}';
    }
}

public class BinaryTree2 {
    public static void main(String[] args) {
        //创建节点
        TreeNode node1 = new TreeNode(1, "节点1");
        TreeNode node2 = new TreeNode(2, "节点2");
        TreeNode node3 = new TreeNode(3, "节点3");
        TreeNode node4 = new TreeNode(4, "节点4");
        TreeNode node5 = new TreeNode(5, "节点5");
        TreeNode node6 = new TreeNode(6, "节点6");

        //创建树
        /*
         *         1
         *    2       3
         *4      5
         * */
        node1.setLeft(node2);
        node1.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);

        System.out.println(proSearch(node1,node4));
        System.out.println(infixSearch(node1,node3));
        System.out.println(postSearch(node1,node6));

    }

    /**
     * 前序查找
     */
   /* public static void proSearch(TreeNode node, TreeNode findnode) {
        if (node == findnode) {
            System.out.println(node.toString());
        }
        if (node.getLeft() != null) {
            proSearch(node.getLeft(), findnode);
        }
        if  (node.getRight() != null) {
           proSearch(node.getRight(), findnode);
        }
    }*/
    public static TreeNode proSearch(TreeNode node, TreeNode findnode) {
        //先比较当前节点受不是
        if (node == findnode) {
            return node;
        }
        //创建一个临时节点，作为结果
        TreeNode res = null;

        //如果当前节点不是，那么开始寻找左子树
        if (node.getLeft()!=null){
            res = proSearch(node.getLeft(),findnode);//将其左子树的节点赋值给res
        }
        //当遍历完左子树后，如果res不为null，说明执行了if (node == findnode) {return node;},res被赋值
        if (res !=null){
            return res;
        }

        //当遍历完右子树后，如果res不为null，说明执行了if (node == findnode) {return node;},res被赋值
        if (node.getRight()!=null){
            res = proSearch(node.getRight(),findnode);
        }

        return res;
    }


    /**
     * 中序查找
     */

    public static TreeNode infixSearch(TreeNode node, TreeNode findnode) {
        TreeNode res = null;
        //左子树
        if (node.getLeft()!=null){
            res = infixSearch(node.getLeft(),findnode);
        }
        if (res !=null){
            return res;
        }
        //本身
        if (node == findnode) {
            return node;
        }
        //右子树
        if (node.getRight()!=null){
            res =infixSearch(node.getRight(),findnode);
        }

        return res;

    }

    /*
    *后续查找
     */
    public static TreeNode postSearch(TreeNode node, TreeNode findnode) {
        TreeNode res = null;
        //右子树
        if (node.getRight()!=null){
            res = postSearch(node.getRight(),findnode);
        }
        if (res !=null){
            return res;
        }

        //本身
        if (node == findnode) {
            return node;
        }

        //左子树
        if (node.getLeft()!=null){
            res = postSearch(node.getLeft(),findnode);
        }
        return res;
    }
}