LeetCode算法题个人笔记【简单1-5】【c#和c++】

今天开始在算法打拼力

为了时间效率，直接做题记忆，而不是非要搞懂每个概念名词，不然做到猴年马月去

复习的最好方式就是直接在力口做一遍，做得出就是会了，或者说记住了//

看题目，记题解，默题解，以及最后快速复习

**

第一题 : Two Sum

**
链接地址

Given an array of integers, return indices(index 的复数形式之一) of the two numbers such that they add up to a specific target.
You may assume that each input would have exactly one solution, and you may not use the same element twice.

Example:
Given nums = [2 ,7, 11 ,15], target=9;

Because nums[0] + nums[1] = 2 + 7 = 9 ,return [0 , 1].

ps：想一会想不出就别嗯想了

关键在于怎么同一个元素不使用两边呢？假设数组就三个元素，target=B+C,而二重循环A+B,A+C，最后B+C就会使用两次元素。。
不懂，不会

官方题解：使用java
不要太纠结文字游戏了，这里两次应该是指不能同一个位置用两次，2+2=4这样自己加自己
但是可以两个位置相同数值，比如【2，2，3，4】如果目标是4，那么要求返回应该是【0，1】而不是【0，0】

方法一：遍历每个元素x，并查找是否存在与target-x相等的元素。（那么先自己写代码，不准照抄）

参考高赞题解
C#

public class Solution 
{
   
    public int[] TwoSum(int[] nums, int target) 
    {
   
        for(int i=0;i<nums.Length;i++)//这里Length-1也对
        {
   
            for(int j=i+1;j<nums.Length;j++)//最后一个不会与自己相加，因为j=i+1
            {
   
                if(nums[i]+nums[j]==target)
                    return new int[] {
   i,j};
               、
            }
        }
        return new int[] {
   0,0};//官方java中用的是抛出异常
        //不写这句的话如果没有满足条件的情况就会没有返回值，出错
    }
}

（先复制到notepad再复制到这就没bug了）

时间复杂度O（n^2)对于每个元素，遍历数组的剩余部分来查找对应的目标元素，耗费O(n)的时间
（没毛病，ABCD，虽然循环里B只与CD查找，但在A的循环中AB也查找过了，所以每个元素都遍历了剩余元素）
空间复杂度O（1）
复杂度分析（课本p38页）

c++

class Solution {
   
public:
    vector<int> twoSum(vector<int>& nums, int target) {
   
        int i,j;
        for(i=0;i<nums.size()-1;i++)//写上减1也是一样，上面的最后一步不执行so
        {
   
            for(j=i+1;j<nums.size();j++)//nums.size()
            {
   
                if(nums[i]+nums[j]==target)
                {
   
                   return {
   i,j};
                }
            }
        }
        return {
   i,j};
    };
};

方法二： 两边哈希表
课本p246，哈希表又叫散列表

为了对运行时间复杂度进行优化，我们需要一种更有效的方法来检查数组中是否存在目标元素。如果存在，我们需要找出它的索引。保持数组中的每个元素与其索引相对应的最好方法是哈希表。
通过以空间换取速度的方式，我们可以将查找时间从O（n）降低到O（1）。哈希表支持以近似恒定的时间进行快速查找。
使用两次迭代，在第一次迭代中，将每个元素的索引和值添加到表中。在第二次迭代中检查每个元素对应的目标元素（target-nums[i]）是否存在于表中。

C#中，哈希表使用Dictionary类来实现，虽然不熟练字典是什么，但是可以先通过这个例子学习并记住这次的用法

关于C#哈希表，可见菜鸟教程C#集合

再次提醒，不要照抄代码，不要照抄代码，不要照抄代码！这样偷懒毫无意义！懒惰是万恶之源！

    public int[] TwoSum(int[] nums, int target)
    {
   
        Dictionary<int, int> kvs = new Dictionary<int, int>();
        for (int i = 0; i < nums.Length; i++)
        {
   
        //这里注意，判断的是如果输入数值与之前输入 过 的某个数值相同如【2，4，3，4】
        //之前输入了一个4，再输一次包含才是true
            if (kvs.ContainsKey(nums[i]))
            {
   
            //这时显然如果目标是该值乘二，那么返回这两个值即可
                if (nums[i] * 2 == target)
                {
   
                    return new int[] {
    kvs[nums[i]],i };
                }
            }
            else
            {
   
                kvs.Add(nums[i], i);
            }
        }
        for (int i = 0; i < nums.Length; i++)
        {
   
            int complement = target - nums[i];
            //这里的条件和上面不同，这里是不能本身用两次，比如目标为4，【2，3，4，5】时
            //不能返回【0，0】
            //哪其实为什么还需要上面的条件呢，不明白，有这个不久够了吗？
            //因为上面在写入字典笨
            if (kvs.ContainsKey(complement)&&kev[complement]!=i)
            {
   
                return new int[] {
    i, kvs[complement] };
            }
        }
        //没有答案时返回【0，0】
        return new int[] {
    0, 0 };
    }

这个字典确实让数组中的元素和索引对应了，哪这和数组有什么区别呢，不也是一个数据一个索引？
但是！这里确实没有二重循环了，之前一次循环取所有数据，第二次循环将取出的数据（当然是经过和目标值表达式得到的）和其他的进行比较，
两边哈希表指第一遍将索引和值添加到表里，第二次直接搜索，一次循环还是取数据，关键在于这个ContainsKey这个方法吧，这个让我们省略了一个循环来比较值是否相等

时间复杂度O（n），我们把包含有n个元素的列表遍历两次。哈希表将时间缩短到O(1),
空间复杂度O（n），所需额外空间取决于哈希表中存储的元素数量

c++

class Solution {
   
public:
    vector<int> twoSum(vector<int>& nums, int target) {
   
        map<int,int> a;//建立hash表存放数组元素
        vector<int> b(2,-1);//存放结果
        for(int i=0;i<nums.size();i++)
            a.insert(map<int,int>::value_type(nums[i],i));//注意小写
        for(int i=0;i<nums.size();i++)
        {