[leetcode] Python(18)--反转链表(206)、移除链表元素(203)、奇偶链表(328)、回文链表(234)、合并两个有序链表(21)

从零开始的力扣（第十八天）~

1.反转链表

反转一个单链表。

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

进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题？
—————————————————————————————————————————

暴力反转，两次循环，时间复杂度O(n²)

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

class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if not head:
            return None
        tail = head
        while tail.next:
            tail = tail.next
        while head.next:
            cur1 = cur2 = head
            while cur1.next:
                cur2 = cur1
                cur1 = cur1.next
            cur1.next = cur2
            cur2.next = None
        return tail

神仙写法，通过python特有的多元赋值搞定循环

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

class Solution:
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        p, rev = head, None
        while p:
            rev, rev.next, p = p, rev, p.next
        return rev

2.移除链表元素

删除链表中等于给定值 val 的所有节点。

示例:

输入: 1->2->6->3->4->5->6, val = 6
输出: 1->2->3->4->5
—————————————————————————————————————————

先写出基本过程，这里我使用了双指针，再考虑特殊情况，比如头节点是val或者尾节点是val或者只有一个头节点

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

class Solution(object):
    def removeElements(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """
        cur = pre = head
        while cur:
            if cur.val == val:
                if cur == head:
                    head = head.next
                    cur = pre = head
                else:
                    cur = cur.next
                    pre.next = cur
            else:
                pre = cur
                cur = cur.next
        return head

3.奇偶链表

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

请尝试使用原地算法完成。你的算法的空间复杂度应为 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

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

使用两个指针分别代表单数节点与双数节点，最后整合

# 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
        """
        if not head:
            return None
        oddcur = head
        doublecur = doublebegincur = head.next
        while doublecur is not None and doublecur.next is not None:
            oddcur.next = doublecur.next
            oddcur = oddcur.next
            doublecur.next = oddcur.next
            doublecur = doublecur.next
        oddcur.next = doublebegincur
        return head

4.回文链表

请判断一个链表是否为回文链表。

示例 1:
输入: 1->2
输出: false

示例 2:
输入: 1->2->2->1
输出: true

进阶：
你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？
—————————————————————————————————————————

创建一个列表储存链表数值，最后判断翻转列表是否与原列表相同

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

class Solution(object):
    def isPalindrome(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        lst = []
        cur = head
        while cur:
            lst.append(cur.val)
            cur = cur.next
        return lst == lst[::-1]

5.合并两个有序链表

将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4
—————————————————————————————————————————

并不是l1之后l2之后再l1的，而是每次比较l1与l2的大小，然后再串联

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

class Solution(object):
    def mergeTwoLists(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        res = ListNode(None)
        node = res
        while l1 and l2:
            if l1.val<l2.val:
                node.next,l1 = l1,l1.next
            else:
                node.next,l2 = l2,l2.next
            node = node.next
        if l1:
            node.next = l1
        else:
            node.next = l2
        return res.next  

以上就是今日经验！