LeetCode.1-10

LeetCode 1. 两数之和

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> res;
        unordered_map<int,int> hash;
        for(int i=0;i<nums.size();i++)
        {
            int another = target - nums[i];
            if(hash.count(another))
            {
                res.push_back(i);
                res.push_back(hash[another]);
                break;
            }
            hash[nums[i]] = i;
        }
        return res;
    }
};

LeetCode 2. 两数相加

/**
 * 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) {
        auto dummy = new ListNode(-1), cur = dummy;
        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 dummy->next;
    }
};

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

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

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

//方法一：
class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int total = nums1.size() + nums2.size();
        if(total % 2 == 0)
        {
            int left = findKthNumber(nums1,0,nums2,0,total/2);
            int right = findKthNumber(nums1,0,nums2,0,total/2+1);
            return (left+right)/2.0;
        }
        else
            return findKthNumber(nums1,0,nums2,0,total/2+1);
    }

    int findKthNumber(vector<int> &nums1, int i, vector<int> &nums2, int j, int k)
    {
        if(nums1.size()-i > nums2.size()-j) return findKthNumber(nums2,j,nums1, i, k);
        if(nums1.size() == i) return nums2[j+k-1];
        if(k == 1) return min(nums1[i],nums2[j]);
        int si = min(i+k/2,int(nums1.size())), sj = j+k/2;
        if(nums1[si-1]>nums2[sj-1])
            return findKthNumber(nums1,i,nums2,j+k/2,k-k/2);
        else
            return findKthNumber(nums1,si,nums2,j,k-(si-i));
    }
};

//方法二：
class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int N1 = nums1.size();
        int N2 = nums2.size();
        if(N1<N2) return findMedianSortedArrays(nums2,nums1);

        int lo = 0, hi = N2*2;
        while(lo<=hi)
        {
            int mid2 = (lo+hi)/2;
            int mid1 = N1+N2 - mid2;

            double L1 = (mid1 == 0) ? INT_MIN : nums1[(mid1-1)/2];
            double L2 = (mid2 == 0) ? INT_MIN : nums2[(mid2-1)/2];
            double R1 = (mid1 == N1*2) ? INT_MAX : nums1[(mid1)/2];
            double R2 = (mid2 == N2*2) ? INT_MAX : nums2[(mid2)/2];

            if(L1>R2) lo = mid2+1;
            else if(L2>R1) hi = mid2 - 1;
            else return (max(L1,L2)+min(R1,R2)) / 2; 
        }
        return -1;
    }
};

LeetCode 5. 最长回文子串

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++;
            if(res.size()<r-l-1) res = s.substr(l+1,r-l-1);
        }
        return res;
    }
};

LeetCode 6. Z 字形变换

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

LeetCode 7. 整数反转

class Solution {
public:
    int reverse(int x) {
        int res = 0;
        while (x) {
            if (x > 0 && res > (INT_MAX - x % 10) / 10) return 0;
            if (x < 0 && res < (INT_MIN - x % 10) / 10) return 0;
            res = res * 10 + x % 10;
            x /= 10;
        }
        return res;
    }
};

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

class Solution {
public:
    int myAtoi(string s) {
        int k = 0;
        while(k<s.size()&&s[k] == ' ') k++;
        if(k == s.size()) return 0;

        int minus = 1;
        if(s[k]=='-') minus = -1,k++;
        else if(s[k]=='+') k++;

        int res = 0;
        while(k<s.size()&&isdigit(s[k]))
        {
            int x = s[k]-'0';
            if(minus>0&&res>(INT_MAX-x)/10) return INT_MAX;
            if(minus<0&&-res<(INT_MIN+x)/10) return INT_MIN;
            if(-res*10-x == INT_MIN) return INT_MIN;
            res = res*10+x;
            k++;
        }

        res*=minus;
        return res;
    }
};

LeetCode 9. 回文数

class Solution {
public:
    bool isPalindrome(int x) {
        if(x<0) return false;
        string s = to_string(x);
        return s==string(s.rbegin(),s.rend());
    }
};

LeetCode 10. 正则表达式匹配

class Solution {
public:
    bool isMatch(string s, string p) {
        int n = s.size(), m = p.size();
        s = ' ' + s, p = ' ' + p;
        vector<vector<bool>> f(n + 1, vector<bool>(m + 1));
        f[0][0] = true;
        for (int i = 0; i <= n; i ++ )
            for (int j = 1; j <= m; j ++ ) {
                if (j + 1 <= m && p[j + 1] == '*') continue;
                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];
    }
};