**2. Add Two Numbers **
You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 0 -> 8

class Solution {
public:
    ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
        if(l1==NULL)
            return l2;
        if(l2==NULL)
            return l1;
        ListNode* result;
        ListNode* newhead = new ListNode(-1);
        result = newhead;
        int carry = 0;
        while(l1!=NULL||l2!=NULL)
        {
            int sum = 0;
            int a = 0;
            int b = 0;
            if(l1!=NULL)
            {
                a = l1->val;
                l1 = l1->next;    
            }
            if(l2!=NULL)
            {
                b = l2->val;
                l2 = l2->next;
            }
            sum = (a + b + carry)%10;
            carry = (a + b + carry)/10;

            result->next = new ListNode(sum);  //若写成result = new ListNode(sum)，则链表连不起来,
                                               //创建链表的时候一定要确定下一个节点result->next的指向
            result = result->next;              
        }
        if(carry!=0)
        {
            result->next = new ListNode(carry);
            result = result->next;
        }
        result = NULL;
        return newhead->next;
    }
};

**67. Add Binary **

Given two binary strings, return their sum (also a binary string).
For example,
a = "11"
b = "1"
Return "100".

class Solution {
public:
    string addBinary(string a, string b) {
        vector<int> rec1;
        vector<int> rec2;
        vector<int> result;
        int m = a.size();
        int n = b.size();
        for(int i=m-1;i>=0;i--)
          rec1.push_back(a[i]-'0');
        for(int i=n-1;i>=0;i--)
          rec2.push_back(b[i]-'0');
        if(m>n)
        {
            rec2.push_back(0);
            n++;
        }
        else if(m<n)
        {
            rec1.push_back(0);
            m++;
        }
        int k = 0,sum = 0,carry = 0;
        while(k<max(m,n))
        {
            sum = (rec1[k] + rec2[k] + carry)%2;
            result.push_back(sum);
            carry = (rec1[k] + rec2[k] +carry)/2;
            k++;
            
        }
        if(carry!=0)
           result.push_back(carry);
        string str;
        for(int i=result.size()-1;i>=0;i--)
        {  
           str += result[i]+ '0';
           cout<<result[i];    
        }
        return str;
    }
};

**43. Multiply Strings **
Given two non-negative integers num1 and num2 represented as strings, return the product of num1 and num2.

Note:
The length of both num1 and num2 is < 110.
Both num1 and num2 contains only digits 0-9.
Both num1 and num2 does not contain any leading zero.
You must not use any built-in BigInteger library or convert the inputs to integer directly.

class Solution {
public:
    string multiply(string num1, string num2) {
        if(num1.empty()||num2.empty())
          return "";
        if(num1=="0"||num2=="0")
          return "0";
        
        int m = num1.size();
        int n = num2.size();
        string str = "";
        reverse(num1.begin(),num1.end());
        reverse(num2.begin(),num2.end());
        
        vector<int> rec(m+n,0);
        for(int i=0;i<m;i++)
          for(int j=0;j<n;j++)
          {
              rec[i+j] += (num1[i]-'0')*(num2[j]-'0');
          }
        int carry = 0;
        for(int k=0;k<m+n;k++)
        {
            rec[k] += carry; 
            carry = rec[k]/10;
            rec[k] %= 10;
        }
        reverse(rec.begin(),rec.end());
        bool flag = false;
        for(int i=0;i<m+n;i++)
        {
           
            if(rec[i]!=0||flag)  
            {  
                str += to_string(rec[i]); 
                flag = true;
            }
        }
        return str;
    }
};

**66. Plus One **
Given a non-negative integer represented as a non-empty array of digits, plus one to the integer.
You may assume the integer do not contain any leading zero, except the number 0 itself.
The digits are stored such that the most significant digit is at the head of the list.

class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        int n = digits.size();
        for(int i=n-1;i>=0;i--)
        {
            if(digits[i]==9)
                digits[i] = 0;
            else
            {
                digits[i]++;
                return digits;
            }
        }
        if(digits[0]==0)
        {
            digits[0]=1;
            digits.push_back(0);
        }
        return digits;
    }
};