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 = 0;
    struct ListNode *nh = NULL;
    long sum = 0;
    while (p != NULL && q != NULL) {
        struct ListNode *new = (struct ListNode *) malloc(sizeof(struct ListNode));
        sum = p -> val + q -> val + carry;
        if (sum >= 10) {
            sum -= 10;
            carry = 1;
        }
        else carry = 0;
        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 > 0) {
        r -> next = MAKE_NODE;
        (r -> next) -> val = 1;
        (r -> next) -> next = NULL;
        return nh;
    }
    return nh;    
}
struct ListNode *add_one(struct ListNode *h) {
    struct ListNode *p = h, *prev = NULL;

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

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

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

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

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

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

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