LeetCode-数组

最新推荐文章于 2022-02-23 20:01:34 发布

没饭吃！

最新推荐文章于 2022-02-23 20:01:34 发布

阅读量1w

点赞数

分类专栏： LeetCode

本文链接：https://blog.csdn.net/qq_32157579/article/details/102675939

版权

LeetCode 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

LeetCode-数组

#1.两数之和
#4.寻找两个有序数组的中位数
#11.盛最多水的容器
#26.删除排序数组中的重复项
#27.移除元素
#80.删除排序数组中的重复项 II
#88.合并两个有序数组
#118.杨辉三角
#119.杨辉三角 II
#283.移动零

#1.两数之和

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

暴力法

public int[] TwoSum(int[] nums, int target)
{
    for (int i = 0; i < nums.Length; i++)
    {
        for (int j = i + 1; j < nums.Length; j++)
        {
            if (nums[i] + nums[j] == target)
            {
                return new int[] { i, j };
            }
        }
    }
    return null;
}

参照题解优化版
思路：遍历一次数组，target减去每一项得到差diff，判断diff是否存在字典中，如果包含则找到了索引，否则将该项添加到字典中(数字可能重复)

public int[] TwoSum(int[] nums, int target)
{
    Dictionary<int, int> dic = new Dictionary<int, int>();
    for (int i = 0; i < nums.Length; ++i)
    {
        int diff = target - nums[i];
        if (dic.ContainsKey(diff))
        {
            return new int[] { dic[diff], i };
        }
        dic[nums[i]] = i;
    }
    return null;
}

#4.寻找两个有序数组的中位数

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。
请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。
你可以假设 nums1 和 nums2 不会同时为空。

示例 1:
nums1 = [1, 3]
nums2 = [2]
则中位数是 2.0

示例 2:
nums1 = [1, 2]
nums2 = [3, 4]
则中位数是 (2 + 3)/2 = 2.5

public double FindMedianSortedArrays(int[] nums1, int[] nums2)
{
    if (nums1.Length + nums2.Length == 0) return 0;
    int[] newArr = new int[nums1.Length + nums2.Length];
    int nums1Index = 0, nums2Index = 0, newArrIndex = 0; ;
    while (nums1Index < nums1.Length && nums2Index < nums2.Length)
    {
        newArr[newArrIndex++] = nums1[nums1Index] > nums2[nums2Index] ? nums2[nums2Index++] : nums1[nums1Index++];
    }
    while (nums1Index < nums1.Length)
    {
        newArr[newArrIndex++] = nums1[nums1Index++];
    }
    while (nums2Index < nums2.Length)
    {
        newArr[newArrIndex++] = nums2[nums2Index++];
    }
    if (newArr.Length % 2 != 0)
    {
        return newArr[newArr.Length / 2];
    }
    return (newArr[newArr.Length / 2 - 1] + newArr[newArr.Length / 2]) / 2.0;
}

#11.盛最多水的容器

给定 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

说明：你不能倾斜容器，且 n 的值至少为 2。

在这里插入图片描述
图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

public int MaxArea(int[] height)
{
    int maxarea = 0;
    int left = 0, right = height.Length - 1;
    while (left < right)
    {
        maxarea = Math.Max(maxarea, (right - left) * Math.Min(height[left], height[right]));
        if (height[left] < height[right])
            ++left;
        else
            --right;
    }
    return maxarea;
}

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

给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
示例 1:
给定数组 nums = [1,1,2],
函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。
你不需要考虑数组中超出新长度后面的元素。

示例 2:
给定 nums = [0,0,1,1,1,2,2,3,3,4],
函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。
你不需要考虑数组中超出新长度后面的元素。

排好序的数组，说明相同的数是连续的

public int RemoveDuplicates(int[] nums) {
    if (nums.Length <= 1) {
        return nums.Length;
    }
    int index = 1, currentNum = nums[0];
    for (int i = 1; i < nums.Length; i++) {
        if (nums[i] != currentNum) {
            currentNum = nums[i];
            nums[index++] = currentNum;
        }
    }
    return index;
}

#27.移除元素

给定一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1:
给定 nums = [3,2,2,3], val = 3,
函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。
你不需要考虑数组中超出新长度后面的元素。

示例 2:
给定 nums = [0,1,2,2,3,0,4,2], val = 2,
函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。
注意这五个元素可为任意顺序。
你不需要考虑数组中超出新长度后面的元素。

