leetcode-罗马数字转整数/合并2个有序链表/回文数

一 罗马数字转整数

题目链接：https://leetcode-cn.com/problems/roman-to-integer/

这一题目关键是理解题意！！！

题目中说了，罗马数字中小的数字一般放在大的数字后面，但有特殊情况，是有且只有6种：IV/IX  XL/XC  CD/CM

所以不存在IL解释为150这种说法，因为这种组合根！本！不！合！法！

所以可以搞一个map先存储所有字符到数字的映射，然后从头到尾遍历字符串，如果左边的字符比右边的字符代表的数值小，就让结果加上这2个数之差，然后去遍历之后的，否则加上当前的字符即可。特别注意结尾字符是否被算进去了。

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

二 合并2个有序链表

 题目链接：https://leetcode-cn.com/problems/merge-two-sorted-lists/

自力更生1

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1==NULL&&l2==NULL)
            return NULL;
        if(l1==NULL)
            return l2;
        if(l2==NULL)
            return l1;
        ListNode *head;
        if(l1->val<=l2->val)
        {
            head=l1;
            l1=l1->next;
        }
        else
        {
            head=l2;
            l2=l2->next;
        }
        ListNode *cur=head;
        while(l1&&l2)
        {
            if(l1->val<=l2->val)
            {
                cur->next=l1;
                cur=cur->next;
                l1=l1->next;
            }
            else
            {
                cur->next=l2;
                cur=cur->next;
                l2=l2->next;
            }
        }
        if(l1)
            cur->next=l1;
        else if(l2)
            cur->next=l2;
        else
            cur->next=NULL;
        return head;
    }
};

自力更生2

递归调用

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1==NULL)
            return l2;
        if(l2==NULL)
            return l1;
        if(l1->val<=l2->val)
        {
            l1->next=mergeTwoLists(l1->next,l2);
            return l1;
        }
        else
        {
            l2->next=mergeTwoLists(l1,l2->next);
            return l2;
        }        
    }
};

三 回文数

题目链接：https://leetcode-cn.com/problems/palindrome-number/

自力更生

很容易想到的思路，就是转换为字符串的想法

class Solution {
public:
    bool isPalindrome(int x) {
        if(x<0||(x%10==0&&x!=0))
            return false;
        string str="";
        while(x)
        {
            str+=x%10+'0';
            x/=10;
        }
        int i,j;
        for(i=0,j=str.size()-1;i<j;i++,j--)
        {
            if(str[i]!=str[j])
                return false;
        }
        return true;
    }
};

首先判断是不是负数（负数直接返回false），再判断当个位数为0的时候这个数本身是不是0（如果不是0，譬如100，则肯定不是回文数），然后转换为字符串，双指针法比较即可。

不转换为字符串

class Solution {
public:
    bool isPalindrome(int x) {
        if(x<0)
            return false;
        else if(x==0)
            return true;
        else
        {
            int param=x;
            int pop=0;
            long long rec=0;
            while(param)
            {
                pop=param%10;
                param/=10;
                rec=rec*10+pop;
                if(rec>INT_MAX||rec<INT_MIN)
                    return false;      
            }
            return (x==rec);
        }
    }
};

建立一个变量，存储把这个数字反过来的数值（注意可能会溢出，要判断，溢出就直接判断不是回文数），如果这个数值和原数值一样，就是回文数。

借鉴他人

把数字的前一半和后一半对比看是不是一样就好了

譬如12344321，1234=1234    再譬如12321   12=12

class Solution {
public:
    bool isPalindrome(int x) {
        if(x<0||(x%10==0&&x!=0))
            return false;
        int halfnum=0;
        while(x>halfnum)
        {
            halfnum=halfnum*10+x%10;
            x/=10;
        }
        
        if(halfnum==x||(x==halfnum/10))
            return true;
        else
            return false;
    }
};

首先判断x是否为负或是否末位数是0但这个数本身不是0，属于这2种情况都直接返回false

然后开始改变halfnum的值，直到x<=halfnum，这是已经处理完至少一半的数字

如果x==halfnum，譬如123321中的123=123，返回true

如果x<halfnum的值，譬如1234321中的123<1234,如果123==1234/10，返回true。