leetecode——add two numbers

原题目连接  https://leetcode.com/problems/add-two-numbers/

You are given two linked lists representing two non-negative numbers. 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.

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

        在解这道题目之前，先来复习一下关于链表的操作。链表中每一个元素称为“结点”，每个结点都应包括两个部分：一个是数据域保存用户需要用的实际数据，二是指针域存放下一个结点的地址。对链 表的操作 包括单向链表的创建、删除、  插入（无序、有序）、输出、  排序（选择、插入、冒泡）、反序等等。

        1.   创建n个节点的链表的函数为：

struct student  
{  
    int num;              //学号   
    float score;          //分数，其他信息可以继续在下面增加字段  
    struct student *next;       //指向下一节点的指针  
};  
  
int n;  //节点总数   
/* 
========================== 
功能：创建n个节点的链表 
返回：指向链表表头的指针 
========================== 
*/  
struct student *Create()  
{  
    struct student *head;       //头节点  
    struct student *p1 = NULL;  //p1保存创建的新节点的地址  
    struct student *p2 = NULL;  //p2保存原链表最后一个节点的地址  
  
    n = 0;          //创建前链表的节点总数为0：空链表  
    p1 = (struct student *) malloc (LEN);   //开辟一个新节点  
    p2 = p1;            //如果节点开辟成功，则p2先把它的指针保存下来以备后用  
  
    if(p1==NULL)        //节点开辟不成功  
    {  
        printf ("\nCann't create it, try it again in a moment!\n");  
        return NULL;  
    }  
    else                //节点开辟成功  
    {  
        head = NULL;        //开始head指向NULL  
        printf ("Please input %d node -- num,score: ", n + 1);  
        scanf ("%d %f", &(p1->num), &(p1->score));    //录入数据  
    }  
    while(p1->num != 0)      //只要学号不为0，就继续录入下一个节点  
    {  
        n += 1;         //节点总数增加1个  
        if(n == 1)      //如果节点总数是1，则head指向刚创建的节点p1  
        {  
            head = p1;  
            p2->next = NULL;  //此时的p2就是p1,也就是p1->next指向NULL。  
        }  
        else  
        {  
            p2->next = p1;   //指向上次下面刚刚开辟的新节点  
        }  
  
        p2 = p1;            //把p1的地址给p2保留，然后p1产生新的节点  
  
        p1 = (struct student *) malloc (LEN);  
        printf ("Please input %d node -- num,score: ", n + 1);  
        scanf ("%d %f", &(p1->num), &(p1->score));  
    }  
    p2->next = NULL;     //此句就是根据单向链表的最后一个节点要指向NULL  
  
    free(p1);           //p1->num为0的时候跳出了while循环，并且释放p1  
    p1 = NULL;          //特别不要忘记把释放的变量清空置为NULL,否则就变成"野指针"，即地址不确定的指针  
    return head;        //返回创建链表的头指针   
}  

 

           其他操作可以参考这篇博客：http://blog.csdn.net/hackbuteer1/article/details/6591486/  讲的很详细。在进行链表操作时，要注意保存一个指向链表头结点的指针， 还有遍历时保存当前位置的指针，还有待处理的目标节点的指针。

          这道题的难点其实就是在单链表的使用上，逻辑很清楚，主要需要注意一下三点：

            1.当两个序列长度不一样时，需要单独处理；

            2.当最后一位加完有进位时，需要单独开一个节点保存进位

            3.当一个序列为空时，直接返回另一个序列

         源代码如下：

/**
 * 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) {  
        // IMPORTANT: Please reset any member data you declared, as  
        // the same Solution instance will be reused for each test case.  
          
        if (l1 == NULL) return l2;  
        if (l2 == NULL) return l1;  
  
        ListNode *resList = NULL, *pNode = NULL, *pNext = NULL;  
        ListNode *p = l1, *q = l2;  
        int up = 0;  
        while(p != NULL && q != NULL)  
        {  
            pNext = new ListNode(p->val + q->val + up);  
            up = pNext->val / 10;    //计算进位  
            pNext->val = pNext->val % 10;   //计算该位的数字  
              
            if (resList == NULL)  //头结点为空  
            {  
                resList = pNode = pNext;  
            }  
            else //头结点不为空  
            {  
                pNode->next = pNext;  
                pNode = pNext;  
            }  
            p = p->next;  
            q = q->next;  
        }  
  
        //处理链表l1剩余的高位  
        while (p != NULL)  
        {  
            pNext = new ListNode(p->val + up);  
            up = pNext->val / 10;      
            pNext->val = pNext->val % 10;  
            pNode->next = pNext;  
            pNode = pNext;  
            p = p->next;  
        }  
  
        //处理链表l2剩余的高位  
        while (q != NULL)  
        {  
            pNext = new ListNode(q->val + up);  
            up = pNext->val / 10;      
            pNext->val = pNext->val % 10;  
            pNode->next = pNext;  
            pNode = pNext;  
            q = q->next;  
        }  
  
        //如果有最高处的进位，需要增加结点存储  
        if (up > 0)  
        {  
            pNext = new ListNode(up);  
            pNode->next = pNext;  
        }  
  
        return resList;  
    }  
  
};