LeetCode-第十个星期

二叉树的右视图

LeetCode199题，输出一个二叉树每一层中最右边的那个节点。

思路分析：

最开始肯定是从根节点的右子树开始遍历，需要考虑的问题是，当前层的右节点为空，这时候需要返回上一层接着遍历上一层的左子数，并且还需注意一层中只能输出一个节点。

 static List<Integer> res = new ArrayList<>();

    public static List<Integer> rightSideView(TreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }
        find(root, 0, 0);
        return res;
    }

    public static int find(TreeNode root, int cur, int len) {
        //如果当前层大于等于最大目前最大层,则说明可以该层的值还未取到
        if (cur >= len) {
            res.add(root.val);
            len = cur + 1;
        }
        if (root.right != null) {
            len = find(root.right, cur + 1, len);
        }
        if (root.left != null) {
            len = find(root.left, cur + 1, len);
        }
        return len;
    }

包含所有三种字符的子字符串数目

LeetCode1358题，给定一个字符串求同时出现a、b、c三个字符的最多的次数。

思路分析：
1.遍历字符串，统计a、b、c三个字符出现的次数。
2.当三者的次数都大于0时，说明满足条件的次数+1。
3.这时字符串之后的字符肯定也是满足的，直接将其加上即可。
4.再次遍历时，需要将第一个加进来的字符次数-1，重复步骤2、3，直到不满足条件，在接着遍历字符串。

        char[] data = s.toCharArray();
        int[] records = new int[3];
        int res = 0;
        int start = 0;
        for (int i = 0; i < data.length; i++) {
            records[data[i] - 'a']++;
            while (records[0] > 0 && records[1] > 0 && records[2] > 0) {
                //满足条件之后，开始计算符合的条件,并且踢出前面的元素
                res += data.length - i;
                records[data[start++] - 'a']--;
            }
        }
        return res;

最大数

LeetCode179题，给定一组非负整数的数组，重新排列它们的顺序使之组成一个最大的整数。

思路分析：

将数组按照自定义的顺序排列好，得到的结果就是算法的结果，这个自定义的算法指的是，两个字符串拼接成一个数字，谁在前谁在后，得出的大小不一致，循环比较这两个字符串中的字符，来判断得出的大小。

 public static String largestNumber(int[] nums) {
        String[] numstr = new String[nums.length];
        for(int i=0;i<nums.length;i++){
            numstr[i] = String.valueOf(nums[i]);
        }
        quickSort(numstr,0,nums.length-1);
        StringBuffer sb = new StringBuffer();
        if(numstr[0].charAt(0)=='0'){
            return "0";
        }
        for(String num:numstr){
            sb.append(num);
        }
        return sb.toString();
    }
    static int compare(String a,String b){
        int l1 = a.length();
        int l2 = b.length();
        int l = l1+l2;
        int i=0;
        for(;i<l;i++){
            char ac = a.charAt(i%l1);
            char bc = b.charAt(i%l2);
            if(ac==bc){
                continue;
            }
            return ac-bc;
        }
        return 0;
    }
    static void quickSort(String[] nums,int start,int end){
        if(start>=end){
            return;
        }
        int index = getIndex(nums,start,end);
        quickSort(nums,start,index-1);
        quickSort(nums,index+1,end);
    }
    //每次结束,low和high区间里，左边的数一定都大于右边的数
    static int getIndex(String[]nums,int low,int high){
        String tmp = nums[low];
        while(low<high){
            //找出第一个high下标大于low的值
            while(low<high&&compare(nums[high],tmp)<=0){
                high--;
            }
            //把值大的放在左边
            nums[low] = nums[high];
            //找出第一个low下标小于high的值
            while(low<high&&compare(nums[low],tmp)>=0){
                low++;
            }
            //把值小的放在右边
            nums[high] = nums[low];
        }
        nums[low] = tmp;
        return low;
    }