1-10(leetcode)

1. 两数之和

原题链接

/*
使用c++中的 哈希表
循环一遍数组，干俩事：
1. 判断target - nums[i] 是否在哈希表中
2. 将nums[i] 插入到哈希表中

*/
// C++版本
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> hash;
        for(int i = 0 ;i < nums.size(); i++){
            int r = target - nums[i];
            if(hash.count(r)) return {hash[r], i};
            hash[nums[i]] = i;
        }
        return {};
    }
};
// Python版本
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        d = {}
        for i, num in enumerate(nums):
            r = target  - num
            if r in d:
                return [d[r],i]
            d[num] = i
        return []

2.两数相加

原题链接

/*
模拟加法过程：
1.从低到高位，逐位相加。如果和大于10，保留个位数字，进位数加1
2.如果最高位有进位，需要在最前面补1


Tip:
添加一个虚拟头结点： ListNode *head = new ListNode(-1);可以简化边界框的判断

*/

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

'''
？？？？
cur=  cur.next = ListNode(t%10)的含义
大致分为以下三步：
p  = ListNode(t%10)
cur = p 
cur.next = p

'''
class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        head = cur = ListNode(0)   
        t = 0
        while l1 or l2 or t:
            if l1:
                t += l1.val
                l1 = l1.next
            if l2:
                t += l2.val
                l2 = l2.next
            cur.next = ListNode(t%10)
            # cur = cur.next = ListNode(t%10)  为什么这样连续赋值是不可以的？       
            cur = cur.next
            t //=10
        return   head.next

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

原题链接

/*
哈希表 + 滑动窗口的套路
定义两个指针i,j(i>=j), 表示当前扫描到的子串是[i,j](闭区间)。扫描过程中维护一个哈希表unodered_map<char, int> 表示[i,j]中每个字符出现的次数。
线性扫描时，每次循环的流程如下：
1.指针i后移一位，同时将哈希表中s[i]的计数加1， 
2.假设i移动前的区间[i,j]中没有重复字符，则i移动后，只有s[i]可能出现两次。因此我们不断的向后移动j，直至区间[i,j]中s[i]的个数等于1为止。



*/
class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        unordered_map<char, int> hash;
        int res = 0;
        for(int i = 0, j = 0; i <s.size(); i++){
            hash[s[i]] ++;
            while(hash[s[i]] > 1){
                hash[s[j++]]--;
            }
            res = max(res, i-j+1);

        }
        return res;
    }
};

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

原题链接

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int tot = nums1.size() + nums2.size();
        if(tot % 2 == 0){
            int left = find(nums1, 0, nums2, 0, tot/2);
            int right = find(nums1, 0, nums2, 0 , tot/2 + 1);
            return (left +  right) / 2.0;
        }else return find(nums1, 0, nums2, 0, tot/2 + 1);
    }
    int find(vector<int>& nums1, int i, vector<int>& nums2, int j, int k){
        if((nums1.size() - i) > (nums2.size() -j)) return find(nums2,j,nums1, i, k);
        if(k == 1){
            if(nums1.size() == i) return nums2[j];
            else return min(nums1[i], nums2[j]);
        }
        if(nums1.size() == i) return nums2[j + k-1];
        int si = min(i + k/2 , int(nums1.size()));
        int sj = j + k/2;
        if(nums1[si-1] >  nums2[sj-1]) return find(nums1, i, nums2,sj,k-k/2);
        else return find(nums1, si, nums2, j, k - (si - i));

    }
    
};

5.最长回文子串

原题连接

暴力枚举
首先回文串枚举中心点i，然后分两种情况向两边扩展边界，直到遇到不同字符为止

• 1.奇数–>判断 s[i-k] ==s[i+k], k=1,2,3…
• 2.偶数–>判断 s[i-k] == s[i+k-1], k=1,2,3…
  如果遇到了不同字符，则找到了以i为中心的会问串的边界

class Solution
{
public:
    string longestPalindrome(string s)
    {
        string res;
        for (int i = 0; i < s.size(); i++)
        {
            //首先考虑奇数的情况， 定义中心点左右的两个游标
            int l = i - 1, r = i + 1;
            //左右游标位置字符相同时，同时往两边移动
            while (l >= 0 && r < s.size() && s[l] == s[r])l--, r++;
            //根据游标长度截取字符串
            if (res.size() < r - l - 1)
                res = s.substr(l + 1, r - l - 1);
            //考虑偶数情况，左右两游标是对称的
            l = i, r = i + 1;
            //相等时，同时往两边移动
            while (l >= 0 && r < s.size() && s[l] == s[r])l--, r++;
            //res保留最长的回文数
            if (res.size() < r - l - 1)
                res = s.substr(l + 1, r - l - 1);
        }

        return res;
    }
};

6.Z字形变换

原题链接

找规律：
对于行数为n：

• 1.第一行和最后一行，是公差为2(n-1)的等差数列， 首相是0 和 n-1;
• 2.对于第i行(0< i < n-1),是两个公差为2(n-1)的等差数列交替排列，首项分别是i和2n - 2 - i;
  自上到下，依次打印每行的字符
  每个字符遍历一遍o(n)

