左神算法之中级提升（6）二叉树的递归套路

目录

【案例1】

【题目描述】

 【思路解析】

【代码实现】

【案例2】

【题目描述】

【思路解析】

【代码实现】

【案例3】

【题目描述】

 【思路解析】

【代码实现】

【案例4】

【题目描述】 2018年美团面试题

【思路解析】

【代码实现】

【案例5】

【题目描述】

【思路解析】

 【代码实现】

---

【案例1】

【题目描述】

 【思路解析】

(8条消息) 详解前缀树和贪心算法_Studying~的博客-CSDN博客

(8条消息) 详解图论算法 图的宽度优先遍历 图的深度优先遍历 图的拓扑排序算法 kruskal算法 prim算法 Dijkstra算法_Studying~的博客-CSDN博客

先根据这个字符串类型的数组，先生成一个前缀树，然后再对这个前缀树进行深度优先遍历，在深度优先遍历时，根据层数来控制输出的空格即可。

【代码实现】

import java.util.HashMap;

/**
 * @ProjectName: study3
 * @FileName: Ex1
 * @author:HWJ
 * @Data: 2023/7/24 15:38
 */
public class Ex1 {
    public static void main(String[] args) {
        String[] folderPaths = {"a\\b\\c", "b\\f\\k"};
        ex(folderPaths);
    }

    public static void ex(String[] folderPaths){
        Node node = generateFolderTree(folderPaths);
        process(node, 0);
    }

    // 构建前缀树
    public static Node generateFolderTree(String[] folderPaths){
        Node head = new Node(" "); // 系统根目录，前缀树头节点
        for (String folderPath : folderPaths) {
            //  folderPath.split("\\\\") 的split函数里面即含转义匹配又含正则匹配
            // 通过转义匹配  \\\\ 被解释为 \\ , \\再通过正则匹配解释为 \，所以这\\\\最终被解释为\。
            String[] paths = folderPath.split("\\\\");
            Node cur = head;
            for (int i = 0; i < paths.length; i++) {
                // 根据前缀树规则，如果不存在这条路径就新建，存在就复用
                if (!cur.nextMap.containsKey(paths[i])){
                    cur.nextMap.put((paths[i]), new Node(paths[i]));
                }
                cur = cur.nextMap.get(paths[i]);
            }
        }

        return head;
    }

    // 深度优先遍历
    public static void process(Node node, int level){
        if(level != 0){
            System.out.println(print2Space(level) + node.name);
        }
        for (Node cur : node.nextMap.values()) {
            process(cur, (level + 1));
        }

    }

    // 得到相应的空格
    public static String print2Space(int n){
        String s = "";
        for (int i = 1; i < n; i++) {
            s += "  ";
        }
        return s;
    }

}

class Node {
    public String name;
    public HashMap<String, Node> nextMap;

    public Node(String name) {
        this.name = name;
        this.nextMap = new HashMap<>();
    }
}

【案例2】

【题目描述】

【思路解析】

这里使用二叉树的递归套路，假设一个以Node节点开头的二叉树，如果他的左子树能转为一个双向链表，且他的右子树也能转为一个双向链表，则我们只需要将左子树的双向链表的末尾连向Node节点，右子树的双向链表的开头连向Node节点。然后左子树的双向链表的头，右子树的双向链表的尾就作为整个双向链表的头和尾。

【代码实现】

/**
 * @ProjectName: study3
 * @FileName: Ex2
 * @author:HWJ
 * @Data: 2023/7/29 9:08
 */
public class Ex2 {
    public static void main(String[] args) {

    }

    public static Node convert(Node head){
        if (head == null){
            return null;
        }
        return process(head).start;
    }

    // 搜索二叉树转为双向链表后返回的头和尾信息。
    public static class Info{
        public Node start;
        public Node end;

        public Info(Node start, Node end) {
            this.start = start;
            this.end = end;
        }
    }

    // 节点类
    public static class Node{
        public int value;
        public Node right;
        public Node left;

        public Node(int value) {
            this.value = value;
        }
    }

    public static Info process(Node X){
        if (X == null){
            return new Info(null, null);
        }
        Info leftHeadEnd = process(X.left);
        Info rightHeadEnd = process(X.right);
        if (leftHeadEnd.end != null){
            leftHeadEnd.end.right = X;
            X.left = leftHeadEnd.end;
        }
        if (rightHeadEnd.start != null){
            X.right = rightHeadEnd.start;
            rightHeadEnd.start.left = X;
        }
        return new Info(leftHeadEnd.end != null ? leftHeadEnd.end : X,
                rightHeadEnd.end != null ? rightHeadEnd.end : X);
    }
}

【案例3】

