11.23-11.29

11.23日

452.用最少数量的箭引爆气球

class Solution {
    public int findMinArrowShots(int[][] points) {
        if(points.length < 1) {
            return 0;
        }
        Arrays.sort(points, (o1, o2) -> {
            return o1[1] < o2[1] ? -1 : 1;
        });
        int num = points[0][1];
        int sum = 1;
        for(int i = 1; i < points.length; i ++) {
            if(num < points[i][0]) {
                sum ++;
                num = points[i][1];
            }
        }
        return sum;
    }
}

11.24日

222.完全二叉树的节点个数

//递归遍历每个结点，直接计算结点的个数
class Solution {
    public int countNodes(TreeNode root) {
        if(root == null) {
            return 0;
        }
        return countNodes(root.left) + countNodes(root.right) + 1;
    }
}

/*
二分法，判断左右子树的树高是否相等
如果相等，则结点数 = 2的左边树高方 + 右边的结点数（继续二分计算）
不相等，则结点数 = 2的右边数高方 + 左边的结点数（继续二分计算）
*/
class Solution {
    public int countNodes(TreeNode root) {
        if(root == null) {
            return 0;
        }
        int left = heightTree(root.left);
        int right = heightTree(root.right);
        if(left == right) {
            return countNodes(root.right) + cal(left);
            //可以用位运算代替cal方法
            //return countNodes(root.right) + (1 << left)
        } else {
            return countNodes(root.left) + cal(right);
        }
    }
	
    public int cal(int num) {
        int sum = 1;
        for(int i = 0; i < num; i ++) {
            sum *= 2;
        }
        return sum;
    }

    public int heightTree(TreeNode root) {
        if(root == null) {
            return 0;
        }
        return heightTree(root.left) + 1;
    }
}

11.25日

1370.上升下降字符串

class Solution {
    public String sortString(String s) {
        if(s == null || s.length() == 0) {
            return "";
        }
        char[] s1 = s.toCharArray();
        int[] map = new int[26];
        for(int i = 0; i < s1.length; i ++) {
            map[s1[i] - 'a'] ++;
        }
        String ans = "";
        while(ans.length() < s.length()) {
            for(int i = 0; i < 26; i ++) {
                if(map[i] != 0) {
                    ans += (char)(i + 'a');
                    map[i] --;
                }
            }
            for(int i = 25; i >= 0; i--) {
                if(map[i] != 0) {
                    ans += (char)(i + 'a');
                    map[i] --;
                }
            }
        }
        return ans;
    }
}

ans用StringBuilder类型的会快很多

class Solution {
    public String sortString(String s) {
        if(s == null || s.length() == 0) {
            return "";
        }
        char[] s1 = s.toCharArray();
        int[] map = new int[26];
        for(int i = 0; i < s1.length; i ++) {
            map[s1[i] - 'a'] ++;
        }
        StringBuilder ans = new StringBuilder();
        while(ans.length() < s.length()) {
            for(int i = 0; i < 26; i ++) {
                if(map[i] != 0) {
                    ans.append((char) (i + 'a'));
                    map[i] --;
                }
            }
            for(int i = 25; i >= 0; i--) {
                if(map[i] != 0) {
                    ans.append((char) (i + 'a'));
                    map[i] --;
                }
            }
        }
        return ans.toString();
    }
}

11.26日

164.最大间距

class Solution {
    public int maximumGap(int[] nums) {
        if(nums.length < 2) {
            return 0;
        }
        
        Arrays.sort(nums);  //sort真香

        int maxLen = nums[1] - nums[0];
        for(int i = 1; i < nums.length - 1; i ++) {
            int tmp = nums[i+1] - nums[i];
            maxLen = maxLen > tmp ? maxLen : tmp;
        }
        return maxLen;
    }
}

class Solution {
    public int maximumGap(int[] nums) {
        int n = nums.length;
        if (n < 2) {
            return 0;
        }
        int minVal = Arrays.stream(nums).min().getAsInt();  // 计算最小值
        int maxVal = Arrays.stream(nums).max().getAsInt();  // 计算最大值
        // 桶区间大小因子d
        int d = Math.max(1, (maxVal - minVal) / (n - 1));
        // 在目标数组中需要划分的 桶 的个数， +1是为了消除d取整前的小数部分带来的误差（注意运算顺序）
        int bucketSize = (maxVal - minVal) / d + 1;
        //其实就是一个bucketSize个长度为2的一维数组，这个一维数组用来记录每个区间的的最大值和最小值，0下标存的是最小值，1下标存的是最大值
        int[][] bucket = new int[bucketSize][2];
        // 给二维数组赋初始值为-1，(-1, -1) 表示该桶是空的
        for (int i = 0; i < bucketSize; ++i) {
            Arrays.fill(bucket[i], -1);
        }

        // 遍历
        for (int i = 0; i < n; i++) {
            // 通过此运算用来判断当前元素属于哪个桶区间
            int idx = (nums[i] - minVal) / d;
            // 若区间为空，则此元素是第一次进来，则最大值和最小值都是它
            if (bucket[idx][0] == -1) {
                bucket[idx][0] = bucket[idx][1] = nums[i];
            } 
            // 若区间存在其他元素，则开始下面比较
            else {
                // 当前元素与此桶区间的最小值比较，若比最小值还小，就把最小值替换成当前元素值
                bucket[idx][0] = Math.min(bucket[idx][0], nums[i]);
                // 当前元素与此桶区间的最大值比较，若比最大值还大，就把最大值替换成当前元素值
                bucket[idx][1] = Math.max(bucket[idx][1], nums[i]);
            }
        }

        int ret = 0;    // 目标值
        int prev = -1;  // 上一个下标
        // 开始遍历每个桶列表
        for (int i = 0; i < bucketSize; i++) {
            // 判断当前桶区间是否为空，空则跳出
            if (bucket[i][0] == -1) {
                continue;
            }
            // 判断上一个下标是否为空，即是否第一次循环
            if (prev != -1) {
                /*
                * 计算上一个桶区间的最大值，与当前桶区间的的最小值的差
                * 然后与ret目标值比较，取最大值然后替换ret值
                */
                ret = Math.max(ret, bucket[i][0] - bucket[prev][1]);
            }
            prev = i;   // 上一个下标自增
        }
        return ret;
    }
}

11.27日

454.四数相加Ⅱ

class Solution {
    public int fourSumCount(int[] A, int[] B, int[] C, int[] D) {
        Map<Integer, Integer> map = new HashMap<>();
        int res = 0;
        int N = A.length;
        for(int i = 0; i < N; i ++) {
            for(int j = 0; j < N; j ++) {
                int sumAB = A[i] + B[j];
                if(map.containsKey(sumAB)) {
                    map.put(sumAB, map.get(sumAB)+1);
                }
                else {
                  map.put(sumAB, 1);  
                }
            }
        }
        for(int i = 0; i < N; i ++) {
            for(int j = 0; j < N; j ++) {
                int sumCD = -1 * (C[i] + D[j]);
                if(map.containsKey(sumCD)) {
                    res += map.get(sumCD);
                }
            }
        }
        return res;
    }
}

11.29日

976.三角形的最大周长

class Solution {
    public int largestPerimeter(int[] A) {
        if(A == null || A.length < 3) {
            return 0;
        }
        Arrays.sort(A);
        for(int i = A.length - 3; i >= 0; i --) {
            int a = A[i];
            int b = A[i+1];
            int c = A[i+2];
            if(c < a + b) {
                return a + b + c;
            }
        }
        return 0;
    }
}