Day03 链表

203. 移除链表元素

解法：设置一个虚拟头节点会使得对于head的操作变得简单

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummy_head = ListNode(-1)
        dummy_head.next = head
        cur = dummy_head
        while cur.next != None:
            if cur.next.val == val:
                cur.next = cur.next.next
            else:
                cur = cur.next
        return dummy_head.next

707. 设计链表

解法一：单链表

class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

class MyLinkedList(object):

    def __init__(self):
        self.dummy_head = Node(0) # 虚拟头节点
        self.count = 0 # 添加的节点个数

    def get(self, index):
        """
        :type index: int
        :rtype: int
        """
        if 0 <= index < self.count:
            node = self.dummy_head
            for _ in range(index+1): # 因为有虚拟头节点，所以第index实际对应第index+1
                node = node.next
            return node.val
        else:
            return -1

    def addAtHead(self, val):
        """
        :type val: int
        :rtype: None
        """
        self.addAtIndex(0, val)

    def addAtTail(self, val):
        """
        :type val: int
        :rtype: None
        """
        self.addAtIndex(self.count, val)

    def addAtIndex(self, index, val):
        """
        :type index: int
        :type val: int
        :rtype: None
        """
        if index < 0:
            index = 0
        elif index > self.count:
            return
        self.count += 1 # 更新计数器不要忘
        add_node = Node(val)
        pre_node, cur_node = None, self.dummy_head
        for _ in range(index+1): # 因为有虚拟头节点，所以第index实际对应第index+1
            pre_node, cur_node = cur_node, cur_node.next
        else:
            pre_node.next, add_node.next = add_node, cur_node


    def deleteAtIndex(self, index):
        """
        :type index: int
        :rtype: None
        """
        if 0 <= index < self.count:
            self.count -= 1 # 更新计数器不要忘
            pre_node, cur_node = None, self.dummy_head
            for _ in range(index+1): # 因为有虚拟头节点，所以第index实际对应第index+1
                pre_node, cur_node = cur_node, cur_node.next
            else:
                pre_node.next, cur_node.next = cur_node.next, None
        else:
            return

tips：for…else语句：else子句只有在循环正常结束时才会执行，如果break跳出了for，便不会执行。

解法二：双链表

class Node:
    def __init__(self, val):
        self.val = val
        self.prev = None
        self.next = None

class MyLinkedList(object):

    def __init__(self):
        self.head, self.tail = Node(0), Node(0)
        self.head.next, self.tail.prev = self.tail, self.head
        self.count = 0   # 添加的节点数

    def get_node(self, index):
        if index < self.count // 2:
            node = self.head
            for _ in range(index+1):
                node = node.next
        else:
            node = self.tail
            for _ in range(self.count-index):
                node = node.prev
        return node

    def get(self, index):
        """
        :type index: int
        :rtype: int
        """
        if 0 <= index < self.count:
            node = self.get_node(index)
            return node.val
        else:
            return -1


    def addAtHead(self, val):
        """
        :type val: int
        :rtype: None
        """
        self.addAtIndex(0, val)


    def addAtTail(self, val):
        """
        :type val: int
        :rtype: None
        """
        self.addAtIndex(self.count, val)

    def addAtIndex(self, index, val):
        """
        :type index: int
        :type val: int
        :rtype: None
        """
        if index < 0:
            index = 0
        elif index > self.count:
            return
        node = self.get_node(index)
        self.count += 1
        add_node = Node(val)
        add_node.prev, add_node.next = node.prev, node
        node.prev.next, node.prev = add_node, add_node
               

    def deleteAtIndex(self, index):
        """
        :type index: int
        :rtype: None
        """
        if 0 <= index < self.count:
            node = self.get_node(index)
            self.count -= 1
            node.prev.next, node.next.prev = node.next, node.prev

tips：一定要在get_node()方法之后更新计数器。

206. 反转链表

解法：双指针

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        slow = None
        fast = head
        while fast != None:
            tmp = fast.next
            fast.next = slow
            slow = fast
            fast = tmp
        return slow