数据结构-线性表-链表技巧

最新推荐文章于 2026-08-22 22:05:36 发布
原创 最新推荐文章于 2026-08-22 22:05:36 发布 · 836 阅读 · 14 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
数据结构C语言

当前文章被收录于：

数据结构C语言
4 篇文章 0 人学习

学习笔记

订阅专栏 查看详情

双指针

1.找倒数第x个元素

查找一个单链表的倒数第x个元素，方法很多，这里引出一个极为常用的技巧

双指针

顾名思义，定义两个指针fast，slow

假设找倒数第3个元素，就让fast先走三个节点，再让fast和slow一同前进

当fast为空时，slow正好指向目标节点

对应函数：

int FindLNode(LNode*head, int x){
    //定义双指针
	LNode*fast = head;
	LNode*slow = head;
    //fast先走
	while(x--){
		fast = fast->next;
	}
    //移动fast和slow
	while(fast){
		fast = fast->next;
		slow = slow->next;
	}
    //返回该元素
	return slow->data;
}

2.找两个链表的相交节点

题目

LCR 023. 相交链表 - 力扣（LeetCode）

输出c1节点的数据

以该示例为例

暴力循环也可以，但时间复杂度太高，可以思考能否用双指针这一技巧

还记得上一题的双指针是怎么玩的吗，先让fast走几步，再让fast和slow一起走

这题也一样，让pb指针先走一步，这样pa，pb就对齐了

接下来挨个比较节点是否相同就行（比较的不是节点元素，而是节点地址，即pa和pb是否相同）

总结下来三个步骤：

1.算出快指针要走的步数（A，B长度之差）

2.移动快指针，使两指针对齐

3.遍历比较（比较的是pa和pb）

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    //第一步，算A,B长度差
    int lenA = 0;
    int lenB = 0;
    struct ListNode*pa = headA;
    struct ListNode*pb = headB;
    while(pa->next){
        pa = pa->next;
        lenA++;
    } 
    while(pb->next){
        pb = pb->next;
        lenB++;
    } 
    int n = lenA - lenB;//n是快指针要走的步数
    if(n<0) n*=-1;      //n得是正数
    //第二步移动快指针
    pa = headA;
    pb = headB;
    if(lenA > lenB){       //得判断一下pa,pb谁是快指针
        while(n--){
            pa = pa->next;
        }
    }else{
        while(n--){
            pb = pb->next;
        }
    }
    //第三步遍历比较
    while(pa!=pb){       //出循环后pa,pb要么是同一个节点，要么都是NULL
        pa = pa->next;
        pb = pb->next;
    }
    return pa;
}

能力有限，写的不是很简洁，思路还算清晰，大家可以尝试自行编写优化，到leecode上测试

3.将一个链表从中间分开成两个链表

要求第一个链表长度>=第二个链表长度

定义两个指针，一快一慢

在循环中，快指针每次走两步，慢指针每次走一步

当节点数是偶数时，最后的情况

当节点数时奇数时，最后的情况

由上图可见，循环条件应该是：fast存在 并且 fast->next存在

给出模板，用head1和head2作为头指针

#include<stdio.h>
#include<stdlib.h>
typedef struct node{
	int data;
	struct node*next;
}LNode;

LNode* InitLNode(){ 
	LNode*head = (LNode*)malloc(sizeof(LNode));
	head->next=NULL;               
	return head;                 
}

void CreateLNode(LNode* head, int n){
	LNode*last = head;    
	while(n--){
		LNode*p = (LNode*)malloc(sizeof(LNode));
		p->next = NULL;
		scanf("%d", &p->data);               
		last->next = p;                     
		last = last->next;                  
	} 
}

void FreeLNode(LNode* head){       
	LNode*p=head;               
	while(p){
		LNode*r=p;         
		p=p->next;
		free(r);
	}
}

void Solve(LNode*head, LNode*&head1, LNode*&head2){
	/**************************************/

    /**************************************/
}

