一.867. 转置矩阵----2021/1/11

class Solution {
    public int[][] transpose(int[][] A) {
        int[][] B = new int[A[0].length][A.length];
        for(int i = 0;i<A.length;i++){
            for(int j = 0;j<A[0].length;j++){
                B[j][i] = A[i][j];
            }
        }
        return B;
    }
}

注：这就不用说了，看代码吧。

二.面试题 17.10. 主要元素----2021/1/11

class Solution {
    public int majorityElement(int[] nums) {
        Map<Integer,Integer> map = new HashMap<Integer,Integer>();
        for(int i=0;i<nums.length;i++){
            if(!map.containsKey(nums[i])){
                map.put(nums[i],1);
            }else{
                map.put(nums[i],map.get(nums[i])+1);
            }
        }
        int max = Integer.MIN_VALUE;
        int maxvalue = Integer.MIN_VALUE;
        Set<Integer> keySet = map.keySet(); 
        for(Integer value:keySet){
            if(map.get(value)>max){
                max = map.get(value);
                maxvalue = value;
            }
        }
        return max<=nums.length/2?-1:maxvalue;
    }
}

还有一种方法，就是利用 Arrays.sort(a);对数组排序，那么如果由超过一半则必定连着超过一半的数量，这时候可以双指针！以后在补！

三.977. 有序数组的平方----2021/1/11

class Solution {
    public int[] sortedSquares(int[] nums) {
        int[]newnums = new int[nums.length];
        for(int i = 0;i<nums.length;i++){
            newnums[i] = Math.abs(nums[i]);
        }
        Arrays.sort(newnums);
        for(int i=0;i<nums.length;i++){
            newnums[i] = (int)Math.pow(newnums[i],2);
        }
        return newnums;
    }
}

四.628. 三个数的最大乘积----2021/1/12

class Solution {
    public int maximumProduct(int[] nums) {
        Arrays.sort(nums);
        int length = nums.length;
        int max = nums[length-1] * nums[length-2] * nums[length-3];
        max = max>nums[0] * nums[1] *nums[length-1]?max:nums[0]*nums[1]*nums[length-1];
        return max;
    }
}

思路： 排序后，最大值应该为最后三个数或者前两个数和最后一个数！可以自己举几个例子比较一下。

五.1550.存在连续三个奇数的数组----2021/1/12

class Solution {
    public boolean threeConsecutiveOdds(int[] arr) {
        int length = arr.length;
        int index = 0;
        for(int i =0;i<length;i++){
            if(index == 3){
                return true;
            }
            if(arr[i]%2!=0){
                index++;
            }else{
                index = 0;
            }
        }
        if(index==3)
            return true;
        else    
            return false;
    }
}

思路： for循环，统计奇数的个数，当等于3个，直接返回，否则重新计数。

六.219.存在重复元素 II----2021/1/12

class Solution {
    public boolean containsNearbyDuplicate(int[] nums, int k) {
        int length = nums.length;
        for(int i =0;i<length;i++){
            for(int j=i+1;j <= k+i && j<length;j++){
                if(nums[i] == nums[j])
                    return true;
            }
        }
        return false;
    }
}

思路： 和上面那道题差不多，同理for循环。

七.228. 汇总区间—2021/1/12

class Solution {
    public List<String> summaryRanges(int[] nums) {
        List<String> list = new ArrayList<String>();
        int length = nums.length;
        if(length == 0){
            return list;
        }
        int first = nums[0];
        int end = nums[0];
        for(int i=1;i<length;i++){
            int cur = nums[i];
            if(cur==end+1)
                end = cur;
            else{
                if(first == end){
                    list.add(String.valueOf(first));
                }else{
                    list.add( first + "->" + end);
                }
               
                first = end = nums[i];
            }
        }
        if(first == end){
            list.add(String.valueOf(first));
        }else{
            list.add( first + "->" + end);
        }
        return list;
    }
}

