LeetCode数组入门题目

荀乐
204 阅读2分钟

Leetcode数组

这是我参与新手入门的第三篇文章

1. 两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

解题思路

1.暴力法

对两两数字和加起来进行比较

复杂度：
  • 时间复杂度：O(n^2)，n为数组长度
  • 空间复杂度：O(1)

2.哈希表

对于数组中的每一个x要找到target - x时间复杂度是O(n^2)，如果使用哈希表将数组中的每一个数保存下来，寻找target - x的时间复杂度就可以降到O(1)

复杂度：
  • 时间复杂度：O(n)，n为数组长度
  • 空间复杂度：O(n)，n为数组长度

AC代码

  1. 暴力法

    class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] ret = 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) {
                    ret[0] = i;
                    ret[1] = j;
                }
            }
        }
        return ret;
    }
}

  2. 哈希表

    class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        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);
        }
        return new int[0];
    }
}

88. 合并两个有序数组

给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中*，*使 nums1 成为一个有序数组。

初始化 nums1 和 nums2 的元素数量分别为 m 和 n。你可以假设 nums1 的空间大小等于 m + n，这样它就有足够的空间保存来自 nums2 的元素。

示例 1：

输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]

解题思路

1.先合并，再排序

将nums2中的元素加入nums1，再对nums1排序

复杂度：

  • 时间复杂度：O( (m+n) log(m+n) )，快排的时间复杂度
  • 空间复杂度：O( log(m+n) )，快排的空间复杂度

2.双指针法

方法1没有用到题目中nums1和nums2有序的性质，可以用两个指针i、j分别指向nums1、nums2的下标，并根据下标进行比较，但是需要一个新数组保存结果

复杂度：

  • 时间复杂度：O(m + n)
  • 空间复杂度：O(m + n)

3.逆向双指针

方法2中新建了一个sorted数组保存排序结果，但是题目中nums1中已经预留了空间，所以可以从大的开始排序，并放入nums1的空闲区

复杂度：

  • 时间复杂度：O(m + n)
  • 空间复杂度：O(1)

AC代码

  1. 先合并，再排序

    class solution{
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        for (int i = 0; i < n; i++) {
            nums1[m + i] = nums2[i];
        }
        Arrays.sort(nums1);
    }
}

  2. 双指针

    class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int i = 0;
        int j = 0;
        int[] sorted = new int[nums1.length];

        while (i < m && j < n) {
            if (nums1[i] < nums2[j]) {
                sorted[i + j] = nums1[i++];
            } else {
                sorted[i + j] = nums2[j++];
            }
        }
        
        if (i < m) {
            while (i < m) {
                sorted[i + j] = nums1[i++];
            }
        } else {
            while (j < n) {
                sorted[i + j] = nums2[j++];
            }
        }

        for (int k = 0; k < m + n; k++) {
            nums1[k] = sorted[k];
        }
    }
}

  3. 逆向双指针

    class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int i = m - 1;
        int j = n - 1;

        while (i >= 0 && j >= 0) {
            if (nums1[i] > nums2[j]) {
                nums1[i + j + 1] = nums1[i--];
            } else {
                nums1[i + j + 1] = nums2[j--];
            }
        }

        if (i > 0) {
            while (i >= 0) {
                nums1[i + j + 1] = nums1[i--];
            }
        } else {
            while (j >= 0) {
                nums1[i + j + 1] = nums2[j--];
            }
        }
    }
}

53. 最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

解题思路

假设dp[i]是以nums[i]结尾的最大子序列和，则 最大子序列和max就是dp数组中的最大值

AC代码

public int maxSubArray(int[] nums) {
	//dp[i]表示以nums[i]结尾的最大子序列和
	int[] dp = new int[nums.length];
	dp[0] = nums[0];
	int max = nums[0];

	for (int i = 1; i < nums.length; i++) {
		//以 nums[i] 结尾的最大子序列和 == 以 nums[i-1] 结尾的最大子序列和 + nums[i] 或者是 nums[i]
		dp[i] = Math.max(dp[i-1] + nums[i], nums[i]);
		max = Math.max(dp[i], max);
	}
	return max;
}

26. 删除有序数组中的重复项

给你一个有序数组 nums ，请你** 原地** 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。

示例 1：

输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

解题思路

1.暴力法（自己取的）

对于nums[i]，找到第一个比nums[i]大的数放在nums[i+1]的位置，直到找不到比nums[i]还要大的数。最后返回i+1即数组的新长度

复杂度：

  • 时间复杂度：O(n^2)
  • 空间复杂度：O(1)

2.双指针

如果存在nums[i] = nums[j]，则对于 i≤k≤ji \leq k \leq j 有nums[i] = nums[k] = nums[j]，即相等的元素下标一定连续。通过维护slow和fast快慢指针，可以将空间复杂度降低到O(n)

复杂度：

  • 时间复杂度：O(n)
  • 空间复杂度：O(1)

AC代码

  1. 暴力法

    class Solution {
    public int removeDuplicates(int[] nums) {
        int len = nums.length;
        for (int i = 0; i < len - 1; i++) {
            for (int j = i + 1; j < len; j++) {
                if (nums[j] > nums[i]) {
                    nums[i + 1] = nums[j];
                    break;
                }
                if (j == len - 1) {
                    return i+1;
                }
            }
        }
        return len;
    }
}

  2. 双指针

    class Solution {
    public int removeDuplicates(int[] nums) {
        int slow = 0;
        int fast = slow + 1;
        while (fast < nums.length) {
            if (nums[slow] == nums[fast]) {
                do {
                    fast++;
                } while (fast < nums.length && nums[slow] == nums[fast]);
                if (fast == nums.length) {
                    break;
                }
                nums[slow+1] = nums[fast];
                slow++;
            } else {
                slow++;
                fast++;
            }
        }
        return slow + 1;
    }
}

  3. 双指针简易写法

    class Solution {
    public int removeDuplicates(int[] nums) {
        int i = 0;
        for (int j = 1; j < nums.length; j++) {
            if (nums[i] != nums[j]) {
                nums[++i] = nums[j];
            }
        }
        return ++i;
    }
}
avatar
文章
阅读
粉丝