【LeetCode】初级算法：数组

题目可以在LeetCode查看

1. 从排序数组中删除重复项

用时：11ms

class Solution {
    public int removeDuplicates(int[] nums) {
        int length=nums.length;
        int count=0,remove=0;
        // 如果数组长度为1，直接返回
        if(length==1){
            ++count;
        }else{
            // 直接将数组后面不同的元素移动到前面
            for(int i=1;i

2. 买卖股票的最佳时机 II

用时：1ms

class Solution {
    public int maxProfit(int[] prices) {
        int profit=0;
        boolean buy=false;
        for(int i=0;iprices[i+1]){
                    profit+=prices[i];
                    buy=false;
                }
            }
        }
        // 如果已经买了，倒数第二天没有卖，则最后一天直接卖
        if(buy){
            profit+=prices[prices.length-1];
        }
        return profit;
    }
}

3. 旋转数组

用时：1ms

class Solution {
    public void rotate(int[] nums, int k) {
        // 方法1用时：128ms
        // int len=nums.length;
        // int temp;
        // // 移动轮次
        // for(int i=0;i0;j--){
        //         nums[j]=nums[j-1];
        //     }
        //     nums[0]=temp;
        // }
     
        
        int len=nums.length;
        k%=len;
        // 先旋转整个数组，再分别旋转两个子数组
        reverse(nums,0,len-1);
        reverse(nums,0,k-1);
        reverse(nums,k,len-1);
    }
    
    private void reverse(int[] nums,int start,int end){
        int temp;
        while(start

4. 存在重复

用时：5ms

class Solution {
    public boolean containsDuplicate(int[] nums) {
        int len=nums.length;
        if(len>1){
            // 从排序数组中找到两个相同的元素
            Arrays.sort(nums);
            for(int i=0;i

5. 只出现一次的数字

用时：7ms

class Solution {
    public int singleNumber(int[] nums) {
        int len=nums.length;
        int i=0;
        if(len>1){
            // 从排序数组中直接找到一组不同的元素
            Arrays.sort(nums);
            for(i=0;i

6. 两个数组的交集 II

用时：4ms

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        int len1=nums1.length,len2=nums2.length;
        int lenMin=Math.min(len1,len2);
        int[] intersection=new int[lenMin];
        int count=0;
        if(lenMin>0){
            // 从两个排序数组中找到相同数的位置
            Arrays.sort(nums1);
            Arrays.sort(nums2);
            int i=0,j=0;
            while(inums2[j]){
                    ++j;
                }else{
                    intersection[count++]=nums1[i];
                    ++i;
                    ++j;
                }
            }
        }
        return Arrays.copyOfRange(intersection,0,count);
    }
}

7. 加一

用时：0ms

class Solution {
    public int[] plusOne(int[] digits) {
        int len=digits.length;
        int[] newDigits=new int[len+1];
        newDigits[0]=0;
        
        // 从第一位开始加上进位
        int sum,carry=1;
        for(int i=len-1;i>=0;--i){
            sum=digits[i]+carry;
            if(sum<10){
                newDigits[i+1]=sum;
                carry=0;
            }else{
                newDigits[i+1]=sum%10;
                carry=1;
            }
        }
        newDigits[0]+=carry;

        if(newDigits[0]==0){
            return Arrays.copyOfRange(newDigits,1,len+1);
        }else{
            return newDigits;
        }
    }
}

8. 移动零

用时：2ms

class Solution {
    public void moveZeroes(int[] nums) {
        int len=nums.length;
        int count=0;
        // 先将所有不为0的数前移
        // 并统计不为0的数的数量
        for(int i=0;i

9. 两数之和

用时：8ms

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int len=nums.length;
        int[] plus=new int[2];
        int temp;
        // 用HashMap记录两个加数中的一个
        // 然后用和去减当前数，看HashMap中是否存在差值
        HashMap minus=new HashMap<>();
        for(int i=0;i

10. 有效的数独

用时：36ms

class Solution {
    public boolean isValidSudoku(char[][] board) {
        Set rowDigits=new HashSet<>();
        Set colDigits=new HashSet<>();
        Character dot=new Character('.');
        
        // 判断行和列
        int i,j,m,n;
        for(i=0;i<9;++i){
            for(j=0;j<9;++j){
                if(!dot.equals(board[i][j])&&!rowDigits.add(board[i][j])){
                    return false;
                }
                if(!dot.equals(board[j][i])&&!colDigits.add(board[j][i])){
                    return false;
                }
            }
            rowDigits.clear();
            colDigits.clear();
        }
        
        // 判断九宫格
        for(i=0;i<9;i+=3){ // 行
            for(j=0;j<9;j+=3){ // 列
                for(m=0;m<3;++m){ // 九宫格
                    for(n=0;n<3;++n){
                        if(!dot.equals(board[i+m][j+n])&&!rowDigits.add(board[i+m][j+n])){
                            return false;
                        }
                    }
                }
                rowDigits.clear();
            }
        }

        return true;
    }
}

11. 旋转图像

用时：2ms

class Solution {
    public void rotate(int[][] matrix) {
        int len=matrix.length;
        int n=len-1;
        int rounds=(len+1)/2;
        int move=len;
        int [][] corner=new int[4][2];
        int temp;
        
        for(int i=0;i