目录
链表
什么是链表,链表是一种通过指针串联在一起的线性结构,每一个节点由两部分组成,一个是数据域一个是指针域(存放指向下一个节点的指针),最后一个节点的指针域指向null(空指针的意思)。
单链表
链表的入口节点称为链表的头结点也就是head。
双链表
单链表中的指针域只能指向节点的下一个节点。
双链表:每一个节点有两个指针域,一个指向下一个节点,一个指向上一个节点。
双链表 既可以向前查询也可以向后查询。
链表的存储方式
链表在内存中不是连续的,各个节点分布在内存的不同地址空间上,通过指针串联在一起。
链表的增删
删除节点
添加节点
链表和数组的对比
链表的初始化(Python)
Class ListNode:
def __init__(self, val = 0, next = None):
self.val = val
self.next = next
203. 移除链表元素
删除链表中等于给定值 val 的所有节点。
思路
例子如下:
但是这样的删除需要考虑一个问题,就是删除头节点需要多做一步操作。删除完头节点之后需要把head移动到下一个节点。
所以为了保证逻辑的统一我们采取虚拟头节点来进行删除元素:
这次删除头结点和删除其他节点时,操作的逻辑是一致的。
但是要注意我们在return
的时候,记得要return dummy.next
。
代码
写法一:在链表本身删除节点
# 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]:
# 删除头节点,注意使用while loop
while head and head.val == val:
head = head.next
# 删除非头节点
cur = head
while cur and cur.next:
if cur.next.val == val:
# delete cur.next
cur.next = cur.next.next
else:
# cur pointer go to next node
cur = cur.next
return head
写法二:虚拟头节点
# 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]:
#创建虚拟头
dummy = ListNode(next = head)
#创建指针cur来遍历链表
cur = dummy
#此处思路和写法一的删除非头节点一致
while cur.next:
if cur.next.val == val:
cur.next = cur.next.next
else:
cur = cur.next
return dummy.next
复杂度分析
对以上两种写法来说,都是以下复杂度
- 时间复杂度:
O(n)
- 空间复杂度:
O(1)
707. 设计链表
在链表类中实现这些功能:
get(index)
:获取链表中第index
个节点的值。如果索引无效,则返回-1。addAtHead(val)
:在链表的第一个元素之前添加一个值为val
的节点。插入后,新节点将成为链表的第一个节点。addAtTail(val)
:将值为val
的节点追加到链表的最后一个元素。addAtIndex(index,val)
:在链表中的第index
个节点之前添加值为val
的节点。如果index
等于链表的长度,则该节点将附加到链表的末尾。如果 index大于链表长度,则不会插入节点。deleteAtIndex(index)
:如果索引index
有效,则删除链表中的第index
个节点。
思路
用虚拟头节点来操作会简单点。
代码
class ListNode:
# 定义链表节点结构体
def __init__(self, val = 0, next = None):
self.val = val
self.next = next
class MyLinkedList:
#初始化链表,因为我们使用的是虚拟头节点来操作,所以我们会定义一个dummy虚拟头
#定义size这样方便我们根据Index删除节点,或者在某个index增加节点
def __init__(self):
self.dummy = ListNode()
self.size = 0
def get(self, index: int) -> int:
if index >= self.size or index < 0:
return -1
cur = self.dummy.next
for i in range(index):
cur = cur.next
return cur.val
def addAtHead(self, val: int) -> None:
target = ListNode(val = val)
temp = self.dummy.next
self.dummy.next = target
target.next = temp
self.size += 1
def addAtTail(self, val: int) -> None:
cur = self.dummy
#cur pointer travels to the tail
while cur.next:
cur = cur.next
cur.next = ListNode(val = val)
self.size += 1
def addAtIndex(self, index: int, val: int) -> None:
cur = self.dummy
if index > self.size or index < 0:
return
for i in range(index):
cur = cur.next
cur.next = ListNode(val = val, next = cur.next)
self.size += 1
def deleteAtIndex(self, index: int) -> None:
if index < 0 or index >= self.size:
return
cur = self.dummy
for i in range(index):
cur = cur.next
cur.next = cur.next.next
self.size -= 1
复杂度分析
- 时间复杂度:涉及
index
的相关操作为O(index)
,addAtTail
是O(n)
.AddAtHead
是O(1)
- 空间复杂度:
O(1)
206. 翻转链表
反转一个单链表
示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL
双指针
首先定义一个
cur
指针,指向头结点,再定义一个pre
指针,初始化为null
。
然后就要开始反转了,首先要把cur.next
节点用tmp
指针保存一下,也就是保存一下这个节点。
为什么要保存一下这个节点呢,因为接下来要改变cur.next
的指向了,将cur.next
指向pre
,此时已经反转了第一个节点了。
接下来,就是循环走如下代码逻辑了,继续移动pre
和cur
指针。
最后,cur
指针已经指向了null
,循环结束,链表也反转完毕了。 此时我们return pre
指针就可以了,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: Optional[ListNode]) -> Optional[ListNode]:
prev = None
cur = head
while cur:
#保存cur的下一个节点,因为接下来要改变cur.next
temp = cur.next
cur.next = prev #反转
# 更新prev和cur指针
prev = cur
cur = temp
return prev
复杂度分析
- 时间复杂度:
O(n)
- 空间复杂度:
O(1)
递归法
其实和双指针法是一样的逻辑,同样是当
cur
为空的时候循环结束,不断将cur
指向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: Optional[ListNode]) -> Optional[ListNode]:
#此处相当于双指针写法 cur, prev = head, None
return self.reverse(head, None)
def reverse(self, cur, pre):
if cur == None:
return pre
temp = cur.next
cur.next = pre
return self.reverse(temp, cur) #此处相当于双指针写法里面的 cur, pre = temp, cur
复杂度分析
- 时间复杂度:
O(n)
,要递归处理链表的每个节点 - 空间复杂度:
O(n)
,因为递归调用了 n 层栈空间