void Show(LNode*head1, LNode*head2){
	LNode*p=head1;
    if(!p) printf("空");
	while(p){
		printf("%d ", p->data);
		p=p->next;
	} 
	printf("\n");
	p=head2;
    if(!p) printf("空");
	while(p){
		printf("%d ", p->data);
		p=p->next;
	}
}

int main()
{
	LNode* head = InitLNode();
	int n=0;
	scanf("%d", &n);        
	CreateLNode(head, n);
	
	LNode*head1 = NULL;
	LNode*head2 = NULL;
	Solve(head, head1, head2); 
	
	Show(head1, head2);
    FreeLNode(head);      
	return 0;
}

关键函数

void Solve(LNode*head, LNode*&head1, LNode*&head2){
    //排除特殊情况
	if(!head) return;
	if(!head->next) return;
	//中间分开
	LNode*fast = head;
	LNode*slow = head;
	while(fast && fast->next){
		fast = fast->next->next;
		slow = slow->next;
	}
	head1 = head->next;
	head2 = slow->next;
	slow->next = NULL;
}

数组标记法/哈希标记法

1.

（题目中两个n不一样）

解法：

假设所有数据都<=n

那么定义一个长度为n+1的数组（下标从0到n），初始所有元素为0

然后遍历链表，将每个节点数据的绝对值作为下标，访问数组元素

如果为0，说明这个数据第一次出现，再把0改1

如果为1，说明这个数据已出现过，删去该节点

给出题目模板

#include<stdio.h>
#include<stdlib.h>
typedef struct node{
	int data;
	struct node*next;
}LNode;

LNode* InitLNode(){ 
	LNode*head = (LNode*)malloc(sizeof(LNode));
	head->next=NULL;                
	return head;                    
}

void InsertLNode(LNode*head, int x){
	LNode*p = (LNode*)malloc(sizeof(LNode));
	p->next = NULL;
	p->data = x;
	p->next = head->next;
	head->next = p;
}

void FreeLNode(LNode* head){       //依次释放每个节点的内存空间 
	LNode*p=head;               //p指针用来遍历链表 
	while(p){
		LNode*r=p;            //r指针辅助删除节点 
		p=p->next;
		free(r);
	}
}

void Solve(LNode*head, int x, int*arr){
	/*****************************************/
	
	/*****************************************/
}

void ShowLNode(LNode*head){
	LNode*p=head->next;
	while(p){
		printf("%d ", p->data);
		p=p->next;
	} 
}

int main()
{
	LNode* head = InitLNode();       
	InsertLNode(head, 15);
	InsertLNode(head, -7);
	InsertLNode(head, -15);
	InsertLNode(head, -15);
	InsertLNode(head, 21);
	
	int n = 21;//上界 
	int arr[n+1] = {0}; //数组初始化为0 
	Solve(head, n, arr); 
	 
	ShowLNode(head);
    FreeLNode(head);      //该函数用于释放内存 
	return 0;
}

注：可以用abs(x)表示x的绝对值，但要包含头文件stdlib.h

答案

void Solve(LNode*head, int x, int*arr){
	LNode*p = head->next;//p指针遍历链表 
	LNode*fp = head;     //fp指针指向p前面的节点，这样便于删除操作 
	while(p){
		if(arr[abs(p->data)] == 1){
			//删除节点 
			LNode*r = p; //待删除节点 
			p = p->next; //先把p移动到下一个节点 
			fp->next = p;//连接起来 
			free(r);     //删除 
		}else{
			//下一个
			arr[abs(p->data)] = 1;
			p = p->next; 
			fp = fp->next;
		}
	}
}

三指针

常用于反转链表

head是指向第一个节点的指针，这个链表没用空头节点，如下图

第一步，先修改head所指节点，head->next=pre (pre初始是NULL)

第二步，移动三个指针

将这两步一直循环下去

1

2

1

2

1

