2. Add Two Numbers

class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
ListNode* pHead = new ListNode(0);
        ListNode* p = pHead;
        int carry = 0;
        while(l1 || l2 || carry)
        {
            int sum = (l1?l1->val:0) +(l2?l2->val:0)+carry;
            carry = sum / 10;
            p->next = new ListNode(sum%10);
            p = p->next;
            l1 = l1?l1->next:l1;
            l2 = l2?l2->next:l2;
        }
        return pHead->next;
}
};

/**

 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
/* not acception!*/
/* because overflow for long long type*/
/*
class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
long long sum1 = 0;long long sum2 = 0;long long sum = 0;
ListNode* p = reverseList(l1);
while (p)
{
sum1 = sum1 * 10 + (p->val) % 10;
p = p->next;
}
p = reverseList(l2);
while (p)
{
sum2 = sum2 * 10 + (p->val) % 10;
p = p->next;
}


sum = sum1 + sum2;
ListNode* result = new ListNode(0);
ListNode* p1 = result;

do{
ListNode* pTemp = new ListNode(sum % 10);
p1->next = pTemp;
p1 = pTemp;
sum /= 10;
} while (sum != 0);
return result->next;
}


ListNode* reverseList(ListNode* head)
{
ListNode* pre = NULL;
ListNode* p = head;
if (head == NULL) return NULL;
while (head) {
p = head->next;
head->next = pre;
pre = head;
head = p;
}
return pre;
}
};
*/
/*
Input:
[1,8]
[0]
Output:
[8,1]
Expected:
[1,8]   ????
*/
/*
class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {


ListNode* p = reverseList(l1);
ListNode* q = reverseList(l2);
ListNode* result = new ListNode(0);
ListNode* ret = result;
ListNode* temp = NULL;
int val = 0;
bool carry = false;
while (p &&q) {
val = p->val + q->val + carry;
if (val>9)
{
carry = true;
}
else {
carry = false;
}
temp = new ListNode(val % 10);
result->next = temp;
result = temp;
p = p->next;
q = q->next;
}
if (p == NULL) {
while (q)
{
val = q->val + carry;
if (val>9) {
carry = true;
}
else {
carry = false;
}
temp = new ListNode(val % 10);
result->next = temp;
q = q->next;
}
if (q == NULL & carry)
{
temp = new ListNode(1);
result->next = temp;
}
}
if (q == NULL) {
while (p)
{
val = p->val + carry;
if (val>9) {
carry = true;
}
else {
carry = false;
}
temp = new ListNode(val % 10);
result->next = temp;
p = p->next;
}
if (p == NULL & carry)
{
temp = new ListNode(1);
result->next = temp;
}
}


return (ret->next);
}


ListNode* reverseList(ListNode* head)
{
ListNode* pre = NULL;
ListNode* p = head;
if (head == NULL) return NULL;
while (head) {
p = head->next;
head->next = pre;
pre = head;
head = p;
}
return pre;
}
};
*/


/*
class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode preHead(0), *p = &preHead;
    int extra = 0;
    while (l1 || l2 || extra) {
        int sum = (l1 ? l1->val : 0) + (l2 ? l2->val : 0) + extra;
        extra = sum / 10;
        p->next = new ListNode(sum % 10);
        p = p->next;
        l1 = l1 ? l1->next : l1;
        l2 = l2 ? l2->next : l2;
    }
    return preHead.next;
    }
};
*/
/**
 * 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) {
ListNode* pHead = l1;
        ListNode* p = NULL;
int carry = 0;
int sum = 0;
while (l1 && l2)
{
sum = l1->val + l2->val + carry;
l1->val = sum % 10;
carry = sum >= 10 ? 1 : 0;
            p = l1;                         //记住l1前面的位置，为了链接。
l1 = l1->next;
l2 = l2->next;
}


if (!carry)
{
l1 = !l1 ? l2 : l1;
            p->next = l1;
}
else
{
if (!l1) l1 = l2;
            p->next = l1;
while (l1)
{
//l1->val = l1->val + carry >= 10 ? (l1->val + carry) % 10 : l1->val + carry;
//l1->val = (l1->val + carry ) % 10; // l1->val 的值已经变化，已经加上进位了。
sum = l1->val + carry;
l1->val = sum % 10;
carry = sum >= 10 ? 1 : 0;
                p = l1;
                l1 = l1->next;
}
if (carry) l1 = new ListNode(1);
            p->next = l1;


}
return pHead;
}
};
*/