LeetCode 445 Add Two Numbers II（栈+链表）

You are given two non-empty linked lists representing two non-negative integers. The most significant digit comes first 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.

Follow up:
What if you cannot modify the input lists? In other words, reversing the lists is not allowed.

Example:

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

题目大意：给出两个非空链表，求两个链表所代表的数字之和。

解题思路：遍历每个链表，将值存入两个栈中，然后对栈顶元素操作即可。

代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
 
struct Node{
    int val;
    struct Node* next;
};
struct StackNode{
    int size;
    struct Node* top;
};
typedef struct StackNode* Stack;

void makeEmpty(Stack stk)
{
    stk->size = 0;
    stk->top = NULL;
}

Stack createStack()
{
    Stack stk = malloc(sizeof(struct StackNode));
    makeEmpty(stk);
    return stk;
}

void push(Stack stk, int x)
{
    struct Node* tmp = malloc(sizeof(struct Node));
    tmp->next = NULL;
    tmp->val = x;
    if(stk->size == 0){
        stk->top = tmp;
    }else{
        tmp->next = stk->top;
        stk->top = tmp;
    }
    stk->size++;
}

void pop(Stack stk)
{
    struct Node* tmp = stk->top;
    stk->top = tmp->next;
    stk->size--;
    free(tmp);
}

int top(Stack stk)
{
    if(stk && stk->top)
        return stk->top->val;
    return 0;
}

void destroyStack(Stack stk)
{
    while(stk->size){
        pop(stk);
    }
    free(stk);
}

void traverse(struct ListNode* list, Stack stk)
{
    while(list){
        push(stk, list->val);
        list = list->next;
    }
}

struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) {
    Stack stk1 = createStack();
    Stack stk2 = createStack();
    Stack ans  = createStack();
    
    traverse(l1, stk1);
    traverse(l2, stk2);

    int sum = 0;
    while(stk1->size || stk2->size){
        if(stk1->size){
            sum += top(stk1);
            pop(stk1);
        }
        if(stk2->size){
            sum += top(stk2);
            pop(stk2);
        }
        push(ans, sum % 10);
        sum /= 10;
    }
    if(sum) push(ans, sum);
    destroyStack(stk1);
    destroyStack(stk2);
    
    return ans->top;
}