class Solution {
public:
    string convert(string s, int n) {
        // 定义结果
        string res;
        // 特判 n=1的情况，因为若n=1,等差2*n-2为0，会陷入死循环
        if(n==1) return s;
        // 0-n-1行
        for(int i = 0; i < n; i++){
            // 首行和尾行的情况
            if(i == 0 || i == n-1){
                for(int j = i; j < s.size(); j += 2 * n - 2)
                    res +=s[j];
            }else{
                for(int j = i, k = 2 * n - 2 -i; j < s.size() || k < s.size();j += 2 * n - 2,k += 2 * n - 2){
                    //注意两个等差数列的顺序
                    if( j < s.size()) res += s[j];
                    if( k < s.size()) res += s[k];
                }
            }
        }
        return res;
    }
};

7.整数反转

原题链接

循环
从右往左计算每一位数字，然后逆序累加在一个整数上
注意2点：

• 1.int整数逆序后可能会溢出，所有采用long long 记录中间结果
• 2.c++中，负数的取模运算和数学意义上的取模运算不同，结果还是负数，因此不需要对负数进行额外处理
  时间复杂度分析：一共有 O(logn)位，对于每一位的计算量是常数级的，所以总时间复杂度是 O(logn)

class Solution {
public:
    int reverse(int x) {
        // 防止x逆序后溢出，使用long long 类型保存中间结果
        long long  r = 0;
        while(x){
            r = r * 10 + x % 10; //逆序累加
            x /= 10; // 去除个位数字
        }
        //两个特判，如果反转后整数溢出那么就返回 0。
        if( r < INT_MIN) return 0;
        if( r > INT_MAX) return 0;
        return r;
    }
};

8.字符串转整数(atoi)

原题链接
难点在于考虑的边界情况较多，需要仔细考虑：
每个字符遍历一遍，时间复杂度O(n);0

class Solution {
public:
    int myAtoi(string str) {
        //空格位判断
        int k = 0;
        while(k < str.size() && str[k] == ' ') k++;
        if(k == str.size()) return 0;
        //符号位判断
        int minus = 1;
        if(str[k] == '-') minus = -1, k++;
        else if(str[k] == '+')  k++;
        //定义答案,防止溢出，使用long long保存中间结果
        long long res = 0;
        //数字位判断
        while(k < str.size() && str[k] >='0' &&  str[k] <= '9'){
            res  = res * 10 + str[k] - '0';
            k++;
            if(res > INT_MAX) break;
        }
        res*=minus;
        // 对结果进行特判
        if(res >INT_MAX) return INT_MAX;
        if(res <INT_MIN) return INT_MIN;
        return res;
    }
};

因为题目要求我们的环境只能储存32位的有符号整数，因此不能使用long long 保存临时结果 ，需要对 res进行特判。

class Solution {
public:
    int myAtoi(string str) {
        //空格位判断
        int k = 0;
        while(k < str.size() && str[k] == ' ') k++;
        if(k == str.size()) return 0;
        //符号位判断
        int minus = 1;
        if(str[k] == '-') minus = -1, k++;
        else if(str[k] == '+')  k++;
        //定义答案
        int res = 0;
        //数字位判断
        while(k < str.size() && str[k] >='0' &&  str[k] <= '9'){
            int x = str[k] - '0';
            // 如果该数字是正数，
            if(minus > 0 && res > (INT_MAX -x ) / 10) return INT_MAX;
            // 如果该数字是负数，
            if(minus < 0 && -res < (INT_MIN + x) / 10) return INT_MIN;
            //INT_MIN的绝对值比INT_MIX大1，res是正数，需要对负无穷特判一下
            if(-res * 10 - x == INT_MIN) return INT_MIN;
            res  = res * 10 + x;
            k++;
            if(res > INT_MAX) break;
        }
        res*=minus;
        // 对结果进行特判
        if(res >INT_MAX) return INT_MAX;
        if(res <INT_MIN) return INT_MIN;
        return res;
    }
};

9.回文数

原题链接
注意两点：

• 1.负数因为负号的存在，不是回文串；
• 2.如果用Reverse Integer 题目中的做法，需要避免整数溢出的问题；

转为字符串

class Solution {
public:
    bool isPalindrome(int x) {
        if(x < 0) return 0;
        //转化为字符串
        string s = to_string(x);
        //该字符串和字符串的逆序是否相等
        return s == string(s.rbegin(), s.rend());
    }
};

数值方法

class Solution {
public:
    bool isPalindrome(int x) {
        //特判负数
        if(x < 0) return 0;
        // int的逆序可能溢出
        long long res=0;
        //保存下x
        int y = x;
        while(x){
            res = res*10 + x % 10;
            x/=10;
        }
        return res == y;
    }
};

10.正则表达式匹配(？)

原题链接
dp问题

class Solution {
public:
    bool isMatch(string s, string p) {
        int n = s.size(), m = p.size();
        // 字符串下标从1开始
        s = ' ' + s, p = ' '  + p;
        //状态表示
        vector<vector<bool>>  f(n + 1, vector<bool>(m + 1));
        //状态初始化
        f[0][0] = true;
        // s串：1~n
        for(int i = 0; i <=n; i++)
        	// p串：1~m
            for(int j = 1; j<=m; j++){
            	// 若是a*这种形式，先不做处理
                if(j+1 <= m && p[j+1]=='*') continue;
                // 1. p[j] != '*',状态计算
                // 2. p[j] = '*',状态计算
                if(i && p[j] != '*'){
                    f[i][j] = f[i-1][j-1] && (s[i] == p[j] || p[j] =='.');
                }
                else if(p[j] == '*'){
                    f[i][j] = f[i][j-2] || i && f[i-1][j] && (s[i] == p[j-1] || p[j-1]=='.');
                }

            }
        return f[n][m];
    }
};