leetcode之旅（简单题0-50）

@TOC

两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

两遍哈希表

1. 迭代，将每个元素的值和它的索引添加到表中
2. 迭代，将检查每个元素所对应的目标元素（target - nums[i]target−nums[i]）是否存在于表中

知识点

map<int, int>：map容器，第一个类型的键类型，第二个是值类型

vector<int> twoSum(vector<int>& nums, int target)
{
	vector<int> twoSum;
	map<int, int> tmpmap;
	
	for(int i=0; i<nums.size(); i++)
	{
		tmpmap[nums[i]] = i;
	}
	for(int i = 0; i<nums.size(); i++)
	{
		//返回指定元素出现的次数
		if(tmpmap.count(target - nums[i]) !=0 && tmpmap[target - nums[i]] !=i)
		{
			twoSum.push_back(i);
			twoSum.push_back(tmpmap[target - nums[i]]);
		}
	}
	return twoSum;
}

两数相加

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头

    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
            ListNode* head = new ListNode(-1);
            ListNode* cur = head;
            int sum = 0;
            bool carry = false; 
            while(l1 != NULL || l2 != NULL){
                sum = 0;
                if(l1 != NULL){
                    sum += l1->val;
                    l1 = l1 -> next;
                }
                if(l2 != NULL){
                    sum += l2->val;
                    l2 = l2 -> next;
                }
                if(carry)
                    sum++;
                cur -> next = new ListNode(sum % 10);
                cur = cur -> next;
                carry = sum >= 10 ? true: false;

            }
            if(carry)
                cur -> next = new ListNode(1);
            return head -> next;

        
    }

无重复字符的最长子串

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

现学现用，map

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        map<char, int>dict;
        int cur = 0, max_seq = 0;
        int start = 0;
        for(int i=0; i<s.length(); i++)
        {
            map<char, int>::iterator iter;
            iter = dict.find(s[i]);
            if( iter !=dict.end() )//重复
            {
                cur = i - dict[s[i]];
                for(int j=start; j<=dict[s[i]]; j++)
                    dict.erase(s[j]);
                start = i - cur + 1;
            }
            else
            {
                cur += 1;
                
            }
            
            dict[s[i]] = i;
            if(cur > max_seq)
                max_seq = cur;
            
        }
        return max_seq;
    }
};

整数反转

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
输入: 123
输出: 321

int reverse(int x) {
    bool minus = false;
    long res;
    if(x<0)
    {
        minus = true;
    }
    string s = to_string(x);
	if(!minus)   s = s.substr(1);
    
    for(int j=0; j<s.length(); j++)
    {
        res += ( s[j] - '0' )* pow(10, j);

    }
    
    
    if(minus) res = -res;
    if( res>0x7fffffff || res<(signed int)0x80000000)
        return 0;
    else return res;
    
}

判断32位有符号整数溢出
if( num>0x7fffffff || num<(signed int)0x80000000)

字符转整数
int a = atoi(s.c_str());

整数转字符
std::to_string(i)

回文数

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

class Solution {
public:
    bool isPalindrome(int x) {
        string s = to_string(x);
        int l = s.length();
        int pos = 0;
        for(int i=0; i<l; i++)
        {
            pos = l-i-1;
            if(i<pos)
            {
                if(s[i] == s[pos])
                    continue;
                else return false;
            }
        }
        return true;
    }
};

其他思想：为了避免数字反转可能导致的溢出问题，为什么不考虑只反转 \text{int}int 数字的一半？毕竟，如果该数字是回文，其后半部分反转后应该与原始数字的前半部分相同。

例如，输入 1221，我们可以将数字“1221”的后半部分从“21”反转为“12”，并将其与前半部分“12”进行比较，因为二者相同，我们得知数字 1221 是回文。

罗马数字转整数

给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。

class Solution {
public:
    int romanToInt(string s) {
        map<char, int> numbers;
        numbers['I'] = 1;
        numbers['V'] = 5;
        numbers['X'] = 10;
        numbers['L'] = 50;
        numbers['C'] = 100;
        numbers['D'] = 500;
        numbers['M'] = 1000;
        int num = 0;
        for(int i=0; i<s.size();i++)
        {
            if(i+1<s.size() && numbers[s[i]]< numbers[s[i+1]])
                num -= numbers[s[i]];
            else  
                num += numbers[s[i]];
        }
        return num;
    }
};

执行用时: 136 ms, 在Roman to Integer的C++提交中击败了0.84% 的用户
内存消耗: 33.3 MB, 在Roman to Integer的C++提交中击败了0.33% 的用户

效果不是很好呀

最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 “”。
输入: [“flower”,“flow”,“flight”]
输出: “fl”

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        int nums = strs.size();
        int j=0, count = 0;
        char s;
        string res = "";

        if(strs.size()<&