代码随想录| 203 移除链表元素，707设计链表，206反转链表

代码随想录| 203 移除链表元素，707设计链表，206反转链表

移除链表元素

题目链接：leetcode

题目描述：给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点

单链表的特点是只有一个方向，因此不能考虑“上一个”的概念。同时对每一个节点操作时（运用其方法.next 或者 .val），需要先检查节点非空。尾节点有一点特殊的地方：其指向空节点。
这一题中考虑使用虚拟头节点，即在head节点前新增一个自己创建的节点，那么后面的链表不论怎么变化，虚拟节点的下一个就是head节点
while循环是为了遍历出尾节点外所有节点。

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]:
        dummy = ListNode(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.设计链表

题目描述：
get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/design-linked-list
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

Python 代码

python： 类内方法调用另一个类内方法或者属性，需要使用self.

pred = self.dummy
for _ in range(index):
	pred = pred.next

这个语句将会更新pred到index-1。所以若是需要index的话要用range（index +1）

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

class MyLinkedList:

    def __init__(self):
        self.dummy = Node(0)
        self.size = 0

    def get(self, index: int) -> int:
        if (index <0 or index >= self.size):
            return -1
        cur = self.dummy
        for _ in range(index+1):
            cur = cur.next
        return cur.val
        
    def addAtHead(self, val: int) -> None:
        self.addAtIndex(0,val)

    def addAtTail(self, val: int) -> None:
        self.addAtIndex(self.size,val)

    def addAtIndex(self, index: int, val: int) -> None:
        if index > self.size:
            return 
        index = max(0,index)
        pred = self.dummy
        for _ in range(index):
            pred = pred.next
        new = Node(val)
        new.next=pred.next
        pred.next = new
        self.size += 1


    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index >= self.size:
            return
        pred = self.dummy
        for _ in range(index):
            pred = pred.next
        pred.next = pred.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)

反转链表

题目链接：leetcode

题目描述：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

关键词：单链表，反转
一种想法就是将节点指针指向上一个，也就是反向指。那么链表就变成了从右到左，而不是原始的从左到右。那么问题就是怎么指向上一个，由于单链表节点没有储存上一个的信息，所以就需要想办法找到上一个。 这里考虑加入另一个指针（pre），在一个指针（cur）向右遍历的过程中，pre保存cur上一个遍历的位置，于是cur就可以指向pre从而达到反转的效果。注意到我们要反转整个链表，所以cur 应该初始化为 head，并且向右遍历到空指针（此时无需再进行指向pre的操作），那么作为head的上一个，并且是新链表的最后一位，就应该初始化为空指针。另外，由于节点只有一个指向，若是cur指向了pre，那么遍历的时候cur下一个就会是pre，所以为了正确遍历，我们应该再指向pre前保存原链表下一个的信息（用tmp保存下一个节点）。

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]:
		cur,pre= head,None
		while(cur):
			tmp = cur.next
			cur.next = pre
			pre =cur
			cur =tmp
		return pre

变式：反转index为l，r（包括l，r）的子链表，这里假设l，r有意义。
（此代码尚未运行过，不确保正确运行）

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseSubList(self, head: Optional[ListNode],l:int,r:int) -> Optional[ListNode]:
        pre_fix = head
        for _ in range(l):
        	pre_fix = pre_fix.next
        pre = pre.fix.next
        cur = pre.next
        for _ in range(l-r): 
            tmp = cur.next
            cur.next = pre
            pre = cur
            cur = tmp
        pre_fix.next.next = cur
        pre_fix.next = pre
        return head