day3 ListNode

用链表的目的是什么？省空间还是省时间？ - 知乎

 

链表只是区别于数组的一种数据结构，明显的区别是有链接。

学链表的目的是为了让你自己设计合适的数据处理结构。 

203 移除链表元素

dummy_head统一删除方式

cur设置临时指针，用于操作，这个临时指针起始是dummy_head

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummy_head = ListNode(next = head)
        cur = dummy_head
        while(cur.next!= None):
            if (cur.next.val == val):
                cur.next = cur.next.next
            else:
                cur = cur.next
        return dummy_head.next

707 还需要把代码中的head改成dummy更好理解

# 先构造Node结构，包括数值和指针, val, next 为链表结构专有概念，不需要定义也能直接调用。val 赋值0， next赋值为None。

class Node:

    def __init__(self, x = 0):

        self.val = x

        self.next = None

#构造链表，定义头结点

class MyLinkedList:

    def __init__(self):

        self.head = Node()

        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:

        new_node = Node(val)

        new_node.next = self.head.next # 先指向头结点的下一个，这时候这个链接还没断

        self.head.next = new_node #再让head指向new node, head就是这个程序里的虚拟结点

        self.size += 1

 

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

        new_node = Node(val)

        cur = self.head

        while(cur.next):# cur不会none，就继续遍历

            cur = cur.next

        cur.next = new_node

        self.size += 1

 

    def addAtIndex(self, index: int, val: int) -> None:

        if index <= 0: # 如果index小于等于0，那么就是说在前面插入，和你自己有没有设置dummyhead无关。等于0的情况，因为有dummyhead, 下面集中处理的代码里包含了，所以这里可以不等于。

            self.addAtHead(val)

            return

        elif index == self.size: # 最大的index是size - 1

            self.addAtTail(val)

            return

        elif index > self.size: # 不插入

            return

        node = Node(val)

        pre = self.head #定义pre为辅助指针

        while(index): #这里考虑了dummyhead，带入简单的数字验证就会明白

            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

   206 递归写法真是骚啊，不怎么妙，但是骚。基于双指针写法的原理来搞的。