【题目描述】

找到一颗二叉树中，最大的搜索二叉子树，返回最大搜索二叉子树的头结点。

 【思路解析】

对于这个二叉树的任意一个节点X，有两种情况。

（1) 他作为最大搜索二叉子树的头结点。则他需要满足左子树是搜索二叉树，右子树是搜索二叉树。左子树的最大值小于X节点的值，右子树的最小值大于X节点的值。

（2）他不作为最大搜索二叉子树的头结点。 需要他左子树的最大搜索二叉子树的头结点和大小的信息，还有需要他右子树的最大搜索二叉子树的头结点和大小的信息。通过比较大小，就得到了以X节点下的最大搜索二叉子树。

所以对于任意一个节点我们需要他的信息为，以他为头结点的子树是否是搜索二叉树，子树的最大值，子树的最小值，子树的最大搜索二叉子树的头节点，子树的最大搜索二叉子树的大小。

【代码实现】

/**
 * @ProjectName: study3
 * @FileName: Ex3
 * @author:HWJ
 * @Data: 2023/7/29 9:48
 */
public class Ex3 {
    public static void main(String[] args) {

    }

    public static class Node {
        public int value;
        public Node left;
        public Node right;

        public Node(int value) {
            this.value = value;
        }
    }

    public static class Info {
        public Node head; // 最大搜索二叉子树的头结点
        public int max; // 这颗树的最大值。
        public int min; // 这棵树的最小值
        public boolean isBst; // 这棵树是否为搜索二叉树
        public int size; // 最大搜索二叉子树的大小

        public Info(Node head, int max, int min, boolean isBst, int size) {
            this.head = head;
            this.max = max;
            this.min = min;
            this.isBst = isBst;
            this.size = size;
        }
    }

    public static Info process(Node x) {
        if (x == null) {
            return new Info(null, Integer.MIN_VALUE, Integer.MAX_VALUE, true, 0);
        }
        Info leftBst = process(x.left);
        Info rightBst = process(x.right);
        int min = Math.min(x.value, Math.min(leftBst.min, rightBst.min));
        int max = Math.max(x.value, Math.max(leftBst.max, rightBst.max));
        boolean isBst = false;
        int size = Math.max(leftBst.size, rightBst.size);
        Node head = size == leftBst.size ? leftBst.head : rightBst.head;
        if (leftBst.isBst && rightBst.isBst) {
            if (leftBst.max < x.value && x.value < rightBst.min) {
                size = leftBst.size + rightBst.size + 1;
                isBst = true;
                head = x;
            }
        }
        return new Info(head, max, min, isBst, size);
    }

}

【案例4】

【题目描述】 2018年美团面试题

【思路解析】

设计两个变量，max和cur，max初始为系统最小Integer.MIN_VALUE，cur初始为0，遍历数组，cur+=arr[i]，如果能使max更新则更新，如果不能则不变，如果cur<0，则使cur=0；

【代码实现】

/**
 * @ProjectName: study3
 * @FileName: Ex4
 * @author:HWJ
 * @Data: 2023/7/29 11:00
 */
public class Ex4 {
    public static void main(String[] args) {

    }

    public static int getMaxScore(int[] arr){
        if (arr == null || arr.length == 0){
            return 0;
        }
        int cur = 0;
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < arr.length; i++) {
            cur += arr[i];
            max = Math.max(cur, max);
            cur = Math.max(cur, 0);
        }
        return max;
    }
}

【案例5】

【题目描述】

子矩阵只能为长方形或者正方形。

【思路解析】

利用矩阵压缩技巧，对于子矩阵则它有多种情况，最优解可以出现在 第i行到第j行的最优长方形中，所以我们遍历各种矩阵，然后将矩阵压缩成一个一维数组，然后找到这个一维数组的最优解。

 【代码实现】

/**
 * @ProjectName: study3
 * @FileName: Ex5
 * @author:HWJ
 * @Data: 2023/7/29 11:12
 */
public class Ex5 {
    public static void main(String[] args) {

    }

    public static int getMaxMatrix(int[][] map){
        if (map == null || map.length == 0 || map[0].length == 0){
            return 0;
        }
        int max = Integer.MIN_VALUE;
        int cur = 0;
        int[] s = null;
        // 开始的行号i
        for (int i = 0; i < map.length; i++) {
            s = new int[map[i].length];
            for (int j = i; j < map.length; j++) { // 以i行号开始，以j行号结尾
                cur = 0;
                for (int k = 0; k < map[0].length; k++) {
                    s[k] += map[j][k];
                    cur += s[k];
                    max = Math.max(cur, max);
                    cur = Math.max(0, cur);
                }
            }
        }
        return max;
    }

}