Leetcode 打卡 day3

链表

数组在定义的时候，长度就是固定的，如果想改动数组的长度，就需要重新定义一个新的数组。
链表的长度可以是不固定的，并且可以动态增删， 适合数据量不固定，频繁增删，较少查询的场景。
Python定义：

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

203.移除链表元素

设置一个虚拟头结点，这样原链表的所有节点就都能按照统一的方式进行移除。

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummy = ListNode(0)
        dummy.next = head
        cur = dummy
        while cur.next != None:
            if cur.next.val == val:
                cur.next = cur.next.next
            else:
                cur = cur.next
        return dummy.next

707.设计链表

1、首先要自己创建一个链表中的Node.
2、在链表前面创建一个虚拟指针，dummy_head, 辅助链表在结点前插入新的结点。
3、更新链表时，链表长度也要更新。
4、index的取值范围要先判定清楚。
5、并不是每个函数都需要return。

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

class MyLinkedList:
    def __init__(self):
        self.dummy_head = Node(-1)
        self.size = 0

    def get(self, index: int) -> int:
        cur = self.dummy_head.next
        if index < 0 or index > self.size - 1:
            return -1
        while index:
            index -= 1
            cur = cur.next
        return cur.val

    def addAtHead(self, val: int) -> None:
        new_node = Node(val)
        new_node.next = self.dummy_head.next
        self.dummy_head.next = new_node
        self.size += 1
        # return self.dummy_head.next

    def addAtTail(self, val: int) -> None:
        cur = self.dummy_head
        while cur.next != None:
            cur = cur.next
        new_node = Node(val)
        cur.next = new_node
        new_node.next = None
        self.size += 1
        # return self.dummy_head.next

    def addAtIndex(self, index: int, val: int) -> None:
        if index > self.size:
            return 
        new_node = Node(val)
        cur = self.dummy_head
        while (index):
            index -= 1
            cur = cur.next
        new_node.next = cur.next
        cur.next = new_node
        self.size += 1
        
    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index > self.size - 1:
            return 
        cur = self.dummy_head
        while index:
            index -= 1
            cur = cur.next
        cur.next = cur.next.next
        self.size -= 1



# Your MyLinkedList object will be instantiated and called as such:
# obj = MyLinkedList()
# param_1 = obj.get(index)
# obj.addAtHead(val)
# obj.addAtTail(val)
# obj.addAtIndex(index,val)
# obj.deleteAtIndex(index)

206.反转链表

需要辅助指针 prev
头指针指针方向改变前，先用next_head暂存之前的指针方向。
头指针与辅助指针向后移动时， 辅助指针先移动，头指针再移动。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        prev = None
        while head:
        # 改变方向
            next_head = head.next
            head.next = prev
        # 向后移动
            prev = head
            head = next_head
        return prev

递归写法：

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