Leecode初级——数组篇3（加一、移动零、两数之和、有效数独）

/*加一:
给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储一个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
示例 1:
输入: [1,2,3]
输出: [1,2,4]
解释: 输入数组表示数字 123。

示例 2:
输入: [4,3,2,1]
输出: [4,3,2,2]
解释: 输入数组表示数字 4321。
* */
package com.primary.Aarray;

import java.util.ArrayList;
import java.util.List;


public class Solution7AddOne {
    /*方法1：妙计！！简便*/
    public int[] plusOne1(int[] digits) {
        int n = digits.length;
        for (int i = digits.length - 1; i >= 0; --i) {
            if (digits[i] < 9) {
                ++digits[i];
                return digits;//巧用return
            }
            digits[i] = 0;
        }
        int[] res = new int[n + 1];//巧用数组初始化后各元素为0
        res[0] = 1;
        return res;
    }

    /*方法2：转化成整数形式————思路简单*/
    public int[] plusOne2(int[] digits){
        int len=digits.length;
        int power;
        int number=0;
        int tmpResult;
        int remainder;
        int divisor;
        String str;
        List<Integer>list=new ArrayList<>();
        for (int i=0;i<len;++i){
            power=len-i-1;
            number+=(digits[i]*Math.pow(10,power));
        }
        ++number;
        str=Integer.toString(number);//计算整数位数
        len=str.length();
        remainder=number;
        for (int i=0;i<len;++i){
            divisor= (int) Math.pow(10,(len-i-1));
            tmpResult=remainder/divisor;
            remainder%=divisor;
            list.add(tmpResult);
        }
        System.out.print("Result:");
        /*int[] result = new int[list.size()];
        int counter=0;
        for (int n:list
             ) {
            result[counter]=n;
            System.out.print(n+" ");
        }
        return result;*/
        Solution6 solution6=new Solution6();
        return solution6.Result(list);
    }
    //方法三：借助进位判断
    public int[] plusOne3(int[] digits) {
        if (digits.length == 0) return digits;
        int carry = 1, n = digits.length;//carry判断进位与否
        for (int i = digits.length - 1; i >= 0; --i) {
            if (carry == 0) return digits;
            int sum = digits[i] + carry;
            digits[i] = sum % 10;
            carry = sum / 10;
        }
        int[] res = new int[n + 1];
        res[0] = 1;
        return carry == 0 ? digits : res;
    }

    public static void main(String[]args){
        int[]digits1={9,9};
        int[]digits2={2,9,9};
        int[]digits3={9,9,9,9};
        int[]digits4={4,3,2,1};
        Solution7AddOne solution7AddOne=new Solution7AddOne();
        solution7AddOne.plusOne2(digits1);
        solution7AddOne.plusOne2(digits2);
        solution7AddOne.plusOne1(digits3);
        solution7AddOne.plusOne1(digits4);
        solution7AddOne.plusOne3(digits1);
        solution7AddOne.plusOne3(digits2);
        solution7AddOne.plusOne3(digits4);
    }
}

====================================================================================

/* 8.移动零
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
示例:
输入: [0,1,0,3,12]
输出: [1,3,12,0,0]
说明:
必须在原数组上操作，不能拷贝额外的数组。
尽量减少操作次数。
* */
package com.primary.Aarray;

import org.omg.PortableInterceptor.SYSTEM_EXCEPTION;

import java.util.Arrays;

public class Solution8MoveZeroes {
    /*常规方法1：*/
    public void moveZeroes1(int[] nums) {
//        Arrays.sort(nums);
        int counter=0;//计数器：计算0的个数
        for (int i=0;i<nums.length;++i){
            if (nums[i]==0)
                ++counter;
        }
        for (int i=counter;i<nums.length;++i){//将非0数字往前移动counter位
            nums[i-counter]=nums[i];
        }
        for (int i=nums.length-counter;i<nums.length;++i){//设置最后counter个元素大小为0
            nums[i]=0;
        }
        System.out.print("Result:");
        for (int i=0;i<nums.length;++i){
            System.out.print(nums[i]+" ");
        }
    }

    /*方法二：找一个counter调整数组*/
    public void moveZeroes2(int[] nums) {
        if(nums == null || nums.length == 0){
            return;
        }
        //记录非o元素开始位置
        int k = 0;//原地计数
        for(int i=0;i<nums.length;i++){
            if(nums[i] != 0) {
                nums[k++] = nums[i];
            }
        }
        while(k < nums.length) {
            nums[k] = 0;
            k++;
        }
    }




