代码随想录算法训练营Day 03|链表Part01|203.移除链表元素 707.设计链表 206.反转链表

代码随想录算法训练营Day 03|链表Part01|203.移除链表元素 707.设计链表 206.反转链表

---

---

203.移除链表元素

题目链接

一、虚拟头节点

class Solution(object):
    def removeElements(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """
        dummyhead = ListNode(next = head)
        cur = dummyhead
        while(cur.next):      #要删的是cur.next，所以判断cur.next是否为空
            if cur.next.val == val:
                cur.next = cur.next.next
            else:
                cur= cur.next
        return dummyhead.next #如果原来的头节点被移除了

二、本题总结

掌握一下虚拟头节点的用法，注意删除操作是要找到需删除节点的上一个节点，所以cur指向dummyhead，cur.next才能指向头节点，头节点才能被删除。

---

707.设计链表

题目链接

一、单链表-虚拟头节点

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

    def __init__(self):
        self.dummyhead = ListNode()
        self.size = 0

    def get(self, index):
        """
        :type index: int
        :rtype: int
        """
        cur = self.dummyhead.next # 即head，cur指向index时get值,与循环对应
        # 判断index是否有效
        if index<0 or index>self.size-1:
            return -1
        else:
            for i in range(index):
                cur = cur.next
            return cur.val

    def addAtHead(self, val):
        """
        :type val: int
        :rtype: None
        """
        newNode = ListNode(val)
        newNode.next = self.dummyhead.next  #先添加新节点指向旧头节点的边
        self.dummyhead.next = newNode       #再改变dummyhead的next节点为新节点
        self.size +=1                       #记得增加size
        # self.dummyhead.next = ListNode(val, self.dummy_head.next)

    def addAtTail(self, val):
        """
        :type val: int
        :rtype: None
        """
        cur = self.dummyhead
        while cur.next:
            cur=cur.next
        cur.next = ListNode(val)
        self.size +=1                       #记得增加size
        
    def addAtIndex(self, index, val):
        """
        :type index: int
        :type val: int
        :rtype: None
        """
        if index < 0 or index > self.size: #index=self.size是有效的
            return
        
        cur = self.dummyhead               #指向index节点的前一个节点
        for i in range(index):
            cur = cur.next
        cur.next = ListNode(val, cur.next)
        self.size += 1       

    def deleteAtIndex(self, index):
        """
        :type index: int
        :rtype: None
        """
        if index<0 or index>=self.size: #对于删除操作，index=self.size是无效的
            return 
        cur = self.dummyhead
        for i in range(index):
            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)

注意注意，在有index的时候要注意根据题意判断index的合法范围，还有在增删操作需要知道上一个节点的信息，因此cur指向dummyhead，而获取值的时候cur就应该指向目标节点，所以cur指向dummyhead.next。

二、双链表

# TODO：暂时还没学到双链表

三、本题总结

本题需要搞清楚各个边界条件，以及增删get等操作的先后顺序。

---

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
        """
        # 反转列表需要前置节点指针，和当前节点指针
        pre = None
        cur = head
        while(cur):
            temp = cur.next # temp 保存一下cur下个节点，以免到后面cur.next改变丢失下一个节点的信息
            cur.next = pre
            pre = cur
            cur = temp 		#此时的cur.next为原pre，原cur.next为temp
        return pre          # 最后cur为空

双指针的写法，主要是要考虑清楚方向改变的过程，需要考虑到temp的使用，保存下来cur.next节点，然后逐个往后更新

二、递归法

# 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
        """
        # 递归法
        return self.reverse(head,None) # reverse的参数为初始化pre和cur的参数
    def reverse(self,cur,pre):
        if cur == None:
            return pre
        temp = cur.next
        cur.next = pre
        return self.reverse(temp,cur) #reverse是进入下一层循环，所以传入cur和pre更新的参数
           

很巧妙的方法，但是还是要遵循双指针的思路写。

三、本题总结

本题入手还是从双指针开始，递归的写法还需要再写几遍。