算法-题目汇总-4

1. 二叉树的最大子bst树 使用二叉树套路 bst树的特点左边的最大值小于根节点的值 右边的最小值 大于根节点的值 

注意判断null值 因为结束条件返回的null

public TreeNode node(TreeNode head) {
        BSTInfo process = process(head);
        return process.maxSizeHead;
    }

    public BSTInfo process(TreeNode node) {
        if (node == null) {
            return null;
        }
        BSTInfo leftRes = process(node.left);
        BSTInfo rightRes = process(node.right);
        int maxNode = node.value;
        int minNode = node.value;
        int maxSize = 0;
        TreeNode maxSizeHead = null;
        boolean isbst = false;
        if (leftRes != null) {
            maxNode = Math.max(maxNode, leftRes.maxNode);
            minNode = Math.min(minNode, leftRes.minNode);

        }
        if (rightRes != null) {
            maxNode = Math.max(maxNode, rightRes.maxNode);
            minNode = Math.min(minNode, rightRes.minNode);
        }
　　　　　　// 左子树找到的最大bst的头结点
        if (leftRes != null) {
            maxSize = leftRes.maxSize;
            maxSizeHead = leftRes.maxSizeHead;
        }
　　　　　　// 右树找到的最大bst的头结点
        if (rightRes != null && rightRes.maxSize > maxSize) {
            maxSize = rightRes.maxSize;
            maxSizeHead = rightRes.maxSizeHead;
        }
　　　　// 根节点是bst的根节点 左树 和 右树 跟 根节点 可以连起来的判断 连起来肯定比上面的maxsize大
        if ((leftRes == null || leftRes.isBst) && (rightRes == null || rightRes.isBst)) {
            if ((leftRes == null || leftRes.maxNode < node.value) && (rightRes == null || rightRes.minNode > node.value)) {
                isbst = true;
                maxSize = (leftRes == null ? 0 : leftRes.maxSize) + (rightRes == null ? 0 : rightRes.maxSize) + 1;
                maxSizeHead = node;
            }
        }
        return new BSTInfo(maxSize, maxSizeHead, maxNode, minNode, isbst);
    }

public class BSTInfo {
    public Integer maxSize;
    public TreeNode maxSizeHead;
    public Integer maxNode;
    public Integer minNode;
    public boolean isBst;

    public BSTInfo(Integer maxSize, TreeNode maxSizeHead, Integer maxNode, Integer minNode, boolean isBst) {
        this.maxSize = maxSize;
        this.maxSizeHead = maxSizeHead;
        this.maxNode = maxNode;
        this.minNode = minNode;
        this.isBst = isBst;
    }
}

 

2. 子数组的最大累加和

　　结果假设法 

　　假设答案是数组中累加和最大并且 数量最多的那一段,所以在这段的开头位置是 前面数组相加是负数的index的下一项, 因为如果是正数就会包含在累加和中,

　　当出现等于-1的时候说明这段就可能是最大的累加和那段 所以开始相加 如果是结果的话 cur值会超过前面的max 如果超过就说明这段是 当下一次出现cur等于负数的时候

　　再判断下一段是不是最大累加和 

 　　

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

3. 矩阵的最大累加和

 -5 3 6 4

 -7 9 -5 3

 -10 1 -200 4

先求0行最大累加和

再求 0-1行最大累加和

再求 0-2行最大累加和

再求1-2行最大累加和

再求2行最大累加和 

两行或者多行的如何求 以0-1行为例 (-5+-7),(3+9),(6+-5),(4,3) 求最大累加和

 

4. 路灯问题,在AB组成的数组中,A位置不需要照亮 B位置需要照亮 路灯可以照亮n-1 n n+1的位置,求最少需要多少个路灯

public int lessLeight(String str) {
            if (str == null || str.isEmpty()) {
                return 0;
            }
            char[] chars = str.toCharArray();
            int leight = 0;
            int index = 0;
            while (index < chars.length) {
                if (chars[index] == 'X') {
                    index++;
                } else {
                    leight++;
                    if (index + 1 == chars.length) {
                        break;
                    } else {
                        if (chars[index + 1] == 'X') {
                            // index直接跳过这个x
                            index += 2;
                        } else {
                            // index+1 是.
                            index += 3;
                        }
                    }
                }
            }
            return leight;
        }

5. 给你先序遍历的数组 和 中序遍历的数组 返回后续遍历的数组

