LeetCode初级算法刷题记录

1、删除排序数组中的重复项。给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

class Solution {
    public int removeDuplicates(int[] nums) {
        if(nums != null && nums.length == 0){
            return 0;
        }
        int i = 0;
        for(int j = 1; j < nums.length; j++){
            System.out.print(nums[i] + " ");
            if(nums[j] != nums[i]){
                i++;
                nums[i] = nums[j];
            }
        }
        System.out.println("数组长度：" + (i+1));
        return i+1;
    }
}

2、旋转数组。给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。

class Solution {
    public void rotate(int[] nums, int k) {
        if (nums == null || k == 0 || k == nums.length){
            return;
        }
        int t = 0;
        while(k > 0){
            for(int i = nums.length-1; i >= 1; i--){
                t = nums[i-1];
                nums[i-1] = nums[i];
                nums[i] = t;
                }
                k--;
        }
    }
}

3、存在重复元素。给定一个整数数组，判断是否存在重复元素。如果任意一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。

class Solution {
    public boolean containsDuplicate(int[] nums) {
        Arrays.sort(nums);
        for(int i = 1; i < nums.length; i++){
            if(nums[i-1] == nums[i]){
                return true;
            }
        }
    return false;
    }
}

4、只出现一次的数字。给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

class Solution {
    public int singleNumber(int[] nums) {
        int ans = 0;
        for(int i = 0; i < nums.length; i++){
            ans = ans ^ nums[i];
        }
        return ans;
    }
}

5、两个数组的交集。给定两个数组，编写一个函数来计算它们的交集。

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        if(nums1.length > nums2.length){
            return intersect(nums2,nums1);
        }
        HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
        for(int num :nums1){
            int count = map.getOrDefault(num , 0) + 1;
            map.put(num , count);
        }
        int[] insertarray = new int[nums1.length];
        int index = 0;
        for(int num : nums2){
            int count = map.getOrDefault(num , 0);
            if(count > 0){
                insertarray[index] = num;
                index++;
                count--;
                if(count > 0){
                    map.put(num,count);
                }
                else{
                    map.remove(num);
                }
            }
        }
        return Arrays.copyOfRange(insertarray, 0, index);
    }
}

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

class Solution {
    public int[] plusOne(int[] digits) {
        for(int i = digits.length-1; i >= 0; i--){
            digits[i]++;
            digits[i] = digits[i] % 10;
            if(digits[i] != 0 ){
                return digits;
            }
        }
        digits = new int[digits.length + 1];
        digits[0] = 1;
        return digits;
    }
}

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

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

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

class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
        for(int i = 0; i < nums.length; i++){
            if(map.containsKey(target-nums[i])){
                return new int[] {i,map.get(target-nums[i])};
            }
            map.put(nums[i],i);
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}

9、旋转图像。给定一个 n × n 的二维矩阵表示一个图像。将图像顺时针旋转 90 度。

class Solution {
    public void rotate(int[][] matrix) {
        if (matrix == null || matrix.length == 0){
            return;
        }
        int rowstart = 0;
        int colstart = 0;
        int rowend = matrix.length - 1;
        int colend = matrix[0].length - 1;

        while(rowstart < rowend){
            rot(matrix,rowstart,colstart,rowend,colend);
            rowstart++;
            colstart++;
            rowend--;
            colend--;
        }
    }

    public void rot(int[][] m,int rowstart,int colstart,int rowend,int colend){
        int time = rowend - rowstart;
        for(int i = 0; i < time; i++){
            int t = m[rowstart][colstart + i];
            m[rowstart][colstart + i] = m[rowend - i][colstart];
            m[rowend - i][colstart] = m[rowend][colend - i];
            m[rowend][colend - i] = m[rowstart + i][colend];
            m[rowstart + i][colend] = t;
        }
    }
}