LeetCode——Problem2:Add Two Numbers

这又过了一周了，总感觉刷这个好花时间呀。每次都一两个小时。让我不好安排时间。应该是我太菜了。对，没错，就是这样

1、题目

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.

Example:

Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)

Output: 7 -> 0 -> 8

Explanation: 342 + 465 = 807

2、Python解法

我想的是先把链表转化为数字相加，再把结果数字转化为链表

以下是我写的全部代码

 #!/usr/bin/python3
 # -*- coding: utf-8 -*-
 #@author: Albert
 #@Time: 2018/8/13

 class ListNode(object):
      def __init__(self, x):
          self.val = x
          self.next = None

 class Solution(object):
     def addTwoNumbers(self, l1, l2): #求解
         """
         :type l1: ListNode
         :type l2: ListNode
         :rtype: ListNode
         """
         number1=self.getNumber(l1)
         number2=self.getNumber(l2)
         number=number1+number2
         l=self.num2LinkedLists(number)
         return l

     def getNumber(self,l):  #将链表转化为数字
         number = 0
         item = 1
         while(item):
             number = number+l.val*item
             item=item*10
             l=l.next
             if l==None:
                 item=0
         return number
     def num2LinkedLists(self,num):  #将数字转化为链表

         value=num%10
         rest=int(num/10)
         l=ListNode(value)
         if rest!=0:
             value = rest % 10
             rest = int(rest / 10)
             l.next=ListNode(value)
             temp=l.next
             while(rest!=0):
                 value=rest%10
                 rest=int(rest/10)
                 temp.next=ListNode(value)
                 temp=temp.next
         return l

 def makeLinkedList(n):  #将一个列表数字转化为题目要求的链表，按照个位，十位，百位的顺序
     l = ListNode(n[0])
     l.next = ListNode(n[1])
     temp = l.next
     for i in n[2:]:
         temp.next = ListNode(i)
         temp = temp.next
     return l

 l1=makeLinkedList([2,4,3])
 l2=makeLinkedList([5,6,4])

 a=Solution()
 l=a.addTwoNumbers(l1,l2)
 number=a.getNumber(l)
 print(number)

接下来看大神解法

 # Definition for singly-linked list.
 # class ListNode(object):
 #     def __init__(self, x):
 #         self.val = x
 #         self.next = None

 class Solution(object):
     def addTwoNumbers(self, l1, l2):
         """
         :type l1: ListNode
         :type l2: ListNode
         :rtype: ListNode
         """
         head = l1
         carry = 0
         while 1:
             temp_sum = l1.val + l2.val + carry
             l1.val = temp_sum % 10
             carry = temp_sum // 10
             if not (l1.next and l2.next):
                 break
             l1 = l1.next
             l2 = l2.next
         if not (l1.next or l2.next):
             if carry == 1:
                 l1.next = ListNode(1)
             return head
         lr = l2 if l1.next == None else l1
         l1.next = lr.next
         while l1.next:
             l1 = l1.next
             temp_sum = l1.val + carry
             l1.val = temp_sum % 10
             carry = temp_sum // 10
         if carry == 1:
             l1.next = ListNode(1)
         return head

我第二个想到的算法是这个，就是借用小学算加法的思路。设置一个进位。

3、C语言解法

我尝试了，但是结构体的基础有点差。没有运行成功。这就直接贴大神的解法了。运行时间20ms

#define MAKE_NODE (struct ListNode *)malloc(sizeof(struct ListNode))
struct ListNode *add_one(struct ListNode *);
struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) {
    struct ListNode *p = l1, *q = l2, *r = NULL;
    int carry = ;
    struct ListNode *nh = NULL;
    long sum = ;
    while (p != NULL && q != NULL) {
        struct ListNode *new = (struct ListNode *) malloc(sizeof(struct ListNode));
        sum = p -> val + q -> val + carry;
        if (sum >= ) {
            sum -= ;
            carry = ;
        }
        else carry = ;
        new -> val = sum;
        new -> next = NULL;
        if (nh == NULL) {
            nh = new;
            r = nh;
        } else {
            r -> next = new;
            r = new;
        }
        p = p -> next;
        q = q -> next;
    }
    if (p != NULL && q == NULL) {
        if (!carry) {
         r -> next = p;
            return nh;
        }  //other we have a carry
        p = add_one(p);
        r -> next = p;
        return nh;
    }
    else if (p == NULL && q != NULL) {
        if (!carry) {
            r -> next = q;
            return nh;
        }
        q = add_one(q);
        r -> next = q;
        return nh;
    }

    if (carry > ) {
        r -> next = MAKE_NODE;
        (r -> next) -> val = ;
        (r -> next) -> next = NULL;
        return nh;
    }
    return nh;
}
struct ListNode *add_one(struct ListNode *h) {
    struct ListNode *p = h, *prev = NULL;

    int carry = ;
    while (h != NULL) {

        h -> val += carry;
        if (h -> val > ) {
            carry = ;
            h -> val -= ;
        }
        else {
            carry = ;
        }
        prev = h;
        h = h -> next;
    }
    if (carry > ) {
        struct ListNode *new = MAKE_NODE;
        new -> val = ;
        new -> next = NULL;
        prev -> next = new;
    }
    return p;
}

其中的算法都是按照加法的进位

我还是C语言基础都忘的差不多了，没有写对。

主要是这个申请内存。(struct ListNode *)malloc(sizeof(struct ListNode))

其实他这个算法稍微麻烦了点。又用了一个新的add_one函数。如果l1，l2数目不一样。直接在后面的时候还直接进位，假设另一个为0就好啦。

最近事贼多。唉~愁人。想上研的时候跨专业，需要补习的东西还有很多呀~