leedcode题解

目录

• 1.两数之和
• 2.两数相加
• 3. 无重复字符的最长子串
• 4. 寻找两个正序数组的中位数

1.两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：
输入：nums = [3,3], target = 6
输出：[0,1]

我的解法就是两重循环，看到网友的解法如下：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        map<int,int> a;//提供一对一的hash
        vector<int> b(2,-1);//用来承载结果，初始化一个大小为2，值为-1的容器b
        for(int i=0;i<nums.size();i++)
        {
            if(a.count(target-nums[i])>0)
            {
                b[0]=a[target-nums[i]];
                b[1]=i;
                break;
            }
            a[nums[i]]=i;//反过来放入map中，用来获取结果下标
        }
        return b;
    };
};

2.两数相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/add-two-numbers
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

我坑坑吞吞写了半天，才调试成功。

/**
 * 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 *l_out=nullptr;
        // if(l1==nullptr || l2 == nullptr || ((0 == l1->val)&&(l1->next!=nullptr)) || ((0 == l2->val)&&(l2->next!=nullptr)))
        // {
        //     return l_out;
        // }

        if(l1==nullptr || l2 == nullptr)// || ((0 == l1->val)&&(l1->next!=nullptr)) || ((0 == l2->val)&&(l2->next!=nullptr)))
        {
            return l_out;
        }

        l_out = new(ListNode);
        l_out->val = -1;
        l_out->next = nullptr;
        ListNode *l_pre = l_out;
        ListNode *l_cur = l_pre;
        int val_jinwei = 0;
        while(l1!=nullptr && l2!=nullptr)
        {
            int val_sum = l1->val + l2->val + val_jinwei;
            int val = val_sum % 10;
            val_jinwei = val_sum / 10;

            if(nullptr != l_cur)
            {
                l_cur->val = val;
            }else{
                l_cur = new(ListNode);
                l_cur->val = val;
                l_cur->next = nullptr;

                l_pre->next = l_cur;
            }
            l_pre = l_cur;
            l_cur = nullptr;


            l1 = l1->next;
            l2 = l2->next;
        }

        if(l1==nullptr)
        {
            while(l2)
            {
                 int val_sum = l2->val + val_jinwei;
                 int val = val_sum % 10;
                 val_jinwei = val_sum / 10;

                 l_cur = new(ListNode);
                 l_cur->val = val;
                 l_cur->next = nullptr;

                 l_pre->next = l_cur;

                  l_pre = l_cur;
                  l_cur = nullptr;

                 l2 = l2->next;
            }
        }

        if(l2==nullptr)
        {
            while(l1)
            {
                 int val_sum = l1->val + val_jinwei;
                 int val = val_sum % 10;
                 val_jinwei = val_sum / 10;

                 l_cur = new(ListNode);
                 l_cur->val = val;
                 l_cur->next = nullptr;

                 l_pre->next = l_cur;

                  l_pre = l_cur;
                  l_cur = nullptr;

                 l1 = l1->next;
            }
        }
        if(0 != val_jinwei)//进位还有，需要添加一位
        {
            l_cur = new(ListNode);
            l_cur->val = val_jinwei;
            l_cur->next = nullptr;
            l_pre->next = l_cur;
        }

        return l_out;
    }
};

然而，看到别人的实现，我惊呆了，太秀了吧！

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        auto dummy = new ListNode(-1), p = dummy;
        int t = 0;
        while (l1 || l2 || t)
        {
            if (l1) t += l1->val, l1 = l1->next;
            if (l2) t += l2->val, l2 = l2->next;
            p->next = new ListNode(t%10);
            p = p->next;
            t /= 10;
        }
        return dummy->next; 
    }
};

3. 无重复字符的最长子串

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: s = "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:
输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:
输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
示例 4:
输入: s = ""
输出: 0

我的题解，map<char,int> map_ch;
map_ch.count(ch_2)>0
根据map性质，用map.count来统计是否有重复。
map.count(Key)返回值为1或者0，1返回存在，0返回不存在，返回的是布尔类型的值，因为在map类型中所有的数据的Key值都是不同的，所以被count的数要么存在1次，要么不存在。

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int max_cnt = 0;
        for(int i=0;i<s也可以使用集合。回复.size();i++)
        {
            char ch = s[i];
            map<char,int> map_ch;
            map_ch[ch] = 1;
            int cnt = 1;
            for(int j=i+1;j<s.size();j++)
            {
                cnt += 1;
                char ch_2 = s[j];
                if(map_ch.count(ch_2)>0)//重复了
                {
                    cnt--;
                    break;
                }else
                {
                    map_ch[ch_2] = 1;
                }
            }
            if(cnt >= max_cnt)
            {
                max_cnt = cnt;
            }
        }
        return max_cnt;
    }
};

执行结果：
通过
显示详情

添加备注
执行用时：1056 ms, 在所有 C++ 提交中击败了5.05% 的用户
内存消耗：258.1 MB, 在所有 C++ 提交中击败了5.00% 的用户
通过测试用例：987 / 987

优秀题解：
https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/solution/wu-zhong-fu-zi-fu-de-zui-chang-zi-chuan-cshi-xian-/

4. 寻找两个正序数组的中位数

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。
示例 1：
输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2
示例 2：
输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5
示例 3：
输入：nums1 = [0,0], nums2 = [0,0]
输出：0.00000
示例 4：
输入：nums1 = [], nums2 = [1]
输出：1.00000
示例 5：
输入：nums1 = [2], nums2 = []
输出：2.00000
进阶：你能设计一个时间复杂度为 O(log (m+n)) 的算法解决此问题吗？

这道题还是困难？搞不懂为啥困难了，我一把过！
只不过vector排序百度了一下需用用sort。 --> sort(v_merge.begin(),v_merge.end());

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        vector<int> v_merge(nums1);
        v_merge.insert(v_merge.end(),nums2.begin(),nums2.end());
        sort(v_merge.begin(),v_merge.end());
        double mid_num = 0.0;
        if(0 == v_merge.size()%2)
        {
            int i_flg = v_merge.size()/2;
           mid_num = (v_merge[i_flg] + v_merge[i_flg-1])*1.0/2.0;
        }else
        {
            mid_num = v_merge[(int)(v_merge.size()/2)];
        }
        return mid_num;
    }
};

执行结果：
通过
显示详情
添加备注
执行用时：24 ms, 在所有 C++ 提交中击败了86.66% 的用户
内存消耗：87.6 MB, 在所有 C++ 提交中击败了18.90% 的用户
通过测试用例：2094 / 2094

-----囧---我菜鸡了，在评论里面看到一句话，
“因为菜鸡多，连什么是复杂度都不懂，只要题目达到中等难度，就有一堆人发暴力解法，再加一句题目简单”。。。说的就是我