第二章 链表part01
链表理论基础
- 链表是一种通过指针串联在一起的线性结构,每一个节点由两部分组成,一个是数据域一个是指针域(存放指向下一个节点的指针),最后一个节点的指针域指向null(空指针的意思)。
- 链表的入口节点称为链表的头结点也就是head。
- 链表的类型:单链表,双链表和循环链表。
- 单链表中的指针域只能指向节点的下一个节点;
- 双链表:每一个节点有两个指针域,一个指向下一个节点,一个指向上一个节点。
- 循环链表,顾名思义,就是链表首尾相连。循环链表可以用来解决约瑟夫环问题。
- 链表的存储方式
数组是在内存中是连续分布的,但是链表在内存中可不是连续分布的。链表是通过指针域的指针链接在内存中各个节点。所以链表中的节点在内存中不是连续分布的 ,而是散乱分布在内存中的某地址上,分配机制取决于操作系统的内存管理。
- 链表的定义
给出C/C++的定义链表节点方式,如下所示:struct ListNode { int val; // 节点上存储的元素 ListNode *next; // 指向下一个节点的指针 ListNode(int x) : val(x), next(NULL) {} // 节点的构造函数 };
- 链表的操作
- 删除节点
删除D节点,如图所示:
只要将C节点的next指针 指向E节点就可以了。D节点依然存留在内存里,只不过是没有在这个链表里而已。- 添加节点
可以看出链表的增添和删除都是O(1)操作,也不会影响到其他节点。但是要注意,要是删除第五个节点,需要从头节点查找到第四个节点通过next指针进行删除操作,查找的时间复杂度是O(n)。
数组在定义的时候,长度就是固定的,如果想改动数组的长度,就需要重新定义一个新的数组。
链表的长度可以是不固定的,并且可以动态增删, 适合数据量不固定,频繁增删,较少查询的场景。
203.移除链表元素
题目:给你一个链表的头节点 head 和一个整数 val ,请你删除链表中所有满足 Node.val == val 的节点,并返回 新的头节点 。
思路:
- 要想删除节点node,必须在 node的前一个节点执行删除操作。例如链表 1→2→3,要想删除 2,必须在节点1处操作,也就是把节点 1 的 next更新为节点 3。
- 如果头节点可能被删除,那么要在头节点之前添加一个哨兵节点,这样无需特判头节点被删除的情况,从而简化代码逻辑。或者说,根据套路 1,要想删除头节点,必须在头节点的前一个节点操作,所以要添加一个哨兵节点。
算法:
- 初始化哨兵节点 dummy,其 next为 head。
- 遍历链表,初始化cur=dummy。
- 循环直到 cur 的下一个节点为空。
- 如果 cur的下一个节点的值等于 val,那么删除下一个节点,把 cur.next 更新为 cur.next.next。
- 如果 cur的下一个节点的值不等于 val,那么不删除下一个节点,继续看下下一个节点是否要删除,即更新 cur 为 cur.next。
- 循环结束,返回 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]:
cur=dummy=ListNode(next=head)
while cur.next:#当cur循环到末尾时,循环结束
if cur.next.val==val:
cur.next=cur.next.next# 删除下一个节点
else:
cur=cur.next# 继续向后遍历链表
return dummy.next
复杂度分析
时间复杂度:O(n),其中 n 是链表的长度。
空间复杂度:O(1)。
707.设计链表
题目:你可以选择使用单链表或者双链表,设计并实现自己的链表。单链表中的节点应该具备两个属性:val 和 next 。val 是当前节点的值,next 是指向下一个节点的指针/引用。如果是双向链表,则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。
实现 MyLinkedList 类:
- MyLinkedList() 初始化 MyLinkedList 对象。
- int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效,则返回 -1 。
- void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后,新节点会成为链表的第一个节点。
- void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
- void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度,那么该节点会被追加到链表的末尾。如果 index 比长度更大,该节点将不会插入到链表中。
- void deleteAtIndex(int index) 如果下标有效,则删除链表中下标为 index 的节点。
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:#先判断index是否合法
return -1
current=self.dummy_head.next#头节点
for i in range(index):#开始遍历
current=current.next
return current.val #假设index=0时验证一下
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,None)
self.size+=1
def addAtIndex(self, index: int, val: int) -> None:
#先判断index是否合理
if index<0 or index>self.size:# index可以等于链表长度
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:
#先判断index是否合理
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
206.反转链表
题目:给你单链表的头节点 head ,请你反转链表,并返回反转后的链表。
思路:
如果再定义一个新的链表,实现链表元素的反转,其实这是对内存空间的浪费。其实只需要改变链表的next指针的指向,直接将链表反转 ,而不用重新定义一个新的链表,如图所示:
之前链表的头节点是元素1, 反转之后头结点就是元素5 ,这里并没有添加或者删除节点,仅仅是改变next指针的方向。
算法:
- 首先定义一个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]:
#双指针法
cur=head #指向头节点
pre=None
while cur:
tmp=cur.next
cur.next=pre #反转
pre=cur
cur=tmp
return pre