leetcode2-两数相加

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

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

class Solution:
    def addTwoNumbers(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        # 遍历2个链表
        d_l1 = self.get_data(l1)
        d_l2 = self.get_data(l2)
        
        num_1 = int(''.join(d_l1))
        num_2 = int(''.join(d_l2))
        total = num_1 + num_2
        res = list(str(total))
        res.reverse()
        
        rest = self.create_list_node(res)
        return rest
     
    def create_list_node(self, alist):
        nodes = []
        for i in alist:
            nodes.append(ListNode(int(i)))
        
        for i, item in enumerate(nodes):
            if i+1 <= len(nodes) - 1:
                item.next = nodes[i+1]
        return nodes[0]
      
    def get_data(self, l):
        data = []
        node = l
        data.append(str(node.val))
        while node.next is not None:
            node = node.next
            data.append(str(node.val))
        data.reverse()
        return data

基本思想是: 遍历2个链表，得到2个数，求和，然后再把和的数字存储在单链表中，时间复杂度比较高，不是很好的算法

改进后的算法：

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

class Solution:
    def addTwoNumbers(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        # 遍历2个链表
        d_l1 = self.get_data(l1)
        d_l2 = self.get_data(l2)
        
        num_l1 = len(d_l1)
        num_l2 = len(d_l2)
        total = min(num_l1, num_l2)
        nodes = []
        is_flag = False
        for i in range(total):
            if is_flag:
                n_data = d_l1[i] + d_l2[i]+1
            else:
                n_data = d_l1[i] + d_l2[i]
                
            if n_data >= 10:
                is_flag = True
                n_data = n_data % 10
            else:
                is_flag = False
                
            node = ListNode(n_data)
            nodes.append(node)
        
        if num_l1 == num_l2:
            if is_flag:
                node = ListNode(1)
                nodes.append(node)
            
        elif num_l1 > total:
            is_flag = self.get_last_nodes(total, num_l1, d_l1,is_flag, nodes)
            if is_flag:
                node = ListNode(1)
                nodes.append(node)
                
        elif num_l2 > total:
            is_flag = self.get_last_nodes(total, num_l2, d_l2, is_flag, nodes)
            
            if is_flag:
                node = ListNode(1)
                nodes.append(node)
                
            
        rest = self.create_list_node(nodes)
        return rest
     
    def create_list_node(self, nodes):
        for i, item in enumerate(nodes):
            if i+1 <= len(nodes) - 1:
                item.next = nodes[i+1]
        return nodes[0]
    
    def get_last_nodes(self, begin, end, alist, is_flag, nodes):
        for j in range(begin, end):
            if is_flag:
                n_data = alist[j] + 1
            else:
                n_data = alist[j]
            if n_data >= 10:
                is_flag = True
                n_data = n_data % 10
            else:
                is_flag = False
            node = ListNode(n_data)
            nodes.append(node)
        return is_flag
        
    def get_data(self, l):
        data = []
        node = l
        data.append(node.val)
        while node.next is not None:
            node = node.next
            data.append(node.val)
        return data