LeetCode刷题1：两数之和（c#）

题目

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

解答

刷了第一道leetcode题目，好像有点想复杂了，而且关于c#的数组操作挺不熟悉的。初始的解答
思路：

• 现将该数组存起来，放在nums2数组里，用来确定他的初始index.
• 对原数组进行排序。
• 使用两个int值，i,j;索引i指向左边的，初始为0。索引j指向右边的，初始为数组长度。
• 先将j向左移动，知道i和j指向的两个值相等，或者小于目标值了
• 如果小于目标值了，j回去一步，将i右移一步。
• 如果相等了，使用nums2来找到其对应的索引值。（注意：如果碰到两个数相同的情况，可能会返回两个相同的index，但是题目说了只能用一次，所以从第一个index后面开始找符合条件的）

时间复杂度为O(n*n))
使用了Array.IndexOf函数，它的时间复杂度为n
空间复杂度为 O(n)

public class Solution {
    public int[] TwoSum(int[] nums, int target) {
        int[] nums2=new int[nums.Length];
        Array.Copy(nums,nums2,nums.Length);
        Array.Sort(nums);
        int[] index=new int[2];
        int i=0;
        int j=nums.Length-1;
        while(i<j)
        {
            while(nums[i]+nums[j]>=target)
            {
                
                if(nums[i]+nums[j]==target)
                {
                    
                    index[0]=Array.IndexOf(nums2,nums[i]);
                    index[1]=Array.IndexOf(nums2,nums[j]);
                    if(index[0]==index[1])
                    {
						//找第二个index
                        index[1]=Array.IndexOf(nums2,nums[j],index[0]+1);
                    }
                    Array.Sort(index);
                    return index;
                }
                j--;
            }
            i++;
        }
        return index;
    }
}

解法1：

暴力解法：两个for循环 略
或者

public class Solution {
    public int[] TwoSum(int[] nums, int target) {
        int[] index=new int[2];
        
        for(int i=0;i<nums.Length;i++)
        {
            int ano_num=target-nums[i];
            int index_r=Array.IndexOf(nums,ano_num,i+1);
            if(index_r>=0)
            {
                index[0]=i;
                index[1]=index_r;
                break;
            }
        }
        
        return index;
    }
}

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

空间复杂度： O(1)

解法2：

两遍Hash法

其他解法2

//方法二：两遍哈希表
    public int[] TwoSum(int[] nums, int target)
    {
        Dictionary<int, int> kvs = new Dictionary<int, int>();
        for (int i = 0; i < nums.Length; i++)
        {
            //需要对重复值进行判断；因为结果的唯一，所以若有重复值，且答案中包含了重复值的话，说明必有 重复值*2==target; 否则直接忽略重复值即可
            if (kvs.ContainsKey(nums[i]))
            {
                if (nums[i] * 2 == target)
                {
                    return new int[] { i, kvs[nums[i]] };
                }
            }
            else
            {
                kvs.Add(nums[i], i);
            }
        }
        for (int i = 0; i < nums.Length; i++)
        {
            int complement = target - nums[i];
            if (kvs.ContainsKey(complement) && kvs[complement] != i)
            {
                return new int[] { i, kvs[complement] };
            }
        }
        return new int[] { 0, 0 };
    }

作者：DaWuFanCn
链接：https://leetcode-cn.com/problems/two-sum/solution/leetcode-1-two-sum-liang-shu-zhi-he-c-ha-xi-biao-d/

解法3

一遍哈希表

//方法三：一遍哈希表
    public int[] TwoSum(int[] nums, int target)
    {
        Dictionary<int, int> kvs = new Dictionary<int, int>();
        for (int i = 0; i < nums.Length; i++)
        {
            int complement = target - nums[i];
            if (kvs.ContainsKey(complement) && kvs[complement] != i)
            {
                return new int[] { i, kvs[complement] };
            }
            //需要对重复值进行判断,若结果包含了重复值，则已经被上面给return了；所以此处对于重复值直接忽略
            if (!kvs.ContainsKey(nums[i]))
            {
                kvs.Add(nums[i], i);
            }
        }
        return new int[] { 0, 0 };
    }

作者：DaWuFanCn
链接：https://leetcode-cn.com/problems/two-sum/solution/leetcode-1-two-sum-liang-shu-zhi-he-c-ha-xi-biao-d/

其他

附Array.IndexOf
public static int IndexOf (Array array, object value, int startIndex, int count);
从一维数组array中查找第一个value元素，查找范围为从starIndex开始的count个字符。后两个参数忽略时，查找范围为整个数组，最后一个参数忽略时，查找startIndex开始的剩余数组内容。
找到了返回索引值
找不到返回-1；