力扣刷题0630
文章目录
-
- 链表理论基础
-
- 链表的分类
- 链表的存储方式
- 链表常用操作
- 203.移除链表元素
- 707.设计链表
- 206.反转链表
链表理论基础
链表（单链表）是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。
链表的入口节点称为链表的头结点也就是head。
链表的分类
链表可以分为：单链表、双链表、循环链表。
单链表中的指针域只能指向节点的下一个节点。
双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。
双链表 既可以向前查询也可以向后查询。
循环链表，就是链表首尾相连。循环链表可以用来解决约瑟夫环问题。
链表的存储方式
链表的存储方式跟数组不同，数组是在内存中是连续分布的，但是链表在内存中可不是连续分布的。链表是通过指针域的指针链接在内存中各个节点。所以链表中的节点在内存中不是连续分布的 ，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。
链表常用操作
1、删除节点：（Python，就有自己的内存回收机制，不用自己手动释放）
2、添加节点：
对比数组：
数组在定义的时候，长度就是固定的，如果想改动数组的长度，就需要重新定义一个新的数组。链表的长度可以是不固定的，并且可以动态增删， 适合数据量不固定，频繁增删，较少查询的场景。
注意：通常单链表的定义如下：
class ListNode:
def __init__(self, val, next=None):
self.val = val
self.next = next
203.移除链表元素
给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
题目链接：链接
自己理解题目：先想着用两个指针在链表上操作，发现只能删第一个满足要求的节点；后面就采用链表+列表的形式实现，即只在列表中存入满足要求的节点值，然后将列表转换成链表，比较迂回了。。。
# 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]:
#cur=head
#res=ListNode(-1)
#res.next=cur
#if head==None:
# return None
#while cur:
# if cur.val==val:
# res.next=cur.next #删除节点后，cur和res指向同一个节点
# cur=cur.next
# res=res.next
#
#return head
l=[]
cur=head
while cur:
if cur.val!=val:
l.append(cur.val)
cur=cur.next
curl=ListNode(-1)
res=ListNode(-1)
res.next=curl
for i in range(0,len(l)):
curl.next=ListNode(l[i])
curl=curl.next
return res.next.next
题解：
pre=ListNode() #定义一个虚节点
pre.next=head #虚节点的下一节点为头节点
cur=pre #定义当前节点变量
while cur.next: #当当前节点下一节点不为空节点时开始循环，保证3个节点都存在
if cur.next.val==val: #下一节点满足删除条件
cur.next=cur.next.next #删除当前节点
else: #不满足要求时
cur=cur.next #往后循环链表
return pre.next #返回虚节点
一看题解，自己把单链表的删除想太复杂了。。。
707.设计链表
你可以选择使用单链表或者双链表，设计并实现自己的链表。
单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。
如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。
题目链接：
自己理解题目：说实话，题目我都读不懂。。。就当混个眼熟吧
（版本一）单链表法
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
class MyLinkedList:
def __init__(self):
self.dummy_head = ListNode()
self.size = 0
def get(self, index: int) -> int:
if index < 0 or index >= self.size:
return -1
current = self.dummy_head.next
for i in range(index):
current = current.next
return current.val
def addAtHead(self, val: int) -> None:
self.dummy_head.next = ListNode(val, self.dummy_head.next)
self.size += 1
def addAtTail(self, val: int) -> None:
current = self.dummy_head
while current.next:
current = current.next
current.next = ListNode(val)
self.size += 1
def addAtIndex(self, index: int, val: int) -> None:
if index < 0 or index > self.size:#这里不是>=
return
current = self.dummy_head
for i in range(index):
current = current.next
current.next = ListNode(val, current.next)
self.size += 1
def deleteAtIndex(self, index: int) -> None:
if index < 0 or index >= self.size:
return
current = self.dummy_head
for i in range(index):
current = current.next
current.next = current.next.next
self.size -= 1
（版本二）双链表法
class ListNode:
def __init__(self, val=0, prev=None, next=None):
self.val = val
self.prev = prev
self.next = next
class MyLinkedList:
def __init__(self):
self.head = None
self.tail = None
self.size = 0
def get(self, index: int) -> int:
if index < 0 or index >= self.size:
return -1
if index < self.size // 2:
current = self.head
for i in range(index):
current = current.next
else:
current = self.tail
for i in range(self.size - index - 1):
current = current.prev
return current.val
def addAtHead(self, val: int) -> None:
new_node = ListNode(val, None, self.head)
if self.head:
self.head.prev = new_node
else:
self.tail = new_node
self.head = new_node
self.size += 1
def addAtTail(self, val: int) -> None:
new_node = ListNode(val, self.tail, None)
if self.tail:
self.tail.next = new_node
else:
self.head = new_node
self.tail = new_node
self.size += 1
def addAtIndex(self, index: int, val: int) -> None:
if index < 0 or index > self.size:
return
if index == 0:
self.addAtHead(val)
elif index == self.size:
self.addAtTail(val)
else:
if index < self.size // 2:
current = self.head
for i in range(index - 1):
current = current.next
else:
current = self.tail
for i in range(self.size - index):
current = current.prev
new_node = ListNode(val, current, current.next)
current.next.prev = new_node
current.next = new_node
self.size += 1
def deleteAtIndex(self, index: int) -> None:
if index < 0 or index >= self.size:
return
if index == 0:
self.head = self.head.next
if self.head:
self.head.prev = None
else:
self.tail = None
elif index == self.size - 1:
self.tail = self.tail.prev
if self.tail:
self.tail.next = None
else:
self.head = None
else:
if index < self.size // 2:
current = self.head
for i in range(index):
current = current.next
else:
current = self.tail
for i in range(self.size - index - 1):
current = current.prev
current.prev.next = current.next
current.next.prev = current.prev
self.size -= 1
206.反转链表
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
题目链接：链接
自己理解题目：第一反应利用列表的reverse反转后，转化成链表。
（版本一）双指针法
# 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: ListNode) -> ListNode:
cur = head
pre = None
while cur:
temp = cur.next # 保存一下 cur的下一个节点，因为接下来要改变cur->next
cur.next = pre #反转
#更新pre、cur指针
pre = cur
cur = temp
return pre
（版本二）递归法
# 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: ListNode) -> ListNode:
return self.reverse(head, None)
def reverse(self, cur: ListNode, pre: ListNode) -> ListNode:
if cur == None:
return pre
temp = cur.next
cur.next = pre
return self.reverse(temp, cur)
每次碰到链表问题，都是固定思维转化成列表操作再转链表，改改改。