public int RemoveElement(int[] nums, int val)
{
    int index = 0;
    for (int i = 0; i < nums.Length; ++i)
    {
        if (nums[i] == val) { continue; }
        nums[index++] = nums[i];
    }
    return index;
}

#80.删除排序数组中的重复项 II

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

示例 1:
给定 nums = [1,1,1,2,2,3],
函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3 。
你不需要考虑数组中超出新长度后面的元素。
示例 2:
给定 nums = [0,0,1,1,1,1,2,3,3],
函数应返回新长度 length = 7, 并且原数组的前五个元素被修改为 0, 0, 1, 1, 2, 3, 3 。
你不需要考虑数组中超出新长度后面的元素。

思路同 #26.删除排序数组中的重复项

public int RemoveDuplicates(int[] nums) {
    if (nums.Length <= 2) {
        return nums.Length;
    }
    int index = 2, preNum = nums[0], nextNum = nums[1];
    for (int i = 2; i < nums.Length; i++) {
        if (nums[i] == preNum && nums[i] == nextNum) {
            continue;
        }
        preNum = nextNum;
        nextNum = nums[i];
        nums[index++] = nums[i];
    }
    return index;
}

#88.合并两个有序数组

给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。

说明:
初始化 nums1 和 nums2 的元素数量分别为 m 和 n。
你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。

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

public void Merge(int[] nums1, int m, int[] nums2, int n) {
    int nums1Index = m - 1, nums2Index = n - 1, endIndex = nums1.Length - 1;
    while (nums1Index >= 0 && nums2Index >= 0) {
        nums1[endIndex--] = nums1[nums1Index] < nums2[nums2Index] ? nums2[nums2Index--] : nums1[nums1Index--];
    }
    while (nums1Index >= 0) {
        nums1[endIndex--] = nums1[nums1Index--];
    }
    while (nums2Index >= 0) {
        nums1[endIndex--] = nums2[nums2Index--];
    }
}

#118.杨辉三角

给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。

在杨辉三角中，每个数是它左上方和右上方的数的和。
示例:
输入: 5
输出:
[
[1],
[1,1],
[1,2,1],
[1,3,3,1],
[1,4,6,4,1]
]

public IList<IList<int>> Generate(int numRows) {
    IList<IList<int>> lList = new List<IList<int>>();
    for (int i = 0; i < numRows; i++) {
        if (lList.Count == 0)
            lList.Add(new List<int> { 1 });
        else {
            List<int> newList = new List<int>();
            List<int> list = (List<int>)lList[lList.Count - 1];
            newList.Add(1);
            for (int j = 0; j < list.Count - 1; j++) {
                newList.Add(list[j] + list[j + 1]);
            }
            newList.Add(1);
            lList.Add(newList);
        }
    }
    return lList;
}

#119.杨辉三角 II

给定一个非负索引 k，其中 k ≤ 33，返回杨辉三角的第 k 行。
在这里插入图片描述

在杨辉三角中，每个数是它左上方和右上方的数的和。
示例:
输入: 3
输出: [1,3,3,1]

public IList<int> GetRow(int rowIndex) {
    IList<IList<int>> lList = new List<IList<int>>();
    for (int i = 0; i <= rowIndex; i++) {
        if (lList.Count == 0)
            lList.Add(new List<int> { 1 });
        else {
            List<int> newList = new List<int>();
            List<int> list = (List<int>)lList[lList.Count - 1];
            newList.Add(1);
            for (int j = 0; j < list.Count - 1; j++) {
                newList.Add(list[j] + list[j + 1]);
            }
            newList.Add(1);
            lList.Add(newList);
        }
    }
    return lList[lList.Count - 1];
}

#283.移动零

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

示例:
输入: [0,1,0,3,12]
输出: [1,3,12,0,0]

说明:
必须在原数组上操作，不能拷贝额外的数组。
尽量减少操作次数。

public void MoveZeroes(int[] nums) {
    int zeroCount = 0, index = 0;
    foreach (int num in nums) {
        if (num == 0) { ++zeroCount; } else { nums[index++] = num; };
    }

    for (int i = nums.Length - zeroCount; i < nums.Length; ++i) {
        nums[i] = 0;
    }
}

没饭吃！

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LeetCode-数组

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

扫一扫