Leetcode——初级部分——链表部分——Python实现

一. 删除链表中的节点

请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。

现有一个链表 -- head = [4,5,1,9]，它可以表示为:

4 -> 5 -> 1 -> 9

示例 1:

输入: head = [4,5,1,9], node = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.

示例 2:

输入: head = [4,5,1,9], node = 1
输出: [4,5,9]
解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.

说明:

• 链表至少包含两个节点。
• 链表中所有节点的值都是唯一的。
• 给定的节点为非末尾节点并且一定是链表中的一个有效节点。
• 不要从你的函数中返回任何结果。

我的解答：

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

class Solution:
    def deleteNode(self, node):
        """
        :type node: ListNode
        :rtype: void Do not return anything, modify node in-place instead.
        """
        node.val = node.next.val #当前值被后一个值覆盖
        node.next = node.next.next #当前结点的下一个结点是原来的下下个结点

二. 删除链表的倒数第N个节点

给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。

示例：

给定一个链表: 1->2->3->4->5, 和 n = 2.

当删除了倒数第二个节点后，链表变为 1->2->3->5.

说明：

给定的 n 保证是有效的。

进阶：

你能尝试使用一趟扫描实现吗？

我的解答：

（1）定义2个指针p1，p2。

（2）使用循环让p2指向顺数第n个节点，同时p1指向第头结点；

（3）然后，p1和p2同时移动，直到p2指向NULL，此时p1应该指向倒数第n个节点。

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

class Solution:
    def removeNthFromEnd(self, head, n):
        """
        :type head: ListNode
        :type n: int
        :rtype: ListNode
        """
        #这里head的type就是一个链表结点
        
        #链表只有一个元素的情况，需要删除这个元素
        if(head.next == None):
            return None
        else:
            p1 = head
            p2 = head
            count = 0 #这个是控制node1和node2的位置的（倒数第几个）
            while p1.next != None:
                p1 = p1.next
                if(count >= n):
                    p2 = p2.next
                count = count + 1
            #这时候第一个指针已经走到终点了，然后只需要删除第二个指针指向的结点
            #删除最后一个结点的情况
            if(n == 1):
                p2.next = None      
                return head
            #删除第一个结点的情况
            elif(n - count == 1):
                return head.next
            else:
                p2.next = p2.next.next
                return head

三. 反转链表

反转一个单链表。

示例:

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

进阶:

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

我的解答：

# 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 q r
        # 第二次   p q
        # ......
        
        if(head == None):
            return None
        else:
            p = head
            q = head.next
            p.next = None
            
            while q:
                r = q.next
                q.next = p
                p = q
                q = r
            return p

四. 合并两个有序链表

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

示例：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

我的解答：

方法1：递归方法

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

class Solution:
    def mergeTwoLists(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        #方法一：递归
        if not l1 and not l2:
            return None
        if not l1:
            return l2
        if not l2:
            return l1
        if l1.val>=l2.val:
            l2.next = self.mergeTwoLists(l1,l2.next)
            return l2
        else:
            l1.next = self.mergeTwoLists(l1.next,l2)
            return l1

方法2：非递归

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

class Solution:
    def mergeTwoLists(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        #方法2：非递归
        head = ListNode(0)
        savehead = head #保留初始链表结点索引
        if not l1 and not l2:
            return None
        else:
            while l1 and l2:
                if l1.val >= l2.val:
                    head.next = l2
                    l2 = l2.next
                else:
                    head.next = l1
                    l1 = l1.next
                head = head.next
            if l1:
                head.next = l1
            if l2:
                head.next = l2
            return savehead.next

五. 回文链表

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

示例 1:

输入: 1->2
输出: false

示例 2:

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

进阶：

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

我的解答：

方法1：将链表中的数放到一个数组中，然后进行判断

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

class Solution:
    def isPalindrome(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        #解答1：将链表中的数放到一个数组中，然后进行判断
        #完成链表——>数组
        nums = []
        while head:
            nums.append(head.val)
            head = head.next
        #判断数组是否为回文序列
        for i in range(len(nums)):
            if(nums[i] != nums[-i-1]):
                return False
        return True

方法2：快慢指针（1个走一步，1个走两步）找到中点（指针1在中点，指针2在末尾），然后将后半部分进行逆序，最后两部分进行比较看是否是回文链表 

具体实现还没写出来

六. 环形链表

给定一个链表，判断链表中是否有环。

进阶：
你能否不使用额外空间解决此题？

我的解答：

快慢指针（1个一次一格，另1个一次两格），那么如果有环的话，跑的快的一定会追满的一圈（相当于每次next，两个指针就会接近一步）。

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

class Solution(object):
    def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        #判断链表是否为空，如果为空，返回false
        if not head:
            return False
        #非空链表如下
        p1 = head
        p2 = head
        while p2.next and p2.next.next:
            p1 = p1.next
            p2 = p2.next.next
            if p1 == p2:
                return True
        return False