LeetCode历程

最新推荐文章于 2022-03-12 08:47:22 发布

Tres_Lu

最新推荐文章于 2022-03-12 08:47:22 发布

阅读量224

点赞数

分类专栏： LeetCode 文章标签： LeetCode

本文链接：https://blog.csdn.net/XingpengLu/article/details/83419446

版权

LeetCode 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1.两数之和

给定一个整数数组nums和一个整数目标值target，请在该数组中找出和为目标值 target的那两个整数，并返回它们的数组下标。
可以假设每个输入只对应一种答案，但是，数组中同一个元素在答案里不能重复出现。
可以按任意顺序返回答案。

示例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) {
        vector<int> result;
        for(int i = 0; i < nums.size()-1; i++) 
            for(int j = i + 1; j < nums.size(); j++)
                if(nums[i] + nums[j] == target) {
                    result.push_back(i);
                    result.push_back(j);
                }
        return result;
    }
};

vector<int> result;
result.push_back(i);

vector<int> result(2);-->result = [0, 0];
result[0] = i;

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int len = nums.size();
        map<int, int> m;
        vector<int> result(2);
        for (int i = 0; i < len; i++)
            m[nums[i]]= i;
        for (int i = 0; i < len; i++) {
            int c = target - nums[i];
            if (m.count(c) && m[c] != i) {
                result[0] = i;
                result[1] = m[c];
                break;
            }
        }
        return result;
    }
};

复杂度分析：
方法一：

时间复杂度：O(n²)，对于每个元素，我们试图通过遍历数组的其余部分来寻找它所对应的目标元素，这将耗费 O(n) 的时间。因此时间复杂度为 O(n²)。
空间复杂度：O(1)。

方法二：

时间复杂度：O(n)，我们只遍历了包含有 n 个元素的列表一次。在表中进行的每次查找只花费 O(1) 的时间。
空间复杂度：O(n)，所需的额外空间取决于哈希表中存储的元素数量，该表最多需要存储 n 个元素。

2.两数相加

给定两个非空的链表，表示两个非负整数。每位数按照逆序方式存储，并且每个节点只存储一位数字。
请将两数相加，并以相同形式返回一个表示和的链表。
可以假设除了数字 0 之外，这两个数字都不会以0开头。

示例1：

输入：2 -> 4 -> 3 、 5 -> 6 -> 4
输出：7 -> 0 -> 8
原因：342 + 465 = 807

示例2

输入：l1 = [0], l2 = [0]
输出：[0]

示例 3：

输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,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* p = l1;
        ListNode* q = l2;
        ListNode* l3 = new ListNode(0);
        ListNode* curr = l3;
        int carry = 0;
        while (p!=NULL || q!=NULL) {
            int x = (p!=NULL)?p->val:0;
            int y = (q!=NULL)?q->val:0;
            int sum = x + y + carry;
            curr->next = new ListNode(sum%10);
            carry = sum/10;
            curr = curr->next;
            if (p!=NULL) p = p->next;
            if (q!=NULL) q = q->next;
        }
        if (carry > 0) curr->next = new ListNode(carry);
        return l3->next;
    }
};

复杂度分析

时间复杂度：O(max(m, n))，假设 m 和 n 分别表示 l1 和 l2 的长度，上面的算法最多重复 max(m, n) 次。
空间复杂度：O(max(m, n))，新列表的长度最多为max(m, n) + 1。

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

给定一个字符串s，找出不含有重复字符的最长子串的长度。

示例 1:

输入: “abcabcbb”
输出: 3
解释: 无重复字符的最长子串是 “abc”，其长度为 3。

示例 2:

输入: “bbbbb”
输出: 1
解释: 无重复字符的最长子串是 “b”，其长度为 1。

示例 3:

输入: “pwwkew”
输出: 3
解释: 无重复字符的最长子串是 “wke”，其长度为 3。请注意，答案必须是一个子串，“pwke” 是一个子序列而不是子串。

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if (s.empty())
            return 0;
        else {
            int res = 1;
            int start = 0;
            int middle, end;
            for (int end = start + 1; end < s.size(); end++) {
                for (middle = start; middle < end; middle++)
                    if(s[middle] == s[end])
                        break;
                if (middle != end) {
                    res = max(res, end - start);        // 上一个end
                    start = middle + 1;
                }
                else
                    res = max(res, end - start + 1);
            }
            return res;
        }
    }
};