    public static void main(String[]args){
//        long startTime=System.currentTimeMillis();
        long startTime=System.nanoTime();
        int[]nums={0,1,0,13,12};
        Solution8MoveZeroes solution8MoveZeroes=new Solution8MoveZeroes();
        solution8MoveZeroes.moveZeroes2(nums);
//        long endTime=System.currentTimeMillis();
        long endTime=System.nanoTime();
        System.out.println("\n程序运行时间："+(endTime-startTime)+"ns");
    }
}

 

===========================================================================

/*两数之和:
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]*/
package com.primary.Aarray;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class Solution9TwoSum {
    /*1.常规方法：*/
    public int[] twoSum1(int[] nums, int target) {
        List<Integer>list=new ArrayList<>();
        int sum=0;
        for (int i=0;i<nums.length;++i){
            for (int j=i+1;j<nums.length;++j){
                sum=nums[i]+nums[j];
                if (sum==target){
                    list.add(i);
                    list.add(j);
                }
            }
        }
        System.out.print("Result1:");
        Solution6 solution6=new Solution6();
        return solution6.Result(list);
    }

    /*方法2：O(n)借助HashMap*/
    public  int[] twoSum2(int[]nums,int target){
        HashMap<Integer, Integer> m = new HashMap<Integer, Integer>();
        int[] res = new int[2];
        for (int i = 0; i < nums.length; ++i) {
            if (m.containsKey(target - nums[i])) {
                res[0] = i;
                res[1] = m.get(target - nums[i]);
                break;
            }
            m.put(nums[i], i);
        }
        return res;
    }

    public static void main(String[] args){
        long startTime=System.nanoTime();
        Solution9TwoSum solution9TwoSum=new Solution9TwoSum();
        int []nums={2,7,11,15};
        int target=9;
        solution9TwoSum.twoSum2(nums,target);
        long endTime=System.nanoTime();
        System.out.println("程序运行时间:"+(endTime-startTime)+"ns");
    }
}

===========================================================================================

/* 有效的数独
判断一个 9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。
数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。
说明:
一个有效的数独（部分已被填充）不一定是可解的。
只需要根据以上规则，验证已经填入的数字是否有效即可。
给定数独序列只包含数字 1-9 和字符 '.' 。
给定数独永远是 9x9 形式的。
* */
/*
* 输入:
[
  ["8","3",".",".","7",".",".",".","."],
  ["6",".",".","1","9","5",".",".","."],
  [".","9","8",".",".",".",".","6","."],
  ["8",".",".",".","6",".",".",".","3"],
  ["4",".",".","8",".","3",".",".","1"],
  ["7",".",".",".","2",".",".",".","6"],
  [".","6",".",".",".",".","2","8","."],
  [".",".",".","4","1","9",".",".","5"],
  [".",".",".",".","8",".",".","7","9"]
]
输出: false
*/
package com.primary.Aarray;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public class Solution10IsValidSudoku {
    public boolean isValidSudoku(char[][] board) {
        int lenRow=board.length;
        int lenCol=board[0].length;
        for (int i=0;i<lenRow;++i){
            Set<Character>setRow=new HashSet<>();
            Set<Character>setCol=new HashSet<>();
            Set<Character>setCell=new HashSet<>();
            for (int j=0;j<lenCol;++j){
                if (board[i][j]!='.'&&!setRow.add(board[i][j]))
                    return false;
                if (board[j][i]!='.'&&!setCol.add(board[j][i]))
                    return false;
                int x=3*(i/3)+j/3;//神仙！！
                int y=3*(i%3)+j%3;
                if (board[x][y]!='.'&&!setCell.add(board[x][y]))
                    return false;
            }
        }
        return true;
    }

    public static void main(String[] args){
        Solution10IsValidSudoku solution10IsValidSudoku=new Solution10IsValidSudoku();
        char[][]board={
                {'5','3','.','.','7','.','.','.','.'},
                {'6','.','.','1','9','5','.','.','.'},
                {'.','9','8','.','.','.','.','6','.'},
                {'8','.','.','.','6','.','.','.','3'},
                {'4','.','.','8','.','3','.','.','1'},
                {'7','.','.','.','2','.','.','.','6'},
                {'.','6','.','.','.','.','2','8','.'},
                {'.','.','.','4','1','9','.','.','5'},
                {'.','.','.','.','8','.','.','7','9'}
        };
        boolean result=solution10IsValidSudoku.isValidSudoku(board);
        System.out.println("Result:"+result);
    }



}