算法与数据结构——链表

链表

内存空间是所有程序的公共资源，在一个复杂的系统运行环境下，空闲的内存空间可能散落在内存各处。存储数组的空间必须是连续的，而当数组非常大时，内存可能无法提供如此大的连续空间，此时链表的灵活性优势就体现出来了。

链表是一种线性数据结构，其中的每个元素都是一个节点对象，各个节点通过“引用”相连接。引用记录了下一个节点的内存地址，通过它可以从当前节点访问到下一个节点。

链表的设计使得各个节点可以分散存储在内存各处，它们的内存地址无需连续。

链表的组成单位是节点（node）对象，每个节点都包含两项数据：节点的“值”和指向下一节点的“引用”。

• 链表的首个节点被称为“头结点”，最后一个节点称为“尾节点”。
• 尾节点指向的是“空”，它在Java、C++和Python中分别记为null、nullptr和None。
• 在C、C++、GO和Rust等支持指针的语言中，上述“引用”应被替换为“指针”。

/*链表节点结构体*/
struct ListNode{
	int val;  // 节点值
	ListNode* next;  // 指向下一节点的指针
	ListNode(int x) :val(x), next(nullptr){}  // 构造函数
};

链表节点ListNode除了包含值，还需要额外保存一个引用（指针）。因此在相同数据量下，链表比数组占用更多的内存空间。

链表常用操作#

链表初始化#

建立链表分为两步，第一步是初始化各个节点对象，第二步是构建节点之间的引用关系。初始化完成后，就可以从链表头节点触发，通过指向next依次访问所有节点。

    // 初始化各个节点
        ListNode *n0 = new ListNode(1);
	ListNode *n1 = new ListNode(3);
	ListNode *n2 = new ListNode(2);
	ListNode *n3 = new ListNode(5);
	ListNode *n4 = new ListNode(4);
	// 构建节点之间的引用
	n0->next = n1;
	n1->next = n2;
	n2->next = n3;
	n3->next = n4;

 插入节点#

在链表中插入节点非常容易，我们想在两个节点n0和n1之间插入一个新节点P，则秩序改变两个节点指针即可，时间复杂度为O(1)。

/*在链表pos位置处插入新节点*/
bool insertListNode(ListNode *pos,ListNode * newNode){
	newNode->next = pos->next;
	pos->next = newNode;
	return true;
}

删除节点#

删除节点只需改变一个节点的指针即可

/*删除链表中pos位置之后一个节点*/
bool deleteListNode(ListNode *pos){
	if (pos->next == nullptr)
		return false;
	// 要删除的节点
	ListNode *p = pos->next;
	pos->next = p->next;
	delete p;
	return true;
}

访问节点#

在链表中访问节点的效率较低。需要从头节点出发，诸葛向后遍历，直至找到目标节点。访问链表的第n个节点需要循环n-1轮，时间复杂度为O(n)。

/*访问节点*/
ListNode * acess(ListNode* head, int index){
	if (head == nullptr || index < 0){
		return nullptr;
	}
	for (int i = 0; i < index; i++){
		if (head == nullptr)
			return nullptr;
		head = head->next;
	}
	return head;
}

查找节点#

遍历链表，查找其中值为target的节点，返回该节点在链表中的索引。此过程也属于线性查找。

/*查找节点 返回索引*/
int find(ListNode* head,int target){
	int index = 0;
	while (head != nullptr){
		if (target == head->val)
			return index;
		index++;
		head = head->next;
	}
	return -1;
}

数组链表对比#

由于数组和链表采用了两种相反的存储策略，因此各种性质和操作效率也呈现对立的特点。

	数组	链表
存储方式	连续内存空间	分散内存空间
容量扩展	长度不可变	可灵活拓展
内存效率	元素占用内存少、但可能浪费空间	元素占用内存多
访问元素	O(1)	O(n)
添加元素	O(n)	O(1)
删除元素	O(n)	O(1)

常见链表类型#

常见链表类型包括三种。

• 单向链表：即前面介绍的普通链表。单向链表的节点包含值和指向下一节点的引用 两项数据。我们将首个节点称为头节点，将最后一个节点称为尾节点，尾节点指向空 nullptr。
• 环形链表：如果我们令单向链表的尾节点指向头节点（首尾相接），则得到一个环形链表。在环形链表中，任意节点都可以视作头节点。
• 双向链表：与单向链表相比，双向链表记录了两个方向的引用。双向链表的节点定义同时包含指向后继结点（下一个节点）和前驱节点（前一个节点）的引用（指针）。相较于单向链表，双向链表更具灵活性，可以朝两个方向上遍历链表，但相应的也需要占用更大的内存空间。

/* 双向链表节点结构体 */
struct DListNode {
	int val; // 节点值
	DListNode *next; // 指向后继节点的指针
	DListNode *prev; // 指向前驱节点的指针
	DListNode(int x) : val(x), next(nullptr), prev(nullptr) {} // 构造函数
};

 

链表典型应用#

单向链表通常用于实现栈、队列、哈希表和图等数据结构。

• 栈与队列：当插入和删除操作都在链表的一端进行时，它表现出先进后出的特性，对应栈；当插入操作在链表的一端进行，删除操作在链表的另一端进行，它表现出先进先出的特性，对应队列。
• 哈希表：链式地址是解决哈希冲突的主流方案之一，在该方案中，所有冲突的元素都会被放到一个链表中。
• 图：邻接表是表示图的一种常用方式，其中图的每一个顶点都与一个链表相关联，链表中的每个元素都代表与该顶点相连的其他顶点。

双向链表常用于需要快速查找前一个和后一个元素的场景。

• 高级数据结构：比如在红黑树、B树中，我们需要访问节点的父节点，这可以通过在节点中保存一个指向父节点的引用来实现，类似于双向链表。
• 浏览器历史：在网页浏览器中，当用户点进前进或后退按钮时，浏览器需要知道用户访问过的前一个和后一个网页。双向链表的特性使得这种操作变得简单。
• LRU算法：在缓存淘汰（LRU）算法中，我们需要快速找到最近最少使用的数据，以及支持快速添加和删除节点。这时使用双向链表就非常合适。

环形链表常用于需要周期性操作的场景，比如操作系统的资源调度。

• 时间片轮转调度算法：在操作系统中，时间片轮转调度算法是一种常见的CPU调度算法，它需要对一组线程进行循环。每个进程被赋予一个时间片，当时间片用完时，CPU将切换到下一个进程。这种循环操作可以通过环形链表来实现。
• 数据缓冲区：在某些数据缓冲区的实现中，也可能会使用环形链表。比如在音频、视频播放器中，数据流可能会被分成多个缓冲块并放入一个环形链表，以便实现无缝播放。