【代码随想录】day04-1 203.移除链表元素 707.设计链表 206.反转链表

 203.移除链表元素

链表节点的定义，很多同学在面试的时候都写不好。

这是因为平时在刷leetcode的时候，链表的节点都默认定义好了，直接用就行了，所以同学们都没有注意到链表的节点是如何定义的。

Python链表节点定义：

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

性能分析

链表的特性和数组的特性进行一个对比，如图所示：

203. 移除链表元素

这道题就是给大家一个链表，移除链表中等于某个target的所有节点。然后返回这个链表的头节点。

如果我们删除这个节点的话，让这个节点的前一个节点，指向这个节点的下一个节点。这样我们就把这个元素从列表中移除了。这个节点是c++的话，我们要手动把这个节点的内存给释放掉。

移除节点时有一个问题。如果移除的节点是头节点，头节点没有前一个节点，我们要把Head向下移1位  head=head.next。这样我们就把头结点，从链表中删除了。他的新的头结点是原来的第二个节点。

从列表中移除元素针对头节点和非头节点的移除元素的方式是不一样的。
那么我们在实现这段代码逻辑的时候就要做一个判断，我们删除的这个节点是不是头节点？这样的话我们删除节点的方式就没有统一，能不能有一种方式能统一的方式删除所有节点？
还有一种方法叫做虚拟头结点的方法：就是在这个列表中再加入一个头节点。这个头节点叫做dummy head。是虚拟的。这样的话我们再去删除列表中的元素时，所有的元素都可以按照一个规则进行删除。

不用虚拟头节点来删除代码中元素的方法：

首先我们要判断我们删除的元素是不是头节点。
这个头节点一定要不为空，因为我们接下来要取这个头节点的值。如果这个头节点为空的话，我们相当于取了一个空指针，编译的时候会报错。同时这个头节点的数值等于我们要删除的值。满足这样的情况时，我们要把这个头节点删掉。
if (head != null and head->val == target)
我们进行移除头节点的操作后，移动到下一个节点时发现还是一样。所以我们移除头节点其实是一个持续移除的过程。所以这里应该是while。
while (head != null and head->val == target)
    head = head->next


cur  = head
这里的临时指针为什么是从head开始而不是从它的下一个节点开始？例如说我现在要删除第二个元素。删除第二个元素要找他的上一个节点指向他的下一个节点。所以这里要记录该节点的上一个节点。所以我们要删除head.next要从head开始。
whlie(cur != null && cur.next != null){
这两个值不能为空，否则在取值时会出现空指针错误。
    if (cur->next->val == target){
        cur->next = cur->next->next}
    else {
        cur = cur->next
    }

return head
    
        

用虚拟头节点的方法：

首先将dummyhead的实例化,new出来一个节点
dummyhead = new ListNode()
dummyhead->next = head
定义一个临时指针来遍历链表，头节点的指针是不能改的。否则最后返回的头节点一直在变化。
cur = dummyhead 
这里为什么不定义cur = dummyhead.next？我们如果要删掉一个元素，必须要知道这个元素的上一个元素是什么。
while(cur->next != null){
    if (cur->next->val == target){
        cur->next = cur->next->next;
    else{
        cur = cur->next
    }
return dummyhead->next
为什么不返回head？因为head有可能已经被我们删掉了。

Python代码：

# 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]:
        dummyhead = ListNode()
        dummyhead.next = head
        cur = dummyhead
        while cur.next != None:
            if cur.next.val == val:
                cur.next = cur.next.next
            else:
                cur = cur.next
        return dummyhead.next
            


        

707. 设计链表

 

Python代码：

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: int) -> int:
        if index < 0 or index >= self.size:
            return -1
        
        current = self.dummy_head.next
        for i in range(index):
            current = current.next
            
        return current.val

    def addAtHead(self, val: int) -> None:
        self.dummy_head.next = ListNode(val, self.dummy_head.next)
        self.size += 1

    def addAtTail(self, val: int) -> None:
        current = self.dummy_head
        while current.next:
            current = current.next
        current.next = ListNode(val)
        self.size += 1

    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0 or index > self.size:
            return
        
        current = self.dummy_head
        for i in range(index):
            current = current.next
        current.next = ListNode(val, current.next)
        self.size += 1

    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index >= self.size:
            return
        
        current = self.dummy_head
        for i in range(index):
            current = current.next
        current.next = current.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. 反转链表

Python代码：

# 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: Optional[ListNode]) -> Optional[ListNode]:
        pre =None
        cur = head
        while cur:
            temp = cur.next
            cur.next = pre
            pre = cur
            cur = temp
        return pre

方法二：
# 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: Optional[ListNode], pre: Optional[ListNode]) ->Optional[ListNode]:
        if cur == None:
            return pre
        temp = cur.next
        cur.next = pre
        return self.reverse(temp, cur)


    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        return self.reverse(head, None)