搜索二叉树的子树

package digui;

/**
 * 按照树形结构直观地打印出一棵二叉树(Java)
 */
public class TreeOperation {
    /*
    树的结构示例：
              1
            /   \
          2       3
         / \     / \
        4   5   6   7
    */

    // 用于获得树的层数
    public static int getTreeDepth(TreeNode root) {
        return root == null ? 0 : (1 + Math.max(getTreeDepth(root.left), getTreeDepth(root.right)));
    }


    private static void writeArray(TreeNode currNode, int rowIndex, int columnIndex, String[][] res, int treeDepth) {
        // 保证输入的树不为空
        if (currNode == null) return;
        // 先将当前节点保存到二维数组中
        res[rowIndex][columnIndex] = String.valueOf(currNode.val);

        // 计算当前位于树的第几层
        int currLevel = ((rowIndex + 1) / 2);
        // 若到了最后一层，则返回
        if (currLevel == treeDepth) return;
        // 计算当前行到下一行，每个元素之间的间隔（下一行的列索引与当前元素的列索引之间的间隔）
        int gap = treeDepth - currLevel - 1;

        // 对左儿子进行判断，若有左儿子，则记录相应的"/"与左儿子的值
        if (currNode.left != null) {
            res[rowIndex + 1][columnIndex - gap] = "/";
            writeArray(currNode.left, rowIndex + 2, columnIndex - gap * 2, res, treeDepth);
        }

        // 对右儿子进行判断，若有右儿子，则记录相应的"\"与右儿子的值
        if (currNode.right != null) {
            res[rowIndex + 1][columnIndex + gap] = "\\";
            writeArray(currNode.right, rowIndex + 2, columnIndex + gap * 2, res, treeDepth);
        }
    }


    public static void show(TreeNode root) {
        if (root == null) System.out.println("EMPTY!");
        // 得到树的深度
        int treeDepth = getTreeDepth(root);

        // 最后一行的宽度为2的（n - 1）次方乘3，再加1
        // 作为整个二维数组的宽度
        int arrayHeight = treeDepth * 2 - 1;
        int arrayWidth = (2 << (treeDepth - 2)) * 3 + 1;
        // 用一个字符串数组来存储每个位置应显示的元素
        String[][] res = new String[arrayHeight][arrayWidth];
        // 对数组进行初始化，默认为一个空格
        for (int i = 0; i < arrayHeight; i ++) {
            for (int j = 0; j < arrayWidth; j ++) {
                res[i][j] = " ";
            }
        }

        // 从根节点开始，递归处理整个树
        // res[0][(arrayWidth + 1)/ 2] = (char)(root.val + '0');
        writeArray(root, 0, arrayWidth/ 2, res, treeDepth);

        // 此时，已经将所有需要显示的元素储存到了二维数组中，将其拼接并打印即可
        for (String[] line: res) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < line.length; i ++) {
                sb.append(line[i]);
                if (line[i].length() > 1 && i <= line.length - 1) {
                    i += line[i].length() > 4 ? 2: line[i].length() - 1;
                }
            }
            System.out.println(sb.toString());
        }
    }
}

 

package digui;

/**
 * @author yuchen
 * @version 1.0
 * @date 2019-12-19 17:57
 */
public class 搜索二叉树的子树 {

    public static TreeNode searchTreeNode(TreeNode treeNode,int val){

        if(treeNode == null || val == treeNode.val){
            return treeNode;
        }

        /**
         * 二叉树存储规律 左子树 < 根节点 < 右子树
         */
        if(treeNode.val > val){
            return searchTreeNode(treeNode.left,val);
        }

        if(treeNode.val < val){
            return searchTreeNode(treeNode.right,val);
        }

        return null;
    }
}

package digui;

/**
 * 示例：
 *
 * 输入：
 *
 *      4
 *    /   \
 *   2       7
 *  / \     /  \
 * 1   3    6   9
 *
 * 给定二叉搜索树（BST）的根节点和一个值。 你需要在BST中找到节点值等于给定值的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 NULL。
 *
 * 例如，
 *
 * 给定二叉搜索树:
 *
 *         4
 *        / \
 *       2   7
 *      / \
 *     1   3
 *
 * 和值: 2
 * 你应该返回如下子树:
 *
 *       2
 *      / \
 *     1   3
 * 在上述示例中，如果要找的值是 5，但因为没有节点值为 5，我们应该返回 NULL。
 *
 * 来源：力扣（LeetCode）
 * 链接：https://leetcode-cn.com/problems/search-in-a-binary-search-tree
 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 */
public class TreeOperatinTest7 {
    public static void main(String[] args) {
    	// 根据给定的数组创建一棵树
        TreeNode treeNode5 = new TreeNode(6,null,null);
        TreeNode treeNode7 = new TreeNode(9,null,null);

        TreeNode treeNode6 = new TreeNode(3,null,null);
        TreeNode treeNode4 = new TreeNode(1,null,null);

        TreeNode treeNode2 = new TreeNode(2,treeNode4,treeNode6);
        TreeNode treeNode3 = new TreeNode(7,treeNode5,treeNode7);
        TreeNode treeNode1 = new TreeNode(4,treeNode2,treeNode3);



        // 将刚刚创建的树打印出来
        TreeOperation.show(treeNode1);

        TreeNode treeNode = 搜索二叉树的子树.searchTreeNode(treeNode1,7);
        TreeOperation.show(treeNode);

        TreeNode treeNode00 = 搜索二叉树的子树.searchTreeNode(treeNode1,3);
        TreeOperation.show(treeNode00);

    }
}

打印结果:

       4      
    /   \    
  2       7  
 / \     / \ 
1   3   6   9
   7   
  / \  
 6   9 
3