public int[] getPost(int[] pre, int[] mid) {
        int length = pre.length;
        int[] after = new int[length];
        getPost(pre, mid, after, 0, length - 1, 0, length - 1, 0, length - 1);
        return after;
    }

    public void getPost(int[] pre, int[] mid, int[] after, int p1, int p2, int m1, int m2, int a1, int a2) {
        if (p1 > p2) {
            return;
        }
        if (p1 == p2) {
            after[a1] = pre[p1];
            return;
        }
        after[a2] = pre[p1];
        int find = m1;
        while (mid[find] != pre[p1]) {
            find++;
        }
        getPost(pre, mid, after, p1 + 1, p1 + find - m1, m1, find - 1, a1, a1 + find - m1 - 1);
        getPost(pre, mid, after, p1 + find - m1 + 1, p2, find + 1, m2, a1 + find - m1, m2 - 1);
    }

6. 数字转中文读法

 

 public String numTo9(int num) {
        if (num < 0 || num > 9) {
            return "";
        }
        String[] names = {"一", "二", "三", "四", "五", "六", "七", "八", "九"};
        return names[num - 1];
    }

    public String numTo99(int num, boolean hasBai) {
        if (num < 1 || num > 99) {
            return "";
        }
        if (num < 10) {
            return numTo9(num);
        }
        int shi = num / 10;
        if (shi == 1 && (!hasBai)) {
            return "十" + numTo9(num % 10);
        } else {
            return numTo9(shi) + "十" + numTo9(num % 10);
        }
    }

    public String numTo999(int num) {
        if (num < 1 || num > 999) {
            return "";
        }
        if (num < 100) {
            return numTo99(num, false);
        }
        String res = numTo9(num / 100) + "百";
        int i = num % 100;
        if (i == 0) {
            return res;
        } else if (i >= 10) {
            return res + numTo99(i, true);
        } else {
            return res + "零" + numTo9(i);
        }
    }

    public String numTo9999(int num) {
        if (num < 1 || num > 9999) {
            return "";
        }
        if (num < 1000) {
            return numTo999(num);
        }
        int i = num / 1000;
        int j = num % 1000;
        String res = numTo9(i) + "千";
        if (j == 0) {
            return res;
        } else if (j > 100) {
            res += numTo999(j);
        } else {
            res += "零" + numTo99(j, false);
        }
        return res;
    }

    public String numTo99999(int num) {
        if (num < 1 || num > 99999999) {
            return "";
        }
        if (num < 10000) {
            return numTo9999(num);
        }
        int i = num / 10000;
        int j = num % 10000;
        String res = numTo9999(i) + "万";
        if (j == 0) {
            return res;
        } else if (j > 1000) {
            res += numTo9999(j);
        } else {
            res += "零" + numTo999(j);
        }
        return res;
    }

    public String numTo999999999(int num) {
        if (num == 0) {
            return "零";
        }
        String res = num < 0 ? "负" : "";
        int i = Math.abs(num / 100000000);
        int j = Math.abs(num % 100000000);
        if (i == 0) {
            return res + numTo99999(num);
        }
        res += numTo9999(i) + "亿";
        if (j == 0) {
            return res;
        } else {
            if (j < 10000000) {
                return res + "零" + numTo99999(j);
            } else {
                return res + numTo99999(j);
            }
        }
    }

7. 求完全二叉树的节点个数

 先看右子树的最左节点有没有到最大的深度

　达到了 说明左子树是满二叉树 个数是(2^n)-1

 　没达到 说明右子树是满二叉树 个数是(2^n)-1

 　结束条件是当前节点到底最底层的时候 return 1;

　　

 public int getCount(TreeNode head) {
        return bs(head, 1, getrLevel(head, 1));
    }

    public int bs(TreeNode node, int level, int h) {
        if (level == h) {
            return 1;
        }
        if (getrLevel(node.right, level + 1) == h) {
            // 右子树的最左节点到底了最大深度
            return (1 << (h - level)) + bs(node.right, level + 1, h);
        } else {
           // h-level-1 右子树是满二叉树 但是比左数少一层
            return (1 << (h - level - 1)) + bs(node.left, level + 1, h);
        }
    }    

8. 最长递增子序列

 3 1 2 6 3 4 的最长子序列是 1,2,3,4

 dp问题,从3开始 找3左边比3小的数没有 所以最长子序列是1个

1左边没有 结果1

2左边有1 ,1的最长子序列是1 所以2结果是2

6左边比他小的是2 2的子序列是2 所以6的结果是3

3 左边比他小的是2 3结果是3

4左边比他小的是3 结果是4

 

9. 1234 能否被3整除? 转换成1+2+3+4 能否被3整除