C#力扣数组题目详解（题目会更新）

27. 移除元素

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

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1：
输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。

分析：将i+1位的元素 挪动到 i位即可，同时要记得将i–，因为i+1的元素也可能是需要移除的元素，还需要从该位判断

public class Solution {
    public int RemoveElement(int[] nums, int val) {
        int leng = nums.Length;
        for(int i = 0; i < leng; i++)
        {
            if(nums[i] == val)
            {
                for(int j = i + 1; j < leng; j++)
                {
                    nums[j - 1] = nums[j];
                }
                i--;
                leng--;
            }
        }
        return leng;
    }
}

977. 有序数组的平方

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：
输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

分析：有两种方式
第一种：直接对所有元素平方，通过Array.Sort进行排序（升序）

public class Solution {
    public int[] SortedSquares(int[] nums) {
        int length = nums.Length;
        for(int i = 0; i < length; i ++)
        {
            nums[i] = nums[i] * nums[i];            
        }
        Array.Sort(nums);
        return nums;
    }
}

第二种：双指针法，首先创建一个新数组，对首元素和尾元素的平方数进行比较，将大的一方放入新数组的尾部，依次向前填充元素

要点：我们需要三个变量，左右指针标记旧数组的元素，i用来标记新数组添加元素的位置

public class Solution {
    public int[] SortedSquares(int[] nums) {
        int leng = nums.Length;
        int left = 0,right = nums.Length - 1;
        int[] newnums = new int[leng];
        for(int i = right; i >= 0; i--)
        {
            int nums1 = nums[left]*nums[left];
            int nums2 = nums[right]*nums[right];
            if(nums1 < nums2)
            {
                newnums[i] = nums2;
                right--;
            }
            else
            {
                newnums[i] = nums1;
                left++;
            }
        }
        return newnums;
    }
}

209. 长度最小的子数组

分析：（我这里使用的是暴力解法，力扣超时，其他解法我是学了就忘学了就忘，就写一下暴力吧）
暴力很简单，就是两层遍历，第一层遍历所有的元素，第二层是以第一层为准，往后进行遍历，有几个小的点要注意别写错：
（1）sum 也就是元素总和值，要写到第一层遍历中，因为第二层遍历完需要清空sum值才对
（2）其中计算总和位数，也就是j - i + 1，想不出来就画图软件画一下就明白了
（3）MaxValue我是第一次看别人用的，目的其实就是标识，因为Math.Min是返回出最小的值，如果这个循环中没有大于target的值，那就返回MaxValue，在最后返回值中判断一下，如果等于最大值说明没有对应的值，返回0，不等于最大值则返回result

分析：题目要求是在一个数组中选出一个子数组 >= 目标值，最后返回这个子数组的长度
（1）for循环是超时的，while循环是ok的
（2）这里使用双指针法，start慢指针，end快指针，让end不断向后查找元素，用sum将元素进行累加
（3）当sum >= target时，就去移动start指针，result记录最小值，不断减去nums[start]，因为是while循环，直到 < target就会退出循环，继续移动end指针向后

public class Solution {
    public int MinSubArrayLen(int target, int[] nums) {
        int n = nums.Length;
        int start = 0,end = 0;
        int result = int.MaxValue;
        int sum = 0;
        while(end < n)
        {
            sum += nums[end];
            while(sum >= target)
            {
            	//end - start + 1 就是元素数量 看不懂可以代入数字想一下
                result = Math.Min(result,end - start + 1);
                //不断的减去之前的元素 直到小于target退出循环 这样就能保证累加数组是最小的
                sum = sum - nums[start];
                start++;
            }
            end++;
        }
        return result == int.MaxValue ? 0 : result;
    }
    //int.MaxValue; //将result设置为Integer.MAX_VALUE的目的是为了确保在遍历过程中能够正确地更新result的值。
    //在最后返回结果时，如果result仍然保持为Integer.MAX_VALUE，则说明不存在满足条件的子数组，返回0；否则返回找到的最小子数组长度。
}

非力扣题目
//设备中存有n个文件，文件id基于数组docs。若文件id相同，则定义为该文件存在副本。请返回任一存在副本的文件id。
//示例-1
//输入:docs = [2, 5, 3, 0, 5, 0]
//输出:0 或 5
//0 ≤ docs[i] ≤ n - 1

分析：题意就是在一个数组中找到相同id的文件
（1）这里也可以使用字典，将出现过的id都存放起来即可，但空间复杂度为O（n）。
（2）那这里注意看题目，0 ≤ docs[i] ≤ n - 1，说明id最大值不会超出索引值。所以我们可以通过将id放到和索引相等的位置，假设索引 = 2，存放id = 2，那如果后续还有id = 2想要放到索引为2的位置，就说明重复了，返回出去即可。

 public class 寻找文件副本 : MonoBehaviour
    {
        void Start()
        {
            int[] arr = new int[] { 2, 5, 3, 0, 5, 0 };
            Debug.Log(Find(arr));
        }
        public int Find(int[] arr)
        {
            int i = 0;
            while(i < arr.Length)
            {
            	//i++的位置很重要 索引i一直要等到i == arr[i]才能进行下一位
                if (i == arr[i])
                {
                    i++;
                    continue;
                }
                //举个例子 假设索引 = 2,id = 2,但索引 = 4,id = 2,就是说明找到了目标值（重复值）
                //也就是（索引4）2 == （索引2）arr[2] 相同则返回目标值
                if (arr[i] == arr[arr[i]])
                {
                    return arr[i];
                }
                //不等于就一直做交换逻辑 直到等于后再进行i++
                int temp = arr[i];
                arr[i] = arr[temp];
                arr[temp] = temp;
            }
            return -1;
        }
    }