python 刷 leetcode 题目（31）

2. 两数相加

给定两个非空链表来表示两个非负整数。位数按照逆序方式存储，它们的每个节点只存储单个数字。将两数相加返回一个新的链表。

你可以假设除了数字 0 之外，这两个数字都不会以零开头。

示例：

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

思路：主要三种细节，进位情况，第二个是两个链表不等长的情况，第三就是最后一位在是否进位的情况。

代码：

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

class Solution1(object):
    def addTwoNumbers(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        tail = ListNode(0)
        if l1 is None:
            return l2
        if l2 is None:
            return l1
        head = tail
        flag = 0 #### 表示是否进位
        while l1 != None and l2 != None:
            sum = l1.val + l2.val + flag
            flag = sum // 10
            tail.next = ListNode(sum % 10)  #### 进位之后还剩下的值作为下一个节点的值
            tail = tail.next
            l1 = l1.next
            l2 = l2.next

        #### 考虑两个链表不等长的情况
        if l1 == None:
            l1 = l2
        while l1 != None:
            sum = l1.val + flag
            flag = sum // 10
            tail.next = ListNode(sum % 10)
            tail = tail.next
            l1 = l1.next

        ####  考虑最后一位是否为零的情况
        if flag != 0:
            tail.next = ListNode(flag)
            tail = tail.next
        tail.next = None
        return  head.next

l1 = ListNode(2)
l2 = ListNode(4)
l3 = ListNode(3)
l1.next =l2
l2.next =l3
l4 = ListNode(7)
l5 = ListNode(0)
l6 = ListNode(8)
l4.next = l5
l5.next = l6

328. 奇偶链表

给定两个非空链表来表示两个非负整数。位数按照逆序方式存储，它们的每个节点只存储单个数字。将两数相加返回一个新的链表。

你可以假设除了数字 0 之外，这两个数字都不会以零开头。

示例：

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

给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。

请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1)，时间复杂度应为 O(nodes)，nodes 为节点总数。

示例 1:

输入: 1->2->3->4->5->NULL
输出: 1->3->5->2->4->NULL

示例 2:

输入: 2->1->3->5->6->4->7->NULL 
输出: 2->3->6->7->1->5->4->NULL

说明:

• 应当保持奇数节点和偶数节点的相对顺序。
• 链表的第一个节点视为奇数节点，第二个节点视为偶数节点，以此类推。

思路：其实就注意一点： odd.next = odd.next.next  和 even.next = even.next.next.

代码如下;

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

class Solution(object):
    def oddEvenList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        ####  the first method 
        if head is None:
            return None
        odd = odd_head = head
        even = even_head = head.next
        while even and even.next:
            odd.next = odd.next.next
            odd = odd.next
            even.next = even.next.next
            even = even.next
        odd.next = even_head
        return odd_head
        
        
        #### the second  method 
#         if head is None:
#             return None
#         odd = odd_head = head
#         even = even_head = head.next
#         while even and even.next:
#             odd.next = even.next
#             odd = odd.next
#             even.next = odd.next
#             even = even.next
       
#         odd.next = even_head
#         return odd_head