LeetCode-HOT100(一)_leetcodehot100怎么进入

1-两数之和

思路：
暴力解法：双重循环定1动1得到结果 O(n**2)

优化解法：利用unordered_map构造hashmap将内层循环的复杂度变为O(1)

vector<int> twoSum(vector<int>& nums, int target) {
        //需要注意使用的是unordered map
        unordered_map<int, int> hashmap;
        for(int i=0;i<nums.size();i++)
        {
            int x = nums[i];
            auto it = hashmap.find(target-x);//auto自动类型转换
            if(it!=hashmap.end())
            {
                return {it->second, i};//返回{}类型为函数规定返回的类型
            }
            else
            {
                hashmap[x] = i;
            }
        }
        return {};
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2-两数相加

思路：链表合并

简单来说就是用链表实现大数相加的步骤

首先对两个链表相同的部分进行相加

进位保留

int sum = l1->val + l2->val + jinwei
jinwei = sum/10;
p->val = sum%10;
1
2
3

改进：

当一个链表指针指到nullptr时，让其值变为0参与相加运算解决两数长短不一的问题

记得最后需要判断进位是否不为零进行结果的保存

这里直接贴官方题解了——自己写的代码不够简练

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;//解决长短不一的问题，短的高位补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) {//最后判断进位是否>0
            tail->next = new ListNode(carry);
        }
        return head;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

3-无重复字符的最长字串

思路1：暴力解法
将其所有的子串取出，利用set进行去重，统计最大的无重复字串
当然会超时！

思路2：滑动窗口
利用unordered_map不断添加字符进入，当存在重复的字符且该字符在统计的范围内——这里避免了删除map中前面出现过的字符这一操作，具体实现在代码中呈现。
统计当前窗口内的字符数目，更新长度，更新滑动窗口，更新当前计数cnt，读入下一个字符继续判断。

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        unordered_map<char, int> m;//记录每个字符的值和位置
        int ans = 0;//最终返回的答案
        int cnt = 0;//当前窗口内的非重复字符
        int start = 0;//窗口的start
        int end = 0;//窗口的end
        while(end<s.size())
        {
            char ch = s[end];//每次往后读一位字符
            //判断其是否在当前的窗口内出现
            if(m.find(ch)!=m.end()&&m[ch]>=start)
            {
            	//出现则移动窗口的start到该重复字符的下一个
                start = m[ch]+1;
                cnt = end-start;//计算当前窗口大小
            }
            m[ch] = end;//添加该字符
            end++;//往后读
            cnt++;//不重复则cnt++
            ans = max(cnt, ans);//更新最大值
        }
        ans = max(cnt, ans);
        return ans;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27