链表
1 理论
- 链表就像一个节点链,其中每个节点包含着数据和指向后续节点的指针。 链表还包含一个头指针,它指向链表的第一个元素,但当列表为空时,它指向null或无具体内容。
- 链表是物理存储单元上非连续的、非顺序的存储结构,数据元素的逻辑顺序是通过链表的指针地址实现,每个元素包含两个结点,一个是存储元素的数据域 (内存空间),另一个是指向下一个结点地址的指针域。根据指针的指向,链表能形成不同的结构,例如单链表,双向链表,循环链表等。
- 链表的优点:
链表是很常用的一种数据结构,不需要初始化容量,可以任意加减元素;
添加或者删除元素时只需要改变前后两个元素结点的指针域指向地址即可,所以添加,删除很快; - 缺点:
因为含有大量的指针域,占用空间较大;
查找元素需要遍历链表来查找,非常耗时。 - 适用场景:
数据量较小,需要频繁增加,删除操作的场景 - 链表与数组:
链表和数组作为算法中的两个基本数据结构,在程序设计过程中经常用到。尽管两种结构都可以用来存储一系列的数据,但又各有各的特点。
数组的优势,在于可以方便的遍历查找需要的数据。在查询数组指定位置(如查询数组中的第4个数据)的操作中,只需要进行1次操作即可,时间复杂度为O(1)。但是,这种时间上的便利性,是因为数组在内存中占用了连续的空间,在进行类似的查找或者遍历时,本质是指针在内存中的定向偏移。然而,当需要对数组成员进行添加和删除的操作时,数组内完成这类操作的时间复杂度则变成了O(n)。
链表的特性,使其在某些操作上比数组更加高效。例如当进行插入和删除操作时,链表操作的时间复杂度仅为O(1)。另外,因为链表在内存中不是连续存储的,所以可以充分利用内存中的碎片空间。除此之外,链表还是很多算法的基础,最常见的哈希表就是基于链表来实现的。基于以上原因,我们可以看到,链表在程序设计过程中是非常重要的。
参考:https://blog.csdn.net/u012531536/article/details/80170893
参考:https://blog.csdn.net/yeyazhishang/article/details/82353846
2 相关编程
1. 实现单链表、循环链表、双向链表,支持增删操作
参考:https://blog.csdn.net/u013109501/article/details/88033722
单链表
class Node(object):
"""定义一个节点"""
def __init__(self, elem):
self.elem = elem
self.next = None
"""定义一个单链表"""
class SingleLinkList(object):
def __init__(self, node=None):
self.__head = node
"""链表是否为空"""
def is_empty(self):
return self.__head is None
"""链表的长度"""
def length(self):
# cur游标,用来移动遍历节点
cur = self.__head
# count记录数量
count = 0
while cur != None:
count += 1
cur = cur.next
return count
"""遍历整个链表"""
def travel(self):
cur = self.__head
while cur != None:
print(cur.elem, end=" ")
cur = cur.next
print("")
"""链表头部添加元素"""
def add(self, item):
node = Node(item)
node.next = self.__head
self.__head = node
"""链表尾部添加元素"""
def append(self, item):
node = Node(item)
if self.is_empty():
self.__head = node
else:
cur = self.__head
while cur.next != None:
cur = cur.next
cur.next = node
"""指定位置添加元素:param pos 从0开始(即将链表的第一个节点记为0节点)"""
# pos/position:位置,方位 param:参数
def insert(self, pos, item):
# pre/previous以前的,在什么之前
if pos <= 0:
self.add(item)
elif pos > (self.length()-1):
self.append(item)
else:
node = Node(item)
pre = self.__head
count = 0
while count < (pos-1):
count += 1
pre = pre.next
node.next = pre.next
pre.next = node
"""删除节点"""
def remove(self, item):
pre = self.__head
# 判断是不是空链表
if pre == None:
return False
# 判断是不是头结点,包含了只有一个节点情况
elif pre.elem == item:
self.__head = pre.next
# pre = None
return True
else:
while pre.next != None:
if pre.next.elem == item:
pre.next = pre.next.next
return True
else:
pre = pre.next
return False
"""查找节点是否存在"""
def search(self, item):
cur = self.__head
while cur != None:
if cur.elem == item:
return True
else:
cur = cur.next
return False
循环链表
"""定义一个节点"""
class Node(object):
def __init__(self, elem):
self.elem = elem
self.next = None
"""单向循环链表"""
class SingleLinkList(object):
def __init__(self, node=None):
self.__head = node
if node != None:
node.next = node
"""链表是否为空"""
def is_empty(self):
return self.__head is None
"""链表的长度"""
def length(self):
if self.is_empty():
return 0
# cur游标,用来移动遍历节点
cur = self.__head
# count记录数量,因为循环不会进入最后一个节点所以初始值为1
count = 1
while cur.next != self.__head:
count += 1
cur = cur.next
return count
"""遍历整个链表"""
def travel(self):
cur = self.__head
if cur == None:
return
else:
while cur.next != self.__head:
print(cur.elem, end=" ")
cur = cur.next
# 退出循环后cur指向尾节点,但是尾节点没有打印。
print(cur.elem)
"""链表头部添加元素"""
def add(self, item):
node = Node(item)
if self.is_empty():
self.__head = node
node.next = self.__head
# 或者
# self.__head = node
# node.next = node
else:
cur = self.__head
while cur.next != self.__head:
cur = cur.next
# 循环结束后cur指向尾节点
node.next = self.__head
self.__head = node
cur.next = node
"""链表尾部添加元素"""
def append(self, item):
node = Node(item)
if self.is_empty():
self.__head = node
node.next = node
else:
cur = self.__head
while cur.next != self.__head:
cur = cur.next
# 循环结束cur指向最后一个节点
cur.next = node
node.next = self.__head
"""指定位置添加元素:param pos 从0开始(即将链表的第一个节点记为0节点)"""
# pos/position:位置,方位 param:参数
def insert(self, pos, item):
# pre/previous以前的,在什么之前
if pos <= 0:
self.add(item)
elif pos > (self.length()-1):
self.append(item)
else:
node = Node(item)
pre = self.__head
count = 0
while count < (pos-1):
count += 1
pre = pre.next
node.next = pre.next
pre.next = node
"""删除节点"""
def remove(self, item):
pre = self.__head
cur = self.__head
# 判断是不是空链表
if cur == None:
return False
# 判断是不是头结点
elif cur.elem == item:
# 判断是不是只有一个节点
if cur.next == self.__head:
self.__head = None
return True
else:
while pre.next != self.__head:
pre = pre.next
self.__head = cur.next
pre.next = self.__head
return True
else:
while pre.next != self.__head:
if pre.next.elem == item:
pre.next = pre.next.next
return True
else:
pre = pre.next
return False
"""查找节点是否存在"""
def search(self, item):
cur = self.__head
# 判断是否为空链表
if self.__head == None:
return False
# 判断是不是头结点
elif cur.elem == item:
return True
else:
while cur.next != self.__head:
if cur.elem == item:
return True
else:
cur = cur.next
# 循环退出后cur指向最后一个节点,但是没有进入最后一个节点
if cur.elem == item:
return True
return False
双向链表
"""节点"""
class Node(object):
def __init__(self, item):
self.elem = item
self.next = None
self.prev = None
"""双向链表"""
class DoubleLinkList(object):
def __init__(self, node=None):
self.__head = node
"""链表是否为空"""
def is_empty(self):
return self.__head is None
"""链表长度"""
def length(self):
# cur游标,用来移动遍历节点
cur = self.__head
# counter:记录数量
counter = 0
while cur != None:
counter += 1
cur = cur.next
return counter
"""链表尾部添加节点,尾插法"""
def append(self, item):
node = Node(item)
if self.is_empty():
self.__head = node
else:
cur = self.__head
while cur.next != None:
cur = cur.next
cur.next = node
node.prev = cur
"""链表头部添加节点,头插法"""
def add(self, item):
node = Node(item)
node.next = self.__head
self.__head = node
node.next.prev = node
"""任意位置添加节点"""
def insert(self, pos, item):
# pos的初始值为0
if pos <= 0:
self.add()
elif pos > (self.length()-1):
self.append()
else:
cur = self.__head
counter = 0
while counter != pos:
counter += 1
cur = cur.next
node = Node(item)
node.prev = cur.prev
cur.prev.next = node
node.next = cur
cur.prev = node
"""遍历整个链表"""
def travel(self):
cur = self.__head
while cur != None:
print(cur.elem, end=" ")
cur = cur.next
print("")
"""根据元素删除节点"""
def remove(self, item):
cur = self.__head
while cur != None:
if cur.elem == item:
# 先判断此结点是否是头节点
# 头节点
if cur == self.__head:
self.__head = cur.next
if cur.next != None:
# 链表不只有一个节点
cur.next.prev = None
else:
cur.prev.next = cur.next
if cur.next != None:
cur.next.prev = cur.prev
return True
else:
cur = cur.next
return False
"""根据元素查找节点是否存在"""
def search(self, item):
cur = self.__head
while cur != None:
if cur.elem == item:
return True
else:
cur = cur.next
return False
2. 实现单链表反转
参考:https://blog.csdn.net/u013109501/article/details/88035186
class Node(object):
def __init__(self, data, next=None):
self.val = data
self.next = next
def fun4(head):
if head == None:
return None
L,M,R = None,None,head
while R.next != None:
L = M
M = R
R = R.next
M.next = L
R.next = M
return R
3. 实现两个有序的链表合并为一个有序链表
参考:https://blog.csdn.net/u013109501/article/details/88037008
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
class Solution:
def mergeTwoLists(self, l1, l2):
"""
:type l1: ListNode
:type l2: ListNode
:rtype: ListNode
"""
if l1 is None and l2 is None:
return None
new_list = ListNode(0)
pre = new_list
while l1 is not None and l2 is not None:
if l1.val < l2.val:
pre.next = l1
l1 = l1.next
else:
pre.next = l2
l2 = l2.next
pre = pre.next
if l1 is not None:
pre.next = l1
else:
pre.next = l2
return new_list.next
4. 实现求链表的中间结点
参考:https://blog.csdn.net/u013109501/article/details/88037655
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
import math
class Solution:
def middleNode(self, head):
# 首先要知道链表一共有多少个结点
count = 0
res = {}
while head != None:
count += 1
res[count] = head
head = head.next
#j = math.ceil(count/2)
#if count % 2 == 0:
# return res[j+1]
#else:
# return res[j]
j = math.ceil((count-1)/2) + 1
return res[j]
练习
1. Linked List Cycle I(环形链表)
英文版:https://leetcode.com/problems/linked-list-cycle/
中文版:https://leetcode-cn.com/problems/linked-list-cycle/
给定一个链表,判断链表中是否有环。
为了表示给定链表中的环,我们使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。 如果 pos 是 -1,则在该链表中没有环。
示例 1:
输入:head = [3,2,0,-4], pos = 1
输出:true
解释:链表中有一个环,其尾部连接到第二个节点。
示例 2:
输入:head = [1,2], pos = 0
输出:true
解释:链表中有一个环,其尾部连接到第一个节点。
示例 3:
输入:head = [1], pos = -1
输出:false
解释:链表中没有环。
解题思路:
- 检查一个结点此前是否被访问过来判断链表是否为环形链表,哈希表: 地址不唯一就返回true。
遍历所有结点并在哈希表中存储每个结点的引用(或内存地址)。如果当前结点为空结点 null(即已检测到链表尾部的下一个结点),那么我们已经遍历完整个链表,并且该链表不是环形链表。如果当前结点的引用已经存在于哈希表中,那么返回 true(即该链表为环形链表)。
复杂度分析
时间复杂度:O(n)O(n)O(n),对于含有 nnn 个元素的链表,我们访问每个元素最多一次。添加一个结点到哈希表中只需要花费 O(1)O(1)O(1) 的时间。
空间复杂度:O(n)O(n)O(n),空间取决于添加到哈希表中的元素数目,最多可以添加 nnn 个元素。
- 节点检查: 检查过的节点被标记为同一个值,下一个节点(未被标记)的值等于该值(要找个奇葩的val,保证和链表中的val都不一样),说明该节点一定在被标记的节点中。也就是有环路。
- 快慢指针: 有环快慢指针必定相遇。(快慢指针,相遇则有环,至于为什么快指针每次走两步?可不可以走三步、四步?数学证明是可以的,但走两步能够更快相遇,更快结束)
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def hasCycle(self, head):
"""
:type head: ListNode
:rtype: bool
"""
slow = fast = head
while slow and fast and fast.next:
slow = slow.next
fast = fast.next.next
if slow == fast:
return True
return False
def hasCycle(self, head):
"""
:type head: ListNode
:rtype: bool
"""
if not head:
return False
l = []
while True:
if id(head) in l:
return True
l.append(id(head))
head = head.next
if head is None:
return False
def hasCycle(self, head):
"""
:type head: ListNode
:rtype: bool
"""
save = set()
cur = head
while cur is not None:
if cur in save:
return True
else:
save.add(cur)
cur = cur.next
return False
def hasCycle(self, head):
"""
:type head: ListNode
:rtype: bool
"""
list_id = []
while head:
if id(head) in list_id:
return True
list_id.append(id(head))
head = head.next
return False
2. Merge k Sorted Lists(合并 k 个排序链表)
英文版:https://leetcode.com/problems/merge-k-sorted-lists/
中文版:https://leetcode-cn.com/problems/merge-k-sorted-lists/
合并 k 个排序链表,返回合并后的排序链表。请分析和描述算法的复杂度。
示例:
输入:
[
1->4->5,
1->3->4,
2->6
]
输出: 1->1->2->3->4->4->5->6
解题思路
- 优先级队列
- 链表两两合并
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def mergeKLists(self, lists: List[ListNode]) -> ListNode:
import heapq
dummy = ListNode(0)
p = dummy
head = []
for i in range(len(lists)):
if lists[i] :
heapq.heappush(head, (lists[i].val, i))
lists[i] = lists[i].next
while head:
val, idx = heapq.heappop(head)
p.next = ListNode(val)
p = p.next
if lists[idx]:
heapq.heappush(head, (lists[idx].val, idx))
lists[idx] = lists[idx].next
return dummy.next
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def mergeKLists(self, lists: List[ListNode]) -> ListNode:
if not lists:return
n = len(lists)
return self.merge(lists, 0, n-1)
def merge(self,lists, left, right):
if left == right:
return lists[left]
mid = left + (right - left) // 2
l1 = self.merge(lists, left, mid)
l2 = self.merge(lists, mid+1, right)
return self.mergeTwoLists(l1, l2)
def mergeTwoLists(self,l1, l2):
if not l1:return l2
if not l2:return l1
if l1.val < l2.val:
l1.next = self.mergeTwoLists(l1.next, l2)
return l1
else:
l2.next = self.mergeTwoLists(l1, l2.next)
return l2