文章目录
前言
给出单链表两种程序实现方法,一种是用数组模拟单链表,一种是结构体实现单链表;分析单链表常见的插入、删除、遍历操作;结合Leetcode典型题目,给出头插法、尾插法、双指针的程序实现。
链表
链表是一种线性数据结构,是线性表的一种,内存中用一段不连续的内存空间来存储,每个结点保存下一个相邻结点的地址,以此来实现表的线性结构,像一条链子一样链接在一起。
单链表
单链表顾名思义单向链表,通过每一个结点next域的值可以找到下一个结点的位置,比如下图第二个结点的地址0x34,第一个结点next域保存这个0x34,通过当前结点 next域就能以O(1)的时间复杂度找到下一个结点,如果想要找到上一个结点需要遍历整个链表,时间复杂度是O(n)。
利用数组实现单链表结构
数组实现单链表是一种非常高效的结构,分别建立两个数组,一个数组存放结点的值val,另一个数组存放结点的下一个结点的索引,这两个数组通过索引联系起来。对单链表常见的操作包括插入、删除、遍历(在头部插入一个元素、删除链表中的某个结点、遍历整个链表),现在对数组实现单链表过程进行解释
- 链表初始化
这里为避免对链表中第一个结点的特判,使用带头节点的单链表,并规定头节点head索引是0,空指针的索引是-1
初始化过程就是建立一个头节点,且头节点的next域指向空
void init(){
idx =0 ;
num[idx] = 0;
ne[idx] = -1 ;
}
- 在头部插入一个数据元素
假设在没有插入前,链表如下图所示。除了头节点外,链表中有一个节点。ne[0]为1表示头节点的下一个结点时索引为1的节点。ne[ne[0]]为-1,表示这个节点是链表中最后一个节点。
要实现插入一个元素就要新建立一个结点,这里通过索引来表示结点,将数据元素存入num数组中,再将元素插入链表的头部。插入过程本质是链的链接,这里就是ne[idx] = ne[0];ne[0] = idx;下图表示在头部插入完成后的结果,可以对比前一幅图找到两个数组的区别。
void insert_head(int x){
idx++;
num[idx] = x;
ne[idx] = ne[0];
ne[0] = idx;
}
- 在第k个插入元素之后插入一个元素
这里与头插法相同,首先将结点元素存入num数组,在修改ne数组的值,将其链接到链表中即可。注意,因为链表建立过程中没增加一个结点。索引idx都会自增1,这里第k个插入的数对应索引就是k。num[k]就是第k个插入的元素的大小,ne[k]就是第k个插入的数的下一个结点。
//在第k个插入数后面插入一个数
void insert_k(int k, int x){
idx++;
num[idx] = x;
ne[idx] = ne[k];
ne[k] = idx ;
}
- 删除第k个插入的元素
由于是数组存储链表的结点,数组是开辟的一块连续的空间,这里的删除不是释放内存,只要遍历链表找不到这个结点就可以认为是成功删除,所以只需修改当前结点ne数组中的值,让其变为下个节点的下一个结点的索引。
void del(int k){
ne[k] = ne[ne[k]];
}
- 测试程序
#include<iostream>
using namespace std;
const int N = 100010;
int num[N],ne[N],idx ;
//规定-1表示空指针 头节点的索引为0
void init(){
idx =0 ;
num[idx] = 0;
ne[idx] = -1 ;
}
void insert_head(int x){
idx++;
num[idx] = x;
ne[idx] = ne[0];
ne[0] = idx;
}
//删除第k个插入的数后面的数,第k个插入的数索引是k
void del(int k){
ne[k] = ne[ne[k]];
}
//在第k个插入数后面插入一个数
void insert_k(int k, int x){
idx++;
num[idx] = x;
ne[idx] = ne[k];
ne[k] = idx ;
}
void printList(){
//通过ne数组找到下一个结点
for(int i = ne[0] ; i != -1 ; i = ne[i]){
cout<<num[i]<<" ";
}
}
int main(){
int m;
cin>>m;
init();
while(m--){
char op;
cin>>op;
if(op == 'H'){
int x;
cin>>x;
insert_head(x);
}
else if(op == 'D'){
int k;
cin>>k;
del(k);
}
else{
int k,x;
cin>>k>>x;
insert_k(k,x);
}
}
printList();
}
结构体实现单链表
当学会了数组实现单链表,打开leetcode中链表的题目,发现有这样一段注释,这就要求我们会用结构里的形式实现链表中的插入、删除、遍历等操作,要不然还是写不出来题。
- 在链表头部插入数据元素
新建一个结点->连接到链表中
//建立一个哑结点,这样不用特判链表为空的情况
ListNode *dummy = new ListNode(0,head);
ListNode * p = new ListNode(x);
p->next = dummy->next;
dummy->next = p;
- 删除链表中的某一个结点
为避免特殊处理头节点,添加哑结点,即创建一个新节点指向链表的头部,这样即使是删除头节点也不需要单独处理,最后返回哑节点的next域即可。
遍历找到待删除的结点的前一个结点pre,之后执行删除操作
//遍历找到前一个结点
ListNode *dummy = new ListNode(0,head);
ListNode * pre = dummy ;
ListNode * cur = head;
while(cur != NULL){
//check()根据题目要求改变
if(check(cur)){
pre->next = cur->next;
}
else{
pre = cur;
cur = cur->next ;
}
}
- 链表尾部插入一个元素
遍历找到最后一个结点,用tail标识
ListNode * node = new ListNode(x);
node->next = nullptr;
tail->next = node;
Leetcode典型题目
206.反转链表
解题思路(头插法)
新建一个单链表,采用头插法的方式以此取出原链表的结点,插入到该链表中即可。
实现程序
class Solution {
public:
ListNode* reverseList(ListNode* head) {
//采用头插法实现,每次取出链表中的一个结点,插到链表的头部
ListNode*dummy = new ListNode(0,head);
dummy->next = nullptr;
ListNode * p = head;
while(p != nullptr){
ListNode*cur = p;
p = p->next ;
cur->next = dummy->next;
dummy->next = cur ;
}
return dummy->next;
}
};
运行结果
160.相交链表
解题思路(双指针)
-
定义两个指针,分别从A B两个链表头部开始遍历。
-
一个指针先遍历A再遍历B 另一个指针先遍历B再遍历A 如果有公共结点,零个指针会同时指向同一个结点
实现程序
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
ListNode *p1 = headA;
ListNode *p2 = headB;
int flagA = 0;
int flagB = 0;
while(p1 != NULL && p2 != NULL){
if(p1 == p2) return p1 ;
else{
if(p1->next == NULL && flagA == 0){
p1 = headB ;
flagA = 1;
}
else p1 = p1->next ;
if(p2->next == NULL && flagB == 0){
p2 = headA ;
flagB = 1;
}
else p2 = p2->next ;
}
}
return NULL;
}
};
运行结果
237.删除链表中的结点
解题思路
- 这个题目不知道头节点,因此不同采用从头到尾遍历的方式找到待删除结点的前一个结点,并且题目中说明要删除结点的下一个结点一定不为空
- 我们将下一个结点内容复制过来,无需遍历,以O(1)时间复杂度就能实现。
实现程序
class Solution {
public:
void deleteNode(ListNode* node) {
//题目中提示了不是最后一个节点,因此node->next一定不为空
ListNode*temp = node->next ;
node->val = temp->val ;
node->next = temp->next ;
delete temp ;
}
};
运行结果
21.合并两个有序链表
解题思路(尾插法)
- 非常典型的尾插法,每次取出两个链表中较小的元素,查到结果链表的尾部
- 注意判空,循环完后,如果还有链表不为空,应当拼接到结果链表后面
实现程序
class Solution {
public:
ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
//建立一个新链表,每次都拿过来两个升序链表中的较小值插入到新链表尾部
ListNode*dummy = new ListNode(0,nullptr);
ListNode * p1 = list1;
ListNode * p2 = list2;
ListNode *p3 = dummy ;
while(p1 != nullptr && p2 != nullptr){
if(p1->val <= p2->val){
ListNode *temp = p1 ;
p1 = p1->next;
p3->next = temp ;
temp ->next = nullptr ;
p3 = p3->next ;
}
else{
ListNode *temp = p2 ;
p2 = p2->next ;
p3->next = temp ;
temp ->next = nullptr ;
p3 = p3->next ;
}
}
if(p1 != nullptr) p3->next = p1;
if(p2 != nullptr) p3->next = p2;
return dummy->next;
}
};