力扣刷题6月4 两数相加

Talk is cheap，show me your code!

2. 两数相加

难度中等4412

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

第一版暴力写，但还是有bug的

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        if(nullptr == l1) return l2;
        if(nullptr == l2) return l1;
        
        if(nullptr == l1->next &&l1->val==0 )
        {
            return l2;
        } 
        if(nullptr == l2->next &&l2->val==0 )
        {
            return l1;
        } 
       
        ListNode* l11 = l1;
        ListNode* l22 = l2;

        vector<int> vl1;
        vector<int> vl2;
        int res1 = 0;
        int res2 = 0;

        int result =0;

        while(l11)
        {
            vl1.push_back(l11->val);//243
            l11=l11->next;
        }
        reverse(vl1.begin(),vl1.end());//342
        while(l22)
        {
            vl2.push_back(l22->val);//564
            l22=l22->next;
        }
        reverse(vl2.begin(),vl2.end());//456
        
        for(int i=0;i<vl1.size();i++)
        {
            res1=res1*10+vl1[i];
        }
        for(int i=0;i<vl2.size();i++)
        {
            res2=res2*10+vl2[i];
        }

        result = res1 + res2;//
        vector<int> v1;

        while(result)
        {
            v1.push_back(result%10);
            result = result/10;
        }

        ListNode* l4 = new ListNode(0);
        ListNode* p1= l4;
       
        for(int i=0;i<v1.size() ; i++)//708
        { 
            ListNode* l5 = new ListNode(v1[i]);
            p1->next=l5;
            p1=l5;
        }
        return l4->next;
    }
};

 

第二版：别人的好办法

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
    ListNode dummy (0);
    ListNode* p = &dummy;
    int sum = 0;
    while(l1 || l2 || sum)
    {
        if(l1) 
        { 
            sum += l1->val;
            l1 = l1->next;
        }
        if(l2)  
        {
            sum += l2->val;
            l2 = l2->next;
        }
        p->next = new ListNode(sum % 10);           //sum % 10为当前位的值
        p = p->next;
        sum /= 10;                              //sum/10为进位的值，并用做下一次求和的初值
    }
    return dummy.next;
    }
};

 

面试题38. 字符串的排列

难度中等46收藏分享切换为英文关注反馈

输入一个字符串，打印出该字符串中字符的所有排列。

你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。

示例:

输入：s = "abc"
输出：["abc","acb","bac","bca","cab","cba"]

限制：

1 <= s 的长度 <= 8

class Solution {
public:
    vector<string> permutation(string s)
    {
          vector<char> result;
          vector<string> res;
          string temp_str="";
          for(int i=0;i<s.size();i++)
          {
              result.push_back(s.at(i));
          }

          sort(result.begin(),result.end());//这边是防止next_permutation字典序列举的时候少元素
          
          do{
               temp_str = "";
               for(int i=0;i<s.size();i++)
               {
                   temp_str = temp_str+result[i];
               }
              res.push_back(temp_str);
          }while(next_permutation(result.begin(),result.end()));

          return res;
    }
};

 

/*next_permutation（start,end），和prev_permutation（start,end）。这两个函数作用是一样的，区别就在于前者求的是当前排列的下一个排列，后一个求的是当前排列的上一个排列。至于这里的“前一个”和“后一个”，我们可以把它理解为序列的字典序的前后*/
class Solution {
public:
    vector<string> permutation(string s) {
        if(s.empty()) return {};
        sort(s.begin(), s.end());
        vector<string> ans;
        ans.push_back(s);
        while(next_permutation(s.begin(), s.end())){
            ans.push_back(s);
        }
        return ans;
    }
};