leetcode hot 1-2

1.两数之和

解法1：暴力遍历

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        for(int i=0;i<nums.size();i++)
        {
            for(int j=i+1;j<nums.size();j++)
            {
                if(nums[i]+nums[j]==target)
                {
                    return {i,j};
                }
            }
        }
        return{};
    }
};

遇到的问题：

在开始的时候，第二重循环将j设置成 j=i 结果第一个数相加两次等于target

输入：

[3,2,4] 6

输出：

[0,0]

预期结果：

[1,2]

此时将j 指向 i的下一个便能通过

暴力解法的时间复杂度是n^2

解法2：哈希表

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        map<int,int>m;
        for(int i=0;i<nums.size();i++)
        {
            auto it=m.find(target-nums[i]);//如果查找成功，find返回下标，如果没找对，返回end（）
            if(it!=m.end())
            {
                return {it->second,i};
            }
            m[nums[i]]=i;
        }
        return {};
    }
};

遇到的问题：

插入的时候使用insert结果报错了

哈希表的高效查找可以使时间复杂度降下到o（n）

2.两数相加

解法1：模拟

直接遍历链表对应数字相加即可。逐位计算它们的和，并与前面的进位值相加

比如，两个链表对应位的数字分别为n1和n2，进位为carry（通常为0和1），则它们的和为(n1 + n2 + carry)，对应位上数字变为(n1 + n2 + carry)%10，新的进位为(n1 + n2 + carry)/10。

如果两个链表长度不一样，长度短的链表后续对应位上值均为0即可。如果遍历结束之后，carray大于0（也就是等于1），则在结构链表后面新增一个节点，

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode* head=nullptr,*tail=nullptr;
        
        int carry=0;
        while(l1||l2)
        {
            int n1=l1?l1->val:0;
            int n2=l2?l2->val:0;
            int sum=n1+n2+carry;
            if(!head)
            {
                head=tail=new ListNode(sum%10);
            }
            else
            {
                tail->next=new ListNode(sum%10);
                tail=tail->next;
            }
            carry=sum/10;
            if(l1)
            {
                l1=l1->next;
            }
            if(l2)
            {
                l2=l2->next;
            }
        }
        if(carry>0) 
        {
            tail->next=new ListNode(carry);
            
        }
        return head;
    }
};

遇到的问题：
int n1=l1?l1->val:0; int n2=l2?l2->val:0; 一开始没看懂这两句，其实它们等价于

            int n1 = l1 != null ? l1.val : 0;
            int n2 = l2 != null ? l2.val : 0;

另外又将这两句放在了while之外，结果造成节点一直指向第一个，没有更新

之后又将 tail->next=new ListNode(carry); 写成 tail=new ListNode(carry); tail=tail->next；

最后造成当 最后相加carry存在的时候，没有进位

上述方法时间复杂度的计算与链表的长度有关，比如两个链表的长度分别为m和n，则遍历的次数为max(m,n)，也就m和n中取最大值，所以时间复杂度为O(n)。

解法2：递归

不用递归没有灵魂。尽管多数时候，递归不见得更有效率

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        if(!l1) return l2;
        if(!l2) return l1;
        int target=l1->val+l2->val;
        ListNode* res=new ListNode(target%10);
        res->next=addTwoNumbers(l1->next,l2->next);
        if(target>=10) 
        {
        res->next=addTwoNumbers(res->next,new ListNode(1)); 
        }
        return res;
    }
};

递归解法非常巧妙。

做递归题目一定要牢记「递归函数的定义」。

递归函数定义：addTwoNumbers 表示将两个链表 l1 和 l2 相加得到的新链表；
递归终止条件：如果 l1 和 l2 有一个为空，则返回另外一个。
递归函数内容：

把两个链表节点的值相加（结果记为 add ）。把 add 模 1010 作为当前的链表节点的值。
把两个链表的 next 节点相加。（注意：如果当前相加的结果 add >= 10add>=10，需要把 next 节点相加得到的结果 + 1。）

递归解法妙在天然地处理好了两个链表不一样长、最终相加结果有进位的情况。

可以推演一下递归调用的时间复杂度。针对递归调用的时间复杂度计算，本质上要看：递归的次数✖️每次递归中的操作次数。那么，上述方法递归了几次呢？递归的次数也是与两个链表最长的那个的长度有关，最后可能会因为进位多算一次，因此递归次数为n或n+1，而内部计算并不随n的变化而变化，执行次数为常数。因此整体时间复杂度为n*1 = O(n)。

空间复杂度依旧与结果链表的长度有关，因此依旧为O(n)。