LeetCode：链表（1）

LeetCode：链表（1）

剑指offer 06.从头到尾打印链表

思路1：使用栈的概念

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

class Solution:
    def reversePrint(self, head: ListNode) -> List[int]:
        lst = []
        while head:
            lst.insert(0,head.val)
            head=head.next
        return lst

运行时间较高；经过分析发现insert时间复杂度O(n)
改进

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

class Solution:
    def reversePrint(self, head: ListNode) -> List[int]:
        lst = []
        while head:
            lst.append(head.val)
            head=head.next
        return lst[::-1]

有明显改善

方法2：递归法

• 1.递推阶段： 每次传入 head.next ，以 head == None（即走过链表尾部节点）为递归终止条件，此时返回空列表 [] 。
• 2.回溯阶段： 利用 Python 语言特性，递归回溯时每次返回 当前 list + 当前节点值 [head.val] ，即可实现节点的倒序输出。

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

class Solution:
    def reversePrint(self, head: ListNode) -> List[int]:
        return self.reversePrint(head.next) + [head.val] if head else []

剑指offer 18.删除链表的节点

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def deleteNode(self, head: ListNode, val: int) -> ListNode:
        
        prevNode = head
        res = prevNode
        if head.val == val:
            prevNode = head.next
            return prevNode
        else:
            while head:
                if head.val == val:
                    prevNode.next = head.next
                    return res
                prevNode = head
                head = head.next

83.删除排序链表中的重复元素

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def deleteDuplicates(self, head: ListNode) -> ListNode:
        if head == None or head.next == None:
            return head
        else:
            pre,node = head,head.next
            res = pre
            while node:
                if node.val == pre.val:
                    node = node.next
                    if node == None:
                        pre.next = node
                else:
                    pre.next = node
                    pre=pre.next
                    node =node.next
        return res

改进（思路没变）

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def deleteDuplicates(self, head: ListNode) -> ListNode:
        if  not head:
            return head
        pre,node = head,head.next
        while node:
            if node.val == pre.val:
                node = node.next
                if node == None:
                    pre.next = node
            else:
                pre.next = node
                pre=pre.next
                node =node.next
        return head

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def deleteDuplicates(self, head: ListNode) -> ListNode:
        if not head: return None
        prev,cur = head,head.next
        while cur:
            if prev.val==cur.val:
                prev.next = cur.next
            else:
                prev=cur
            cur=cur.next
        return head

141.环形链表

快慢指针

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

class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        fast,show = head,head
        while fast and fast.next:
            fast = fast.next.next
            show=show.next
            if fast is show:
                return True
        return False

思路2：递归标记法

class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        if head is None:
            return False
        if head.val == '0':
            return True
        head.val = '0'
        return self.hasCycle(head.next)

思路3：字典模拟hash查找
dict.get(key, default=None)

• key – 字典中要查找的键。
• default – 如果指定键的值不存在时，返回该默认值。默认为None

class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        dic = {}
        node = head
        while node:
            if dic.get(node)!=None:#如果不存在get返回的是0
                return True
            else:
                dic[node] = 1
            node = node.next
        return False