《代码随想录》Day3: 链表介绍 + 203.移除链表元素 + 707.设计链表 + 206.反转链表

《代码随想录》Day3

1. 链表介绍

链表特性

1. 链表 ListNode是由指针将多个节点串联在一起的线性结构，每个节点由两部分组成，一是当前节点值，二是下一节点（也就是指针）
2. 链表的入口节点称为头节点也就是head
3. 数组是在内存中是连续分布的，但链表中的节点在内存中不是连续分布的 ，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。

不同链表类型

• 单链表：如上所述，单链表中指针只能指向下一节点
  

• 双链表：每个节点有两个指针，分别指向上一节点和下一节点
  

• 循环链表：链表首尾相连
  

链表的操作

• 定义链表

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

• 删除节点
  若删除第一个元素/链表表头的值

if head.val == val:
	return head.next

• 添加节点

2. Q203.移除链表元素

删除链表中等于给定值 val 的所有节点

分为删头节点和删非头节点

• 删头节点：使head = head.next
• 删非头节点：使head.next = head.next.next

class Solution:
    def removeElements(self, head: ListNode, val: int) -> ListNode:
    #判断要删除的是否是头节点：
        while head and head.val == val: 
            #head不为none且head值等于val，此时要删除头节点
            head = head.next
            
        if head is None: #此时代表链表已全部删完
            return head
            
        #若要删除非头节点，则使该节点前一项.next = 该节点前一项.next.next
        node = head #定义一个临时指针
        while node.next : #while head.next不为none
            if node.next.val == val: #删除非头节点
                node.next = node.next.next
            else:
                node = node.next #不删，接着往后走
        return head

虚拟头节点

在原链表前加上一个虚拟头节点来构建一个新链表，这样判断时就不用区别删除的是否是头节点，可以用一种方式处理完整个链表，输出时输出*dummyhead.next()*即可

class Solution:
    def removeElements(self, head: ListNode, val: int) -> ListNode:
    	dummyhead = ListNode()
    	dummyhead.next = head
    	node = dummyhead
    	while node.next:
    		if node.next.val == val:
    			node.next = node.next.next
    		else:
    			node = node.next
    	return dummyhead.next

递归方法

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        if head is None: #先定义好边界
            return head
        head.next = self.removeElements(head.next,val) #使用递归函数
        #相当于利用递归快速到达链表尾端，从后往前依次进行判断，用删除头节点的方式依次删除
        #每次递归返回的时当前递归层的head(若head值不等于val)，或head.next(若当前head值等于val)
        if head.val == val: #若当前head值等于val
            head = head.next
        else: #若head值不等于val
            head = head
        return head

3. Q707.设计链表

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

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

初始化设定

• 在虚拟头节点设定下进行操作
• 设置一个链表长度的属性，便于后续操作

class MyLinkedList:
    def __init__(self,x=0): #链表初始化
     	#self.dummyhead = ListNode()
    	#self.dummyhead.next = head
       	self.head = Node() #设定head为虚拟头节点
        self.size = 0 # 设置一个链表长度的属性，便于后续操作，注意每次增和删的时候都要更新

get(index) : 获取节点值

• 先讨论边界，若index超出链表范围的情况
• 利用一个临时指针 node 来遍历链表，node 一层层往后推，index 也一层层变小，直到 index=0 时返回该层node的值

def get(self, index: int) -> int:
	#遍历链表获取第n个节点值
	if index < 0 or index >= self.size: #若index超出链表范围，则返回-1
		return -1 
	node = self.head.next
	# 若index减为0，则跳出循环，返回该值，所以是在while中将指针node一点点往后推，直到index减为0
	while (index): #若index不为0
		node = node.next #往后推一层
		index -= 1
	return node.val

addAtHead(self, val) :插入头节点

注意：

• 此时是在虚拟头节点下讨论
• 且要及时更新self.size

	def addAtHead(self, val: int) -> None:
		#self.node此时为 dummy+原head
		new_node = ListNode(val)
		new_node.next = self.head.next #new_node此时为 val+原head
		self.head.next = new_node #self.node此时为 dummy+val+原head
		self.size += 1 #更新self.size

addAtTail(self, val)：插入尾节点

• 需要用临时指针来帮助找尾巴的位置
• 尾巴时next.val = None

    def addAtTail(self, val: int) -> None:
    	#self.node此时为 dummy+原head
		new_node = ListNode(val)
		#要找尾巴的位置，尾巴时next.val = None
		node = self.head
		while (node,next): #当node.next不为None，即还没到末尾
			node = node.next #没到末尾就还往后挪
		node.next = new_node #跳出循环，即找到末尾，现在就插入值
		self.size += 1

addAtIndex(index,val): 在index前插入节点，节点值为val

• 需要先讨论index的取值情况
• 也是用临时指针来移到index位置，注意要将新节点插入index前，则指针要指到index-1的位置

    def addAtIndex(self, index: int, val: int) -> None:
    	if index < 0: #此时插入为头结点
    		self.addAtHead(val)
    		return
    	elif index == self.size: #此时插入尾节点
    		self.addAtTail(val)
    		return
    	elif index > self.size: #此时不插入，直接返回
    		return
    	
    	#利用临时指针node找到对应插入位置
    	new_node = ListNode(val)
    	node = self.head
    	while (index): #当index不为0
    		node = node.next
    		index -= 1
		new_node.next = node.next
		node.next = new_node
		self.size += 1

deleteAtIndex(index): 删除链表中的第 index 个节点

    def deleteAtIndex(self, index: int) -> None:
    	if int < 0 or int >= self.size:
    		return
    	node = self.head
    	while (index):
			node = node.next
			index -= 1
		node.next = node.next.next
		self.size -= 1

4. Q206.反转链表

反转一个单链表

双指针法

反转单链表可理解为依次将链表中箭头转向，用cur和pre两个指针，cur在pre之后，依次将箭头由cur指向pre
分为

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
    	#定义两指针
    	cur = head
    	pre = None
    	while (cur): #当cur不等于None
    		temp = cur.next #将待处理链表暂时储存
    		cur.next = pre #转向
    		pre = cur #已转向的定为pre组
    		cur = temp #未处理的放在cur组中
    	return pre
 

递归法

思路和双指针法类似，用递归的一层层计算来代替while的一层层循环

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
    	#先定义一个reverse函数，思路和双指针法类似
    	def reverse(cur,pre):
    		if cur is None:
    			return pre
    		temp = cur.next #将待处理链表暂时储存
    		cur.next = pre #转向
    		#此时要进入下一层循环，相当于while循环中的下一层
    		return reverse(cur=temp,pre=cur) #再用一遍reverse
    	return reverse(cur = head, pre = None)	##同双指针中的pre和cur的初始化定义