代码随想录二刷day3 链表复习 203.移除链表元素 206.反转链表 707.设计链表

代码随想录复习

---

链表和数组

什么是数组：数组是放在连续内存空间上相同数据类型的集合

数组便于查找，查找的时间复杂度是O(1), 但插入删除时间复杂度是O(n)

什么是链表： 链表是用指针串联在一起的数据结构，每个结点有一个数据域和一个指针域指向下一个结点，最后一个结点的指针指向 Null

链表中的节点在内存中不是连续分布的 ，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。

链表便于增删，增删的时间复杂度都是O(1), 但查找的时间复杂度是O(n)

如何手写定义一个链表

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

head = ListNode(val = 5, next = node2)
node2 = ListNode(val = 4, next = node3)
node3 = ListNode(val = 3)
	

203.移除链表元素

移除链表元素

这道题带给我了什么：

1. 移除链表元素如果不想特判移除的结点是否为头结点可以引入一个虚拟头结点
2. 遍历链表是用curr, while curr: 由于引入了dummy_head，变成了 while curr.next
3. 找的是curr结点的下一个结点，if curr.next.val == val: curr.next = curr.next.next

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

206.反转链表

反转链表

刷这道题三遍带给我了什么：
1.反转链表要靠两个指针，prev和curr，一开始一个指向None一个指向head
2.由于最后curr要指向None, 而反转操作是curr.next = prev; 所以需要先反转，再移动
3.最后curr已经出去了, prev是反转后的链表head

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        prev, curr = None, head
        while curr:
            tmp = curr.next
            curr.next = prev
            prev = curr
            curr = tmp
        return prev 

递归写法,更能体现出这个反转过程

def reverseList(self, head: ListNode) -> ListNode:
	def reverse(pre,cur):
        if not cur:
        	return pre    
        	  
            tmp = cur.next
            cur.next = pre
        return reverse(cur,tmp)
    return reverse(None,head)

707.设计链表

设计链表

这道题主要有三个函数需要手动实现：

get_index(self, index)
#拿到索引位置的val

add_atindex
#在索引位置添加结点

delete_atindex
#在索引位置删除结点

除此之外你还要定义一个__init__(self):函数, 在这里定义一个虚拟头结点便于操作还要储存一下self.cnt,结点个数

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

class MyLinkedList:

    def __init__(self):
        self._head = Node()  #虚拟头结点
        self.cnt = 0         #链表的结点数


    def get(self, index: int) -> int:
        if 0 <= index < self.cnt:
            node = self._head
            for i in range(index+1):
                node = node.next
            return node.val
        else: return -1


    def addAtHead(self, val: int) -> None:
        self.addAtIndex(0, val)

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


    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0: index = 0
        if index > self.cnt: return

        self.cnt += 1
        added_node = Node(val)

        curr_node = self._head
        prev_node = None   #需要把插入位置的前一个结点搞出来

        for i in range(index+1): #先找到要添加的地方，因为有虚拟头结点所以挪index+1
            prev_node, curr_node = curr_node, curr_node.next
        else:
            prev_node.next, added_node.next = added_node, curr_node


    def deleteAtIndex(self, index: int) -> None:
        if 0 <= index < self.cnt:
            self.cnt -= 1

            prev_node = None
            curr_node = self._head
            for i in range(index+1):
                prev_node, curr_node = curr_node, curr_node.next
            else:                  #此时已经curr是指向该index位置了
                prev_node.next = curr_node.next
                curr_node.next = None