力扣LeetCode算法打卡学习第5天

七、加一

给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数0之外，这个整数不会以零开头。

方法：我的算法，由于我没有看到官方答案，这里便只给我的代码分享。

class Solution {
    public int[] plusOne(int[] digits) {
        int length=digits.length;
        //最后一位加一
        digits[length-1]++;
        for(int i=length-1;i>0;i--){
                digits[i-1]=digits[i-1]+digits[i]/10;
                digits[i]=digits[i]%10;
        }
        //单独看最高位，如果最高位>9了，那么就得多一位
        if(digits[0]/10 >0){
            int[] willback=new int[length+1];
            willback[0]=digits[0]/10;
            willback[1]=digits[0]%10;
            for(int i=2;i<length+1;i++){
                willback[i]=digits[i-1];
            }
            return willback;
        }
        else{
            return digits;
        }
       
    }
}

八、移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

方法一：我的代码，但是超出时间限制了。

class Solution {
    public void moveZeroes(int[] nums) {
        int index=nums.length-1;
        for(int i=nums.length-1;i>=0;i--){
            if(nums[i]==0){
                System.out.println(i);
                for(int j=i;j<index;j++){
                    nums[j]=nums[j+1];
                    nums[j+1]=0;
                    System.out.println(j);
                }
                index--;
            }
        }

    }
}

方法二：双指针

class Solution {
    public void moveZeroes(int[] nums) {
        //左指针左边全是非零，左指针与右指针的之间全为0
        int length=nums.length;
        int index1=0;
        int index2=0;
        while(index2<length){
            if(nums[index2]!=0){
                int temp=nums[index2];
                nums[index2]=nums[index1];
                nums[index1]=temp;
                index1++;
            }
            index2++;
        }
    }
}

方法三：评论区看别人的

class Solution {
    public void moveZeroes(int[] nums) {
        int index=0;
        for(int i=0;i<nums.length;i++){
            if(nums[i]!=0){
                nums[index]=nums[i];
                index++;
            }
        }
        for(int j=index;j<nums.length;j++){
            nums[j]=0;
        }
    }
}

九：两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
你可以按任意顺序返回答案。

方法1：我的，暴力枚举，但是还是两个for，感觉不大好

class Solution {
    public int[] twoSum(int[] nums, int target) {
        boolean back=false;
        int[] willback=new int[2];
        for(int i=0;i<nums.length-1;i++){
            for(int j=i+1;j<nums.length;j++){
                if(nums[i]+nums[j]==target){
                    willback[0]=i;
                    willback[1]=j;
                    back=true;
                    break;
            }
            }
            if(back){
                break;
            }
        }
        return willback;
    }
}

方法2：官方给的哈希表算法

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; ++i) {
            if (hashtable.containsKey(target - nums[i])) {
                return new int[]{hashtable.get(target - nums[i]), i};
            }
            hashtable.put(nums[i], i);
        }
        return new int[0];
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/two-sum/solution/liang-shu-zhi-he-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

十、有效的数独

判断一个 9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。

数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。

方法一：我使用哈希表统计一行，一列，九宫格的出现次数

class Solution {
    public boolean isValidSudoku(char[][] board) {
        //先判断直线的
        for(int i=0;i<9;i++){
            Map<String,Integer> map=new HashMap<String,Integer>();//横着
            Map<String,Integer> map1=new HashMap<String,Integer>();//竖着
            for(int j=0;j<9;j++){
                Map<String,Integer> map2=new HashMap<String,Integer>();//横着
                if(board[i][j] !='.'){
                    int count = map.getOrDefault(board[i][j]+"", 0) + 1;
                    map.put(board[i][j]+"", count);
                    if(count>1){
                        return false;
                    }
                }
                if(board[j][i]!='.'){
                    int count1 = map1.getOrDefault(board[j][i]+"", 0) + 1;
                    map1.put(board[j][i]+"", count1);
                    if(count1>1){
                        return false;
                    }
                }
                //九宫格
                if(i%3==0 && j%3==0){
                    for(int m=0;m<=2;m++){
                        for(int k=0;k<=2;k++){
                            if(board[i+m][j+k]!='.'){
                                int count = map2.getOrDefault(board[i+m][j+k]+"", 0) + 1;
                                System.out.println(count);
                                map2.put(board[i+m][j+k]+"", count);
                                if(count>1){
                                    return false;
                                }
                    
                            }
                        }
                        
                    }
                    

                }
            }

        }
        return true;

    }
}

二、官方的

class Solution {
  public boolean isValidSudoku(char[][] board) {
    // init data
    HashMap<Integer, Integer> [] rows = new HashMap[9];
    HashMap<Integer, Integer> [] columns = new HashMap[9];
    HashMap<Integer, Integer> [] boxes = new HashMap[9];
    for (int i = 0; i < 9; i++) {
      rows[i] = new HashMap<Integer, Integer>();
      columns[i] = new HashMap<Integer, Integer>();
      boxes[i] = new HashMap<Integer, Integer>();
    }

    // validate a board
    for (int i = 0; i < 9; i++) {
      for (int j = 0; j < 9; j++) {
        char num = board[i][j];
        if (num != '.') {
          int n = (int)num;
          int box_index = (i / 3 ) * 3 + j / 3;

          // keep the current cell value
          rows[i].put(n, rows[i].getOrDefault(n, 0) + 1);
          columns[j].put(n, columns[j].getOrDefault(n, 0) + 1);
          boxes[box_index].put(n, boxes[box_index].getOrDefault(n, 0) + 1);

          // check if this value has been already seen before
          if (rows[i].get(n) > 1 || columns[j].get(n) > 1 || boxes[box_index].get(n) > 1)
            return false;
        }
      }
    }

    return true;
  }
}

作者：LeetCode
链接：https://leetcode-cn.com/problems/valid-sudoku/solution/you-xiao-de-shu-du-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

十一、给定一个 n × n 的二维矩阵表示一个图像

将图像顺时针旋转 90 度。
说明：
你必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要使用另一个矩阵来旋转图像。

方法一：我的方法，真的想了很久的规律。

"00>03 03>33 33>30 30>00";
“01>13 13>32 32>20 20>01”;
“02>23 23>31 31>10 10>02”;
“11>12 12>22 22>21 21>11”;

就是这样的一个规律。

class Solution {
    public void rotate(int[][] matrix) {
        int length1=matrix[0].length;
        int alltime=length1/2;
        if(length1%2 !=0){
            alltime++;
        }
        int left=0;
        int right=0;
        int left1=0;
        int right1=0;
        int bianyuan=length1;
        int time=length1*length1/4;
        for(int xx=0;xx<alltime;xx++){
            bianyuan=length1-xx*2;
            System.out.println(bianyuan);
            for(int i=xx;i<bianyuan-1+xx;i++){
            left=xx;
            right=i;
            int temp=matrix[xx][i];
            for(int j=0;j<4;j++){
                System.out.println(temp);
                left1=right;
                right1=length1-left-1;
                int temp1=matrix[left1][right1];
                matrix[left1][right1]=temp;
                temp=temp1;
                left=left1;
                right=right1;  
            }
        }
        }
    }
}