思路： for循环或者理解为双指针，前指针指向头部，后指针指向尾部，当相邻数一个一个的增加时，后指针移动，当出现跳跃时，前后指针同时移动，注意数组为空以及最后情况的重新判断！

八.605. 种花问题—2021/1/12

class Solution {
    public boolean canPlaceFlowers(int[] flowerbed, int n) {
        int length = flowerbed.length;
        if(n==0)
            return true;
        //只有一个数时
        if(length==1&&flowerbed[0] == 0){
            return true;
        }else if(length==1&&flowerbed[0]==1){
            return false;
        }
        //计算开头
        if(flowerbed[0]==0 && flowerbed[1]==0){
            flowerbed[0]=1;
            n--;
        }
        //计算中间
        for(int i=1;i<length-1;i++){
            if(flowerbed[i-1]==0 && flowerbed[i+1]==0 && flowerbed[i]==0){
                flowerbed[i] = 1;
                n--;
            }
        }
        //计算末尾
         if(flowerbed[length-1]==0 && flowerbed[length-2]==0){
            flowerbed[length-1]=1;
            n--;
        }
        return n>0?false:true;
    }
}

思路： 同理for循环，单独处理开头和末尾，这里为什么可以从头到尾直接走一遍，主要是最优结果是越靠前越好，或者从尾到头越靠后越好。

九.832. 翻转图像—2021/1/12

class Solution {
    public int[][] flipAndInvertImage(int[][] A) {
        int row = A.length;
        int col = A[0].length;
        for(int i=0;i<row;i++){
            for(int j =0;j<col/2;j++){
                int temp = A[i][j];
                A[i][j] = A[i][col-j-1]==0?1:0;
                A[i][col-j-1] = temp==0?1:0;
            }
            if(col%2!=0){
                A[i][col/2] =   A[i][col/2]==0?1:0;
            }
        }
        return A;
    }
}

思路： 注意反转图片的时候，当列为奇数的时候要把中间的那一位单独反转。

十.1672. 最富有客户的资产总量—2021/1/12

class Solution {
    public int maximumWealth(int[][] accounts) {
        int row = accounts.length;
        int col = accounts[0].length;
        int max = Integer.MIN_VALUE;
        for(int i=0;i<row;i++){
            int sum = 0;
            for(int j=0;j<col;j++){
                sum+=accounts[i][j];
                max = sum>max?sum:max; 
            }
        }
        return max;
    }
}

注： 统计每一行的最大值！！！！

十一.88. 合并两个有序数组----2021/1/13

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int length = m + n;
        int pointNum1 = m-1;
        int pointNum2 = n-1;
        int p = m + n -1;
        while(p>=0){
            if(pointNum1<0){
                nums1[p--] = nums2[pointNum2--];
                continue;
            }else if(pointNum2<0){
                nums1[p--] = nums1[pointNum1--];
                continue;
            }
            if(nums1[pointNum1]>=nums2[pointNum2]){
                nums1[p--] = nums1[pointNum1];
                pointNum1--;
            }
            else{
                nums1[p--] = nums2[pointNum2];
                pointNum2--;
            }
        }
    }
}

思路： 因为最后要比较的是num1数组（不需要开辟新的空间），所以这里需要从后往前走，这里结合双指针，谁大就保存谁的值，然后指针往前移，然后需要判断的是其中一个已经到头了，则剩下的值直接用另一个赋值即可（即包含continue的语句）。

十二.1534. 统计好三元组----2021/1/13

class Solution {
    public int countGoodTriplets(int[] arr, int a, int b, int c) {
        int count = 0;
        for(int i=0;i<arr.length-2;i++){
            for(int j = i+1;j<arr.length-1;j++){
                for(int k =j+1 ;k<arr.length;k++){
                    if(Math.abs(arr[i]-arr[j])<=a && Math.abs(arr[j]-arr[k])<=b && Math.abs(arr[i]-arr[k])<=c){
                        count++;
                    }
                }
            }
        }
        return count;
        
    }
}

思路： 三层for循环暴力解决！！！