4.两个排序数组的中位数

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2 。请找出并返回这两个有序（正序）数组的中位数。
要求算法的时间复杂度为 O(log (m+n)) 。可以假设 nums1 和 nums2 不同时为空。

示例 1:

nums1 = [1, 3], nums2 = [2]
中位数是 2.0

示例 2:

nums1 = [1, 2], nums2 = [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

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int m1 = nums1.size();
        int m2 = nums2.size();
        int sum = m1 + m2;
        int l1 = 0;
        int l2 = 0;
        
        if (sum == 1)
            return (m1>m2)?nums1[0]:nums2[0];
        else {
            int m = sum/2 + 1;
            double nums3[m];

            for (int i = 0; i < m; i++) {
                if (l1 == m1)
                    nums3[i] = nums2[l2++];
                else if (l2 == m2)
                    nums3[i] = nums1[l1++];
                else if (nums1[l1] <= nums2[l2])
                    nums3[i] = nums1[l1++];
                else if (nums1[l1] > nums2[l2])
                    nums3[i] = nums2[l2++];
            }
            
            if (sum%2 == 0)
                return (nums3[m - 2] + nums3[m - 1])/2;
            else
                return nums3[m - 1];
        }
    }
};

5.最长回文子串

给定一个字符串 s，找到 s 中最长的回文子串。
你可以假设 s 的最大长度为1000。

示例 1：

输入: “babad”
输出: “bab”
注意: "aba"也是一个有效答案。

示例 2：

输入: “cbbd”
输出: “bb”

示例 3：

输入：s = “a”
输出：“a”

示例 4：

输入：s = “ac”
输出：“a”

// 方法一：建立string，220ms
class Solution {
public:
    string longestPalindrome(string s) {
        string res;
        for (int f = 0; f < s.size(); f++) {
            for (int e = s.size() - 1; (e >= f)&(res.size() < e - f + 1); e--) {
                if (s[f] == s[e]) {
                    int i = f;
                    int j = e;
                    while (i<=j) {
                        if (s[i] != s[j])
                            break;
                        else if ((s[i] == s[j])&(i == j||i == j - 1)) {
                            string res_0;
                            for (int k = f; k < e + 1; k++) 
                                res_0 = res_0 + s[k];
                            res = res_0;
                        }
                        ++i;
                        --j;
                    }
                }
            }
        }
        return res;
    }
};

// 方法二：返回原string子串，96ms
class Solution {
public:
    string longestPalindrome(string s) {
        int res_l = 0;
        int res_b = 0;
        int res_e = 0;
        for (int f = 0; (f < s.size())&(res_l < s.size() - f); f++) {
            for (int e = s.size() - 1; (e >= f)&(res_l < e - f + 1); e--) {
                if (s[f] == s[e]) {
                    int i = f;
                    int j = e;
                    while (i<=j) {
                        if (s[i] != s[j])
                            break;
                        else if ((s[i] == s[j])&(i == j||i == j - 1)) {
                            res_b = f;
                            res_e = e;
                            res_l = e - f + 1;
                        }
                        ++i;
                        --j;
                    }
                }
            }
        }
        return s.substr(res_b, res_l);
    }
};

6.Z字形变换

将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。
比如输入字符串为 “PAYPALISHIRING” 行数为 3 时，排列如下：

P A H N
A P L S I I G
Y I R

之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如：“PAHNAPLSIIGYIR”。
请你实现这个将字符串进行指定行数变换的函数：

string convert(string s, int numRows);

示例 1：

输入：s = “PAYPALISHIRING”, numRows = 3
输出：“PAHNAPLSIIGYIR”

示例 2：

输入：s = “PAYPALISHIRING”, numRows = 4
输出：“PINALSIGYAHRPI”
解释：
P I N
A L S I G
Y A H R
P I

示例 3：

输入：s = “A”, numRows = 1
输出：“A”

class Solution {
public:
    string convert(string s, int numRows) {
        if (numRows == 1) 
            return s;
        string res;
        for (int row = 0; row < numRows; row++) {
            for (int i = row; i < s.size(); i += (2*(numRows - 1))) {
                res += s[i];
                if (row && (numRows-1-row) && ((i+2*(numRows-1-row))<s.size())) 
                    res += s[i+2*(numRows-1-row)];
            }
        }
        return res;
    }
};

