NO.1

思路：因为存的字符串高位存放的是低下标，所以输出的字符串必须先翻转。

代码实现：

class Solution {
public:
    string solve(string s, string t) {
       string ret;
       int i=s.size()-1,j=t.size()-1;
       int tmp=0;
       while(i>=0||j>=0||tmp)
       {
        if(i>=0) tmp+=s[i--]-'0';
        if(j>=0) tmp+=t[j--]-'0';
        ret+=tmp%10+'0';
        tmp/=10;
       }

       reverse(ret.begin(),ret.end());
       return ret;
    }
};

NO.2

代码实现：先实现逆序，逆序里面先定义一个头结点，将链表的节点依次头插。实现的时候，将逆序后的链表节点的值依次相加，加起来的值依次赋给新节点的val。

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head1 ListNode类 
     * @param head2 ListNode类 
     * @return ListNode类
     */
    ListNode* reverse(ListNode* head)
    {
      ListNode* newHead=new ListNode(0);
      ListNode* cur=head;
      while(cur)
      {
        ListNode* next=cur->next;
        cur->next=newHead->next;
        newHead->next=cur;
        cur=next;
      }
      cur=newHead->next;
      delete newHead;
      return cur;
    }
    ListNode* addInList(ListNode* head1, ListNode* head2) {
       head1=reverse(head1);
       head2=reverse(head2);
       int t=0;
       ListNode* cur1=head1,*cur2=head2;
       ListNode* ret=new ListNode(0);
       ListNode* prev=ret;
       while(cur1||cur2||t)
       {
        if(cur1)
        {
         t+=cur1->val;
         cur1=cur1->next;
        }
        if(cur2)
        {
            t+=cur2->val;
            cur2=cur2->next;
        }
        prev=prev->next=new ListNode(t%10);
        t/=10;
       }
       cur1=ret->next;
       ret->next=nullptr;
       delete ret;
       return reverse(cur1);
    }
};

NO.3

思路：先进行无进位相乘相加，在将得到数据存放到一个容器里面，相乘之后相加得到的数据的下标是两个元素的下标和。后面进行进位处理，但是我们到后面得多进行一次进位处理，因为最后一个元素相加也要进位，最后一步是取出前导0。

代码实现：

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param s string字符串 第一个整数
     * @param t string字符串 第二个整数
     * @return string字符串
     */
 string solve(string s, string t) {
 reverse(s.begin(), s.end());
 reverse(t.begin(), t.end());
 int m = s.size(), n = t.size();
 vector<int> tmp(m + n);
 // 1. ⽆进位相乘相加
 for(int i = 0; i < m; i++)
 {
 for(int j = 0; j < n; j++)
 {
 tmp[i + j] += (s[i] - '0') * (t[j] - '0');
 }
 }
 // 2. 处理进位
 int c = 0;
 string ret;
 for(auto x : tmp)
 {
 c += x;
 ret += c % 10 + '0';
 c /= 10;
 }
 while(c)
 {
 ret += c % 10 + '0';
 c /= 10;
 }
 // 3. 处理前导零
 while(ret.size() > 1 && ret.back() == '0') ret.pop_back();
 
 reverse(ret.begin(), ret.end());
 return ret;
 }
    
};