2

1

最后一轮循环做到第一步就结束了

这是的head就是新的头节点

leecode代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* reverseList(struct ListNode* head){
    if(!head || !head->next) return head;
    struct ListNode*pre = NULL;
    struct ListNode*nxt = head->next;
    while(head){
        //修改head所指节点
        head->next = pre;
        //移动三个节点
        if(!nxt) break;//最后一轮循环才会执行
        pre = head;
        head = nxt;
        nxt = nxt->next;
    }
    return head;
}

例题1

思路：

1.把链表从中间分开

2.把后半链表反转

3.逐个插入组合

给出模板

#include<stdio.h>
#include<stdlib.h>
typedef struct node{
	int data;
	struct node*next;
}LNode;

LNode* InitLNode(){ //LNode*类型的函数，返回值为头指针head 
	LNode*head = (LNode*)malloc(sizeof(LNode));//为头指针分配大小为一个结点的变量空间 
	head->next=NULL;                //别忘了定义next指针，头节点的data一般不用管 
	return head;                    //返回我们定义的头指针 
}

void CreateLNode(LNode* head, int n){//尾插法 
	LNode*last = head;     //新建尾指针
	while(n--){
		LNode*p = (LNode*)malloc(sizeof(LNode));//新建节点 
		p->next = NULL;
		scanf("%d", &p->data);               //写数据 
		last->next = p;                     //连接 
		last = last->next;                  //更新尾指针 
	} 
}

void FreeLNode(LNode* head){       //依次释放每个节点的内存空间 
	LNode*p=head;               //p指针用来遍历链表 
	while(p){
		LNode*r=p;            //r指针辅助删除节点 
		p=p->next;
		free(r);
	}
}

void Solve(LNode*head){
	/********************************/


    /********************************/
}

void Show(LNode*head){
	LNode*p=head->next;
	while(p){
		printf("%d ", p->data);
		p=p->next;
	}
}

int main()
{
	LNode* head = InitLNode();
	int n=0;
	scanf("%d", &n);        
	CreateLNode(head, n);
	
	Solve(head);  
	
	Show(head);
    FreeLNode(head);      //该函数用于释放内存 
	return 0;
}

关键函数

void Solve(LNode*head){
	if(!head) return;
	if(!head->next) return;
	//中间分开
	LNode*fast = head;
	LNode*slow = head;
	while(fast && fast->next){
		fast = fast->next->next;
		slow = slow->next;
	}
	LNode*newhead = slow->next;
	slow->next = NULL;
	//后半反转 
	LNode*pre=NULL;
	while(newhead){
		LNode*nex=newhead->next;
		newhead->next=pre;
		pre=newhead;
		newhead=nex;
	}
	newhead = pre;
	//见缝插针 
	LNode*p1=head->next;
	LNode*p2=newhead;
	while(p2){
		LNode*p3=p2->next;
		p2->next = p1->next;
		p1->next = p2;
		p1=p2->next;
		p2=p3;
	}
}

例题2

leetcode习题

经典例题

此题要返回环的首个节点，故分为两步

1.判断是否有环

快慢指针，fast每次走两步，slow每次走一步，若两指针能重合，环存在

这里重点要记住while循环的条件fast && fast->next

2.找环的首节点

当fast和slow重合时，此重合节点到环首节点，与head节点到环首节点距离相等

struct ListNode *detectCycle(struct ListNode *head) {
    //排除无节点，单节点情况
    if(!head || !head->next) return NULL;
    //判断是否有环
    struct ListNode*fast = head;
    struct ListNode*slow = head;
    while(fast && fast->next){
        fast = fast->next->next;
        slow = slow->next;
        if(fast == slow) break;
    }
    if(fast != slow) return NULL;         //无环
    //找环的起点
    struct ListNode*p = head;
    while(p!=fast){
        p=p->next;
        fast = fast->next;
    }
    return p;
}

可到leecode上测试

