LeetCode 1-10代码参考

1.Two Sum
思路：见solution

 vector<int> twoSum(vector<int>& nums, int target) {
        for (int i = 0;i < nums.size(); i++) {
            for (int j = i + 1; j < nums.size(); j++) {
                if (nums[i] + nums[j] == target) 
                    return {i,j};
            }
        }
        return {};
    }

 vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> mp;
        for (int i = 0; i < nums.size(); i++) {
            mp[nums[i]]= i;
        }
        for (int i = 0; i < nums.size(); i++) {
            if (mp.find(target-nums[i]) != mp.end() && mp[target-nums[i]] != i)
                return {i,mp[target-nums[i]]};
        }
        return {};
    }

 vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> mp;
        for (int i = 0; i < nums.size(); i++) {

            if (mp.find(target-nums[i]) != mp.end() && mp[target-nums[i]] != i)
                return {i,mp[target-nums[i]]};
            mp[nums[i]] = i;//放到前面就不对
        }
        return {};
    }

2.Add Two Numbers
思路：a1设为l1的val,a2设为l2的val，carry为进位（0或1），sum设为a1+a2+carry。更新carry = sum / 10,新listnode->val = sum % 10;创建新节点next，并将temp->next;进行下一个循环。
小技巧：val/10和val%10在很多程序中都会用到，但是这是很耗费资源的，比较好的方法是：val>10,temp = val - 10, carry = 1;因为在一位数加减法中，最大是9+9，然后加上进位的1，9+9+1 = 19<20,所以carry=1。

ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        int carry = 0;
        ListNode l3(0),*temp = &l3;
        int a1,a2,sum;
        while (l1 || l2 || carry) {
            a1 = l1 ? l1->val : 0;
            a2 = l2 ? l2->val : 0;
            sum = a1 + a2 + carry;
            carry = sum / 10;
            temp->next = new ListNode(sum % 10);
            temp = temp->next;
            l1 = l1 ? l1->next : NULL;
            l2 = l2 ? l2->next : NULL;
        }
        return l3.next;
    }

3 Longest Substring Without Repeating Characters

int lengthOfLongestSubstring(string s) {
        int ans = 0,start = -1;
        vector<int> dict(256,-1);
        for (int i = 0; i < s.size(); i++) {
            if (dict[s[i]] > start)
                start = dict[s[i]];
            dict[s[i]] = i;
            ans = max(ans,i - start);
        }
        return ans;
    }

5.Longest Palindromic Substring这里写链接内容
思路1：动态规划

string longestPalindrome(string s) {
        int n = s.size();
        string temp ;
        if (n < 2) return s;
        vector<vector<bool>> dp(n,vector<bool>(n,false));
        //int maxPali = 0;
        for (int i = n - 1; i >= 0; i--) {
            for (int j = i; j < n; j++) {
                dp[i][j] = (s[i] == s[j] && ( j - i <= 2 || dp[i+1][j-1]));
                if (dp[i][j] && (j - i + 1) > temp.size()) {
                    temp = s.substr(i,j + 1 - i);
                }

            }
        }
        return temp;
    }

思路2：确定回文字符串中心字符，向两边扩散比较。

 string longestPalindrome(string s) {
        string temp = "";
        int size = s.size();
        string temp1,temp2;
        int maxLength = 0;
        int maxTemp;
        for (int i = 0; i < size; i++) {
            temp1 = helper(s,i,i);
            temp2 = helper(s,i,i+1);
            maxTemp = max(temp1.size(),temp2.size());
            if (maxTemp > maxLength) {
                maxLength = maxTemp;
                temp = temp1.size() > temp2.size() ? temp1:temp2;
            }
        }
        return temp;

    }
    string helper(string s,int left,int right) {
        string temp = "";
        int size = s.size();
        while(left >= 0 && right <= size && s[left] == s[right]) {
            temp = s.substr(left,right + 1 - left);
            left--;
            right++;
        }
        return temp;
    }

6.ZigZag Conversion
思路：就按照这个规则，遇到一个数，判断在第几行，然后加在当行string后面。

string convert(string s, int numRows) {
        if (s.size() < numRows || numRows < 2) return s;
        string res;
        vector<string> temp(numRows,"");
        int size = s.size();
        int group = numRows * 2 - 2;
        //bool flag = true;
        int row;
        for (int i = 0; i < size; i++) {
            row = i % group;
            if (row >= numRows)
                row = group - row;
            temp[row].push_back(s[i]);
        }

        for (auto str : temp)
            res.append(str);

        return res;
    }

7.Reverse Integer
思路1：主要问题是防止越界，所以我们把ans设为long long型，那么他就是64位，然后得到的结果和int最大值和最小值比较。

 int reverse(int x) {
        long long ans = 0;
        while (x) {
            ans = ans * 10 + x % 10;
            x /= 10;
        }
        return ans > INT_MIN && ans < INT_MAX ? ans : 0;
    }

思路2：这次ans设为int型，但是如果越界后，ans/10 !=原结果

 int reverse(int x) {
        int ans = 0;
        int temp = 0;
        while (x) {
            temp = ans * 10 + x % 10;
            if (temp/10 != ans)
                return 0;
            ans = temp;
            x /= 10;
        }
        return ans;
    }

9 Palindrome Number
思路：首先，x是负数并且是10的倍数一定不是回文数；然后不需要把整个数都反转，只需要反转一半数字，当然分为偶数个反转和奇数个反转，如果x是有偶数个数字（如12344321），反转一半以后就是1234和1234比较；如果x是奇数个数字（如1234321），反转一半就是1234/10和123比较.

 bool isPalindrome(int x) {
        if (x < 0 || (x % 10 == 0 && x != 0))
            return false;
        int ans = 0;
        while (x > ans) {
            ans = ans * 10 + x % 10;
            x /= 10;
        }
        return x == ans || x == ans / 10;
    }

8.String to Integer (atoi)
思路：首先找到第一个非空格字符，然后判断第一个+-号，然后遍历剩下的数字字符（遇到第一个非数字字符，停止遍历）。

 int myAtoi(string str) {
        if (str.empty()) return 0;
        int i = 0,flag = 1;
        long res = 0;
        while (isspace(str[i])) {
            i++;
        }
        if (str[i] == '-' || str[i] == '+') {
            flag = str[i++] == '-' ? -1 : 1;
        }
        while(isdigit(str[i])) {
            res = res * 10 + str[i++] - '0';
            if (res > INT_MAX) return flag == 1 ? INT_MAX : INT_MIN;
        }
        return res * flag;

    }