二叉树-查找指定节点

二叉树查找指定节点思路

前序查找思路

当前节点是否为空，不为空判断当前节点的rank是否等于要查找的rank
若等于，则返回当前节点；
若不等于，则判断当前节点的左子节点是否为空，
如果不为空，则继续向左递归前序查找，如果左递归前序查找，
找到了节点，则返回；
若没找到，则继续判断当前节点的右子节点是否为空，
如果不为空，则继续向右递归前序查找，如果右递归前序查找，找到了节点，则返回。若没找到则为空。

/**
 *  树的节点
 */
class TreeNode{
    public int rank;//排名
    public String name;//姓名
    public TreeNode left;//左节点
    public TreeNode right;

    /**
     * 构造函数
     * @param rank
     * @param name
     */
    public TreeNode(int rank,String name){
        this.rank = rank;
        this.name = name;
    }

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

class BinaryTree{

    /**
     * 前序遍历查询
     * @param node  根节点
     * @param rank  排名
     * @return
     */
    public static TreeNode preOrderTraversalSearch(TreeNode node,int rank){
        //判断当前节点是不是为空，若不为空
        if (node != null){
            //则判断需要查询的排名，与当前节点的排名是否相等
            if (node.rank == rank){
                return node;
            }
        }
        TreeNode resultNode = null;
        //向左遍历，如果左子节点不为空
        if (node.left != null){
            resultNode = preOrderTraversalSearch(node.left,rank);
            if (resultNode != null){
                return resultNode;
            }
        }
        //向右遍历，如果左子节点不为空
        if (node.right != null){
            resultNode = preOrderTraversalSearch(node.right,rank);
            if (resultNode != null){
                return resultNode;
            }
        }
        return resultNode;
    }
}

public class BinaryTreeDemo {

    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
        TreeNode root = new TreeNode(1, "宋江");
        TreeNode node2 = new TreeNode(2, "卢俊义");
        TreeNode node3 = new TreeNode(3, "吴用");
        TreeNode node4 = new TreeNode(4, "公孙胜");
        TreeNode node5 = new TreeNode(5, "关胜");
        TreeNode node6 = new TreeNode(6, "林冲");
        root.left = node3;
        root.right = node2;
        node2.right = node4;
        node2.left = node5;
        node3.right = node6;
        TreeNode node = binaryTree.preOrderTraversalSearch(root, 5);
        System.out.println("获取到的节点： " + node);
    }
}

中序查找思路

判断当前节点是否为空，不为空，
则判断当前节点的左子节点是否为空，左子节点不为空则中序递归遍历查找，若找到了要查找的节点，则返回；
若没找到，则判断当前节点，若找到了节点，则返回；
若不是，则判断当前节点的右子节点是否为空，右子节点不为空则中序递归遍历查找，若找到了节点，则返回

/**
 *  树的节点
 */
class TreeNode{
    public int rank;//排名
    public String name;//姓名
    public TreeNode left;//左节点
    public TreeNode right;

    /**
     * 构造函数
     * @param rank
     * @param name
     */
    public TreeNode(int rank,String name){
        this.rank = rank;
        this.name = name;
    }

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

class BinaryTree{

    /**
     * 中序遍历查询
     * @param node  根节点
     * @param rank  排名
     * @return
     */
    public static TreeNode inOrderTraversalSearch(TreeNode node, int rank){
        if (node == null){
            return null;
        }
        TreeNode treeNode = null;
        if (node.left != null){
            treeNode = inOrderTraversalSearch(node.left,rank);
            if (treeNode != null){
                return treeNode;
            }
        }
        System.out.println(node);
        if (node.rank == rank){
            return node;
        }
        if (node.right != null){
            treeNode = inOrderTraversalSearch(node.right,rank);
            if (treeNode != null){
                return treeNode;
            }
        }

        return treeNode;
    }
}

public class BinaryTreeDemo {

    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
        TreeNode root = new TreeNode(1, "宋江");
        TreeNode node2 = new TreeNode(2, "卢俊义");
        TreeNode node3 = new TreeNode(3, "吴用");
        TreeNode node4 = new TreeNode(4, "公孙胜");
        TreeNode node5 = new TreeNode(5, "关胜");
        TreeNode node6 = new TreeNode(6, "林冲");
        root.left = node3;
        root.right = node2;
        node2.right = node4;
        node2.left = node5;
        node3.right = node6;
        TreeNode node = binaryTree.inOrderTraversalSearch(root, 10);
        System.out.println("获取到的节点： " + node);
    }
}

后续查找思路

判断当前节点是否为空，不为空，
则判断当前节点的左子节点是否为空，左子节点不为空则中序递归遍历查找，若找到了要查找的节点，则返回；
若不是，则判断当前节点的右子节点是否为空，右子节点不为空则中序递归遍历查找，若找到了节点，则返回；
若没找到，则判断当前节点，若找到了节点，则返回

/**
 *  树的节点
 */
class TreeNode{
    public int rank;//排名
    public String name;//姓名
    public TreeNode left;//左节点
    public TreeNode right;

    /**
     * 构造函数
     * @param rank
     * @param name
     */
    public TreeNode(int rank,String name){
        this.rank = rank;
        this.name = name;
    }

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

class BinaryTree{
   
    /**
     * 后序遍历查询
     * @param node  根节点
     * @param rank  排名
     * @return
     */
    public TreeNode postOrderTraversalSearch(TreeNode node, int rank){
        if (node == null){
            return null;
        }
        TreeNode treeNode = null;
        if (node.left != null){
            treeNode = postOrderTraversalSearch(node.left,rank);
            if (treeNode != null){
                return treeNode;
            }
        }
        if (node.right != null){
            treeNode = postOrderTraversalSearch(node.right,rank);
            if (treeNode != null){
                return treeNode;
            }
        }
        if (node.rank == rank){
            return node;
        }
        return treeNode;
    }
}

public class BinaryTreeDemo {

    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
        TreeNode root = new TreeNode(1, "宋江");
        TreeNode node2 = new TreeNode(2, "卢俊义");
        TreeNode node3 = new TreeNode(3, "吴用");
        TreeNode node4 = new TreeNode(4, "公孙胜");
        TreeNode node5 = new TreeNode(5, "关胜");
        TreeNode node6 = new TreeNode(6, "林冲");
        root.left = node3;
        root.right = node2;
        node2.right = node4;
        node2.left = node5;
        node3.right = node6;
        TreeNode node = binaryTree.postOrderTraversalSearch(root, 5);
        System.out.println("获取到的节点： " + node);
    }
}