什么是链表
链表是一种基本的数据结构,用于存储一系列元素,这些元素按顺序排列,但不需要占用连续的内存空间。链表中的每个元素称为节点(Node),每个节点包含两个部分:数据部分和指针部分。数据部分存储元素的值,而指针部分存储指向下一个节点的引用(或指针)。
链表的主要类型包括:
-
单链表(Singly Linked List):每个节点包含一个数据字段和一个指向下一个节点的指针。最后一个节点的指针通常为空(
None
或null
),表示链表的结束。 -
双链表(Doubly Linked List):每个节点包含一个数据字段和两个指针,一个指向前一个节点,另一个指向后一个节点。这使得在双链表中可以双向遍历。
-
循环链表(Circular Linked List):在单链表或双链表的基础上,将最后一个节点的指针指向第一个节点,形成一个循环。
链表的优点包括:
- 动态大小:链表的大小可以在运行时动态增加或减少,不需要预先分配固定大小的内存。
- 插入和删除操作高效:在链表中插入或删除节点通常只需要改变几个指针的指向,而不需要像数组那样移动大量元素。
链表的缺点包括:
- 访问元素不方便:链表不像数组那样可以通过索引直接访问元素,必须从头节点开始遍历链表,直到找到目标节点。
- 额外的内存开销:每个节点除了存储数据外,还需要存储指针信息,这会导致额外的内存开销。
链表在实现某些数据结构(如栈、队列、哈希表的链地址法解决冲突等)和解决某些算法问题时非常有用。然而,在需要频繁随机访问元素的场景中,数组或其他数据结构可能更为合适。
理解了以上的基础知识后,话不多说直接上题
203.移除链表元素
给你一个链表的头节点 head
和一个整数 val
,请你删除链表中所有满足 Node.val == val
的节点,并返回 新的头节点 。
示例 1:
输入:head = [1,2,6,3,4,5,6], val = 6 输出:[1,2,3,4,5]
示例 2:
输入:head = [], val = 1 输出:[]
示例 3:
输入:head = [7,7,7,7], val = 7 输出:[]
这里就涉及如下链表操作的两种方式:
- 直接使用原来的链表来进行删除操作。
- 设置一个虚拟头结点在进行删除操作。
针对第一种方法,假如非头结点是对应值的话可以通过让前一个节点next指针直接指向下下一个节点就可以了,假如头结点是对应值该如何移除呢,其实只要将头结点向后移动一位就可以,这样就从链表中移除了一个头结点。这样写代码时候需要另写一段逻辑来处理移除头结点的情况。
那么可不可以 以一种统一的逻辑来移除 链表的节点呢。
其实可以设置一个虚拟头结点,这样原链表的所有节点就都可以按照统一的方式进行移除了。
这里来给链表添加一个虚拟头结点dummy_head
为新的头结点,此时要移除这个旧头结点元素1。
这样是不是就可以使用和移除链表其他节点的方式统一了呢?
来看一下,如何移除元素1 呢,还是熟悉的方式,让next指正指向1的后面一个节点4。
最后呢在题目中,return 头结点的时候,别忘了 return dummy_head.next;
, 这才是新的头结点
# 定义一个单链表对象ListNode,val默认值为0
# next是指向下一个 ListNode 对象的引用,默认值为 None,表示当前节点是链表的最后一个节点
# class ListNode(object):
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution(object):
def removeElements(self, head, val):
"""
:type head: ListNode
:type val: int
:rtype: ListNode
"""
# 创建虚拟头部节点以简化删除过程
dummy_head = ListNode(next = head)
# 遍历列表并删除值为val的节点
current = dummy_head
while current.next:
if current.next.val == val:
current.next = current.next.next
else:
current = current.next
return dummy_head.next
注:移除对应节点后,python的话不用手动管理内存,会自动清理内存
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(object):
def __init__(self):
self.dummy_head = ListNode()
self.size = 0
def get(self, index):
"""
:type index: int
:rtype: int
"""
if index < 0 or index >= self.size:
return -1
#等于0时直接返回头结点
current = self.dummy_head.next
for i in range(index):
current = current.next
return current.val
def addAtHead(self, val):
"""
:type val: int
:rtype: None
"""
# 这里是一个关键点 得先让新插入的节点的next指向dummy_head.next,然后重新给dummy_head.next重新指向新加的节点
self.dummy_head.next = ListNode(val, self.dummy_head.next)
self.size += 1
def addAtTail(self, val):
"""
:type val: int
:rtype: None
"""
current = self.dummy_head
for i in range(self.size):
current = current.next
current.next = ListNode(val)
self.size += 1
def addAtIndex(self, index, val):
"""
:type index: int
:type val: int
:rtype: 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):
"""
:type index: int
:rtype: 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
# Your MyLinkedList object will be instantiated and called as such:
# obj = MyLinkedList()
# param_1 = obj.get(index)
# obj.addAtHead(val)
# obj.addAtTail(val)
# obj.addAtIndex(index,val)
# obj.deleteAtIndex(index)
给你单链表的头节点 head
,请你反转链表,并返回反转后的链表。
示例 1:
输入:head = [1,2,3,4,5] 输出:[5,4,3,2,1]
示例 2:
输入:head = [1,2] 输出:[2,1]
示例 3:
输入:head = [] 输出:[]
思路
翻转链表 本质其实就是翻转2个节点之间的next指针的指向。例如原本a.next = b 变为b.next =a,链表长度为n,那么就翻转相邻节点的指针n次。那么原本头结点就会变成尾节点,而尾结点的next为None,故初始化的时候给pre(前一个节点)定义为None,也就是所谓的双指针法
- 时间复杂度: O(n)
- 空间复杂度: O(1)
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution(object):
def reverseList(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
cur = head
pre = None
while cur:
temp = cur.next # 保存一下 cur的下一个节点,因为接下来要改变cur->next
cur.next = pre #反转
#更新pre、cur指针
pre = cur
cur = temp
return pre