7.整数反转

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
如果反转后整数超过 32 位的有符号整数的范围 [−2³¹, 2³¹ − 1] ，就返回 0。
假设环境不允许存储 64 位整数（有符号或无符号）。

示例 1：

输入：x = 123
输出：321

示例 2：

输入：x = -123
输出：-321

示例 3：

输入：x = 120
输出：21

示例 4：

输入：x = 0
输出：0

class Solution {
public:
    int reverse(int x) {
        int res = 0;
        bool zero_flag = true;
        int max = (pow(2, 31) - 1) / 10;
        int min = -(pow(2, 31)) / 10;
        while (x) {
            int i = x % 10;
            if (zero_flag) {
                if (i) {
                    res = i;
                    zero_flag = false;
                }
            }
            else {
                if (res > max || res < min)
                    return 0;
                else if ((res == max && i > 7) || (res == min && i < -8))
                    return 0;
                else
                    res = res*10 + i;
            }
            x = x / 10;
        }
        return res;
    }
};

8.字符串转换整数(atoi)

请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数（类似 C/C++ 中的 atoi 函数）。
函数 myAtoi(string s) 的算法如下：

读入字符串并丢弃无用的前导空格
检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。确定最终结果是负数还是正数。如果两者都不存在，则假定结果为正。
读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
将前面步骤读入的这些数字转换为整数（即，“123” -> 123， “0032” -> 32）。如果没有读入数字，则整数为 0 。必要时更改符号（从步骤 2 开始）。
如果整数数超过 32 位有符号整数范围 [−2³¹, 2³¹ − 1] ，需要截断这个整数，使其保持在这个范围内。具体来说，小于 −2³¹ 的整数应该被固定为 −2³¹ ，大于 2³¹ − 1 的整数应该被固定为 2³¹ − 1 。
返回整数作为最终结果。

注意：

本题中的空白字符只包括空格字符 ’ ’ 。
除前导空格或数字后的其余字符串外，请勿忽略 任何其他字符。
示例 1:

输入: “42”
输出: 42

示例 2:

输入: " -42"
输出: -42
解释: 第一个非空白字符为 ‘-’, 它是一个负号。我们尽可能将负号与后面所有连续出现的数字组合起来，最后得到 -42 。

示例 3:

输入: “4193 with words”
输出: 4193
解释: 转换截止于数字 ‘3’ ，因为它的下一个字符不为数字。

示例 4:

输入: “words and 987”
输出: 0
解释: 第一个非空字符是 ‘w’, 但它不是数字或正、负号。
因此无法执行有效的转换。

示例 5:

输入: “-91283472332”
输出: -2147483648
解释: 数字 “-91283472332” 超过 32 位有符号整数范围。因此返回 INT_MIN (−2³¹) 。

class Solution {
public:
    int myAtoi(string s) {
        int res = 0;
        int i = 0;
        int flag = 1;
        int max = INT_MAX / 10;
        int min = INT_MIN / 10;
        // 空格
        while (s[i] == 32) 
            i++;
        
        if (s[i] == 43)         // +
            i++;
        else if (s[i] == 45) {  // -
            flag = -1;
            i++;
        }

        for (i; i < s.size(); i++) {
            if (s[i] < 47 || s[i] > 58) 
                break;
            else {
                int j = s[i] - 48;
                if (res > max || res < min) 
                    return flag == 1 ? INT_MAX : INT_MIN;
                else if ((res == max && j > 7) || (res == min && j > 8))
                    return flag == 1 ? INT_MAX : INT_MIN;
                else 
                    res = res*10 + flag*j;
            }
        }

        return res;
    }
};

9.回文数

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。

示例 1：

输入：x = 121
输出：true

示例 2：

输入：x = -121
输出：false
解释：从左向右读, 为 -121 。从右向左读, 为 121- 。因此它不是一个回文数。

示例 3：

输入：x = 10
输出：false
解释：从右向左读, 为 01 。因此它不是一个回文数。

示例 4：

输入：x = -101
输出：false

class Solution {
public:
    bool isPalindrome(int x) {
        if (x < 0) 
            return false;
        
        string x_str = to_string(x);
        int len = x_str.size();
        for (int i = 0; i < len/2 + 1; i++) {
            if (x_str[i] != x_str[len - 1 - i]) 
                return false;
        }
        return true;
    }
};