代码随想录算法训练营第三天 |203.移除链表元素、 707.设计链表 、206.反转链表

203.移除链表元素

要点：移除头结点和移除其他节点的操作是不一样的，因为链表的其他节点都是通过前一个节点来移除当前节点，而头结点没有前一个节点，所以引入一个虚拟头节点

注意有一个节点的更新是需要分情况讨论的

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummy_head = ListNode(next  = head)
        ###以什么变量来进行遍历
        cur = head
        pre = dummy_head
        while cur != None:
            if cur.val == val:
                pre.next = cur.next
            else:#如果不是要删除的那么pre就往前走一个
                pre = pre.next     
              #这个怎么找？pre 不可以等于cur，因为cur可能已经被删除了,pre有可能不变的
            cur = cur.next
        return dummy_head.next

707.设计链表

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

    def __init__(self):
        self.dummy_head = ListNode()
        self.size = 0
    def get(self,index):
        #下标从0开始
        cur  = self.dummy_head.next
        if index < 0 or index >= self.size:
            return -1
        else:
            for i in range(index):
                cur = cur.next
        return cur.val
    def addAtHead(self,val):
        #使得新节点成为头节点
        head = ListNode(val = val,next = self.dummy_head.next)
        self.dummy_head.next = head
        self.size = self.size+ 1
        return self.dummy_head.next
    def addAtTail(self,val):
        #到链表中作为链表的最后一个元素。
        last = ListNode(val = val,next = None)
        #首先要找到原始链表的最后一个元素
        cur =  self.dummy_head
        while cur.next != None:
            cur = cur.next
        cur.next = last
        self.size = self.size+ 1
        return self.dummy_head.next
    def addAtIndex(self,index,val):
        #首先要找到index的位置，如果index是0那么就是头节点，如果index是1，那么就是第二个节点

        if index == self.size:
            return self.addAtTail(val)
        elif index > self.size:
            return self.dummy_head.next
        else:
            cur = self.dummy_head
            self.size = self.size + 1
            for i in range(index):
                cur = cur.next

            cur.next = ListNode(val = val,next = cur.next)
            return self.dummy_head
    def deleteAtIndex(self,index):
                
        if index >= self.size or index < 0 :
            return -1
        else:
            cur = self.dummy_head
            self.size = self.size - 1
            for i in range(index):
                cur = cur.next

            cur.next = cur.next.next
            return self.dummy_head

技巧：在对循环进行设计的时候，如果不确定初始元素应该是虚拟头节点还是真实头节点，那么假设要处理的是头节点，带入进去试试，注意链表的下标也是从0开始的

206.反转链表 

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if ( head == None or head.next == None):
            return head
        else:
            pre = None
            cur = head
            while cur != None:
                last = cur.next
                cur.next = pre
                pre = cur 
                cur = last
            return pre  #现在head是最后一个元素了，不是新链表的头节点,pre才是头节点

注意循环终止条件，不确定的话就带入试试，如果cur等于None了，那么说明，最后一次循环中已经翻转完了所有的元素，并且头节点是pre