代码随想录Day03

代码随想录Day03

203移除链表元素

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

示例 1：

输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]
示例 2：

输入：head = [], val = 1
输出：[]
示例 3：

输入：head = [7,7,7,7], val = 7
输出：[]

# 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]:
        #创建一个虚拟节点
        dummyNode = ListNode(0)
        dummyNode.next = head
        cur = dummyNode
        while (cur.next != None):
            if cur.next.val == val:
                cur.next = cur.next.next
            else:
                cur = cur.next
        return dummyNode.next

707设计链表

说实话这个题之前做过，但是再次写起来却有些生疏，总结一下：1.忘记如何创建头节点 2.设置一个cur变量来传入dummyNode的值来遍历循环 3 return dummyNode.next（也就是一个完整的列表，如果return cur 就只是一个值）

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

在链表类中实现这些功能：

get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

示例：

MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2); //链表变为1-> 2-> 3
linkedList.get(1); //返回2
linkedList.deleteAtIndex(1); //现在链表是1-> 3
linkedList.get(1); //返回3

lass ListNode(object):
    def __init__(self,x = 0):
        self.val = x
        self.next = None

class MyLinkedList:

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


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

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


    def addAtTail(self, val: int) -> None:
        node = ListNode(val)
        cur = self.head
        while (cur.next != None):
            cur = cur.next
        cur.next = node
        self.size += 1


    def addAtIndex(self, index: int, val: int) -> None:
        
        if index < 0:
            self.addAtHead(val)
            return 
        if index == self.size:
            self.addAtTail(val)
            return
        if index > self.size:
            return
        node = ListNode(val)
        pre = self.head
        while (index):
            pre = pre.next
            index -= 1
        node.next = pre.next
        pre.next = node
        self.size += 1 



    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index >= self.size:
            return
        pre = self.head
        while (index):
            pre = pre.next
            index -= 1
        pre.next = pre.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反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
示例 2：

输入：head = [1,2]
输出：[2,1]
示例 3：

输入：head = []
输出：[]

提示：

链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000

# 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 = head
        pre = None
        while (cur != None):
            temp = cur.next
            cur.next = pre
            pre = cur
            cur = temp
        return  pre

这道反转链表是看了卡哥的视频后一遍用二分法的思路写出来的，递归暂时没太明白，但是二分法的思路真的清晰，希望二刷的时候可以秒过吧，谢谢老师讲解！