标签
#数据结构 #链表
STM32CUBEMX | STM32L431RCT6的内部Flash操作
yongridada的博客
03-22 5522
一、STM32CUBEMX配置 1、选择芯片型号： 2、配置时钟源 1、 如果选择使用外部高速时钟（HSE），则需要在System Core中配置RCC； 2、 如果使用默认内部时钟（HSI），这一步可以略过； 3、配置时钟树 STM32L4的最高主频到80M，所以配置PLL，最后使HCLK = 80Mhz即可： 4、代码生成设置 点击GENERATE CODE即可生成MDK-V5工程： 二、在MDK中编写、编译、下载用户代码 1、STM32内部Flash及HAL库API 查看所使用芯片的信息，
中级软考（软件攻城狮）第3章知识点——数据结构与数据运算（线性结构+非线性结构）
睡不醒的每天
08-18 163
本文系统梳理了数据结构中的线性与非线性结构。线性部分详细介绍了线性表（顺序/链式存储及时间复杂度对比）、栈（后进先出特性及应用）、队列（循环队列与双端队列）以及串（空串与子串概念）。非线性部分涵盖数组、矩阵、广义表，重点解析了树结构（二叉树性质、存储方式及遍历方法），并深入讲解了最优二叉树（哈夫曼树）的构建原理与编码应用。全文通过图示对比和实例说明，清晰呈现了各类数据结构的特点、存储方式及典型应用场景。
数据结构——线性表（链表，力扣中等篇，技巧型）
2303_77489296的博客
08-25 2329
当链表无序时，去重操作无法像有序链表那样通过简单比较相邻节点来完成，需要借助额外的数据结构来记录已出现过的值。因为链表是排序的，重复元素一定相邻，所以只需比较当前节点和下一个节点的值。思路就是创建两个临时链表，分别存储小于 x 的节点和大于或等于 x 的节点，最后将这两个链表连接起来，保持原有节点的相对顺序。思路2：先将链表连成环，再找到新的头节点位置并断开环，从而完成旋转操作。思路1：将链表分成两个小链表，然后将两个链表交换位置，重新连接即可。不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
六自由度并联Stewart摇摆平台计算
六自由度并联Stewart摇摆平台计算1、Matlab计算程序。2、姿态逆解计算。3、Matlab GUI界面操作和显示，可以动画模拟仿真等运行。4、程序源码有注释。
【数据结构-线性表】顺序表和链表（几种链表操作技巧+几种链表形式）
为了远大的理想，冲锋！
01-30 511
链表的操作 链表中的插入（头插） void *insertNode(ListNode *head, ListNode *node) { node->next = head; head = node; return; } 链表中的插入（尾插） void *insertNode(ListNode *head, ListNode *node) { ListNode *front = head; while(head) { // 备份前一个节点
数据结构（第二版）严蔚敏第二章线性表练习题及答案
＃两个西柚
07-16 7024
第2章 线性表 1．选择题 （1）顺序表中第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是（ ）。 A．110 B．108 C．100 D．120 答案：B 解释：顺序表中的数据连续存储，所以第5个元素的地址为：100+2*4=108。 （2）在n个结点的顺序表中，算法的时间复杂度是O(1)的操作是（ ）。 A．访问第i个结点（1≤i≤n）和求第i个结点的直接前驱（2≤i≤n） B．在第i个结点后插入一个新结点（1≤i≤
数据结构——线性表知识思维导图
＃两个西柚
07-30 3292
此博客主要是线性表部分的知识思维导图 便于对线性表这一章节的知识在脑中形成一个知识体系 具体重要代码实现可以点击 ???? 传送门 一、线性表的定义和基本操作 二、顺序表的定义 三、顺序表的插入删除 四、顺序表的查找 五、单链表的定义 六、单链表的插入与删除 七、单链表的查找与建立 八、双链表 ...
数据结构与算法之线性表（数组、链表、栈、队列）
weixin_45620557的博客
05-22 1305
一篇文章弄懂数据结构中的线性表，包含数组、链表、栈和队列。
考研数据结构之线性表：从基础到实战（附核心考点解析）
m0_73283053的博客
04-10 1353
线性表是具有相同数据类型的n个数据元素的有限序列逻辑特性：除首尾元素外，每个元素有且仅有一个直接前驱和直接后继。数据操作：包括初始化、插入、删除、查找、遍历等核心操作。线性表是考研数据结构的“基石”，其存储结构和操作思想贯穿整个学科。备考时需深入理解顺序表与链表的本质区别，熟练掌握核心算法的实现，并通过大量真题训练提升解题能力。记住：数据结构的学习离不开“动手写代码”，只有在实践中才能真正掌握指针操作、边界处理等细节，为后续复杂数据结构的学习打下坚实基础。
数据结构-链表
qq_52345504的博客
12-14 813
10.22 1、链表的基础知识 （1）链表是最基本的数据结构，是由许多个结点按照逻辑顺序链接起来的（一个结点包含指针域和数据域 指针域存储了下一结点的地址，数据域存储了当前结点的数据） （2）头结点和头指针的区别 a、结构体的基本概念（将相同属性的元素结合在一起 将不同类型的数据放在一起，作为一个整体进行处理 ...
数据结构学习-线性表
weixin_39069034的博客
07-05 164
一、前言： 二、数据结构： 1、数组 2、线性表 3、顺序表 4、顺序表的增删改查
数据结构之线性表
jeekmary的博客
04-06 402
一、线性表 双链表删除元素 删除元素和 增加元素的大忌就是导致引用连断链 s->next = p->next; s->prior = p; p->next = s; s->next->prior = s; 双链表删除元素 s->prior->next = s->next; s->next->prior = s-prior; f...
GXF 3.2.0 to 4.0 CUDA 12 路径 API 与数据结构增量分析
eloudy的专栏
08-18 253
分析范围：以仓库中与分支对比为基础，聚焦）可用的公共 API 与数据结构变化。由于 GXF 核心头文件在各 CUDA 版本间共享，下列新增/修改的接口在 CUDA 12 构建上同样生效。对比链接：https://github.com/NVIDIA-ISAAC-ROS/isaac_ros_nitros/compare/release-3.2…release-4.0。
快速学会数据结构中的链式队列与循环队列
2401_82745609的博客
08-17 542
一种允许从一端插入数据，另外一端删除数据的线性存储结构称为队列。把数据插入的这端称为队列的队尾， 数据删除这端称为队列的队头。插入操作称为入队；删除操作称为出队。先进先出、后进后出数据缓存。
【数据结构】图的应用：最小生成树（Prim / Kruskal）
bianyuan172的博客
08-20 348
摘要：最小生成树（MST）是带权连通无向图中边权总和最小的生成树，常用于网络优化问题。Prim算法从顶点出发，逐步选择连接已选和未选顶点集的最小边，适合稠密图（时间复杂度O(n²)）。Kruskal算法按边权排序后依次选择不构成环的边，适合稀疏图（时间复杂度O(e log e)）。两者均基于贪心策略，但Prim侧重顶点扩张，Kruskal侧重边合并。关键区别在于数据结构（Prim用优先队列，Kruskal用并查集）和适用场景。典型例题需掌握选边过程，记忆口诀为“稠密Prim，稀疏Kruskal”。软考中常考
数据结构 --- 二叉树&哈希表
2401_86288082的博客
08-19 717
本篇数据结构学习笔记分为二叉树、哈希表两大板块。二叉树部分讲解树形基础概念、链式存储方式、前 / 中 / 后序遍历算法，介绍带占位符字符串递归创建二叉树的方法，配套结点计数、深度计算、内存销毁等递归代码实现，补充二叉树核心数学性质。哈希表板块梳理哈希函数、哈希冲突概念，对比开放定址法、链地址法两种冲突解决方案，分析操作的时间复杂度。最后完整给出拉链哈希表五大功能模块的 C 语言实现代码，讲解插入、查找、打印、销毁的执行流程，同时点明现有代码的缺陷与优化方向。
【数据结构】C语言实现链式二叉树
Jupiter1007的博客
08-18 334
本文系统介绍了链式二叉树的实现与操作，包括节点创建、遍历算法（先序、中序、后序、层序）、节点统计（总数、叶子节点、左右子节点）、高度计算、层级节点查询、节点查找、完全二叉树判断、二叉树翻转和销毁等16个核心功能。重点阐述了递归思想在二叉树操作中的应用，并展示了队列在层序遍历和完全二叉树判断中的关键作用。所有操作均通过C语言实现，提供了完整的代码示例，为理解和实现链式二叉树数据结构提供了全面参考。
嵌入式C语言常见考察点（2）
2301_79475128的博客
08-19 173
本文介绍了循环队列实现、 冒泡排序优化、二分查找、 位运算应用、volatile关键字重要性、大小端判断等
第 4 章 数据结构总览：SDMA 在驱动里的实体
图形/计算GPU的驱动与虚拟化技术分享园地
08-18 365
本章将硬件概念映射到SDMA驱动的C数据结构，主要包含三层嵌套关系：芯片级amdgpu_sdma管理所有SDMA实例，实例级amdgpu_sdma_instance对应物理引擎（含GFX和Page两条队列），队列级amdgpu_ring处理具体命令。关键字段包括固件管理、队列状态、中断源、硬件差异抽象（函数指针）等，完整反映了"多实例→双队列"的硬件模型。通过这种层级化设计，驱动实现了对SDMA引擎的精细化控制。
【数据结构】哈希表：构造与冲突处理
最新发布
bianyuan172的博客
08-22 246
文章摘要： 哈希表是一种通过哈希函数直接定位数据的查找结构，核心在于设计哈希函数（如除留余数法）和处理冲突（开放地址法/链地址法）。重点包括：1）除留余数法中质数p的选择；2）线性探测易产生堆积，链地址法效率更稳；3）装填因子α影响查找效率；4）ASL计算（成功/失败）是软考高频考点，需掌握比较次数统计。典型例题展示ASL计算流程，口诀帮助记忆要点。建议重点掌握冲突处理和ASL计算，以应对软考选择与应用题。
数据结构：二叉树
yxg0505的博客
08-18 513
树：由根节点和若干个子节点构成的具有一对多关系的数据的集合，称为树形结构。完全二叉树：在满二叉树基础上，按照从左到右，从上到下依次增加节点的树形结构。二叉树：树的广度为2的树形结构，且各节点的左右子节点不能交换。满二叉树：在不增加层数的情况下，无法再增加一个节点。树的度（数的广度）：树中节点最大的度是该数的广度。K层满二叉树：第K层的节点个数：2^(K-1)叶子节点（终端节点）：向后没有子节点的节点。分支节点（非终端节点）：有子节点的节点。节点的度：节点的子节点个数。叶子节点的节点的度为0。
【数据结构】图的遍历：广度优先搜索（BFS）
bianyuan172的博客
08-19 271
摘要： 广度优先搜索（BFS）是一种基于队列实现的图遍历算法，核心思想是“层层推进”，先访问起点邻接顶点，再逐层扩展。与DFS的纵向深入不同，BFS横向扩展，适合求解无权图最短路径。算法关键点包括：入队时立即标记已访问，避免重复入队；时间复杂度邻接表为O(n+e)，邻接矩阵为O(n²)。BFS生成树具有“矮胖”特性，根到任意顶点的路径为最短路径。典型应用包括连通性判断、二分图检测等。需重点掌握队列实现逻辑及与DFS的对比（如数据结构、遍历顺序等）。软考常考BFS序列模拟及陷阱（如访问标记时机）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值