数据结构-单链表

最新推荐文章于 2024-07-18 00:08:52 发布
最新推荐文章于 2024-07-18 00:08:52 发布
阅读量472 收藏 2
点赞数
分类专栏： 笔记&记录 文章标签： 数据结构 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/keilert/article/details/126402947
版权

文章目录

链表概念

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。

单链表声明 LinkList.h

#include <stdio.h>
#include <stdlib.h>

#ifndef _LINKLIST_H
#define _LINKLIST_H
typedef int Status;  //Status类型就是int型
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -1

typedef int ElemType;   //结点的元素类型为int型
typedef struct LNode{   //单链表的结构体
 	ElemType   data;  //数据域，存储本结点的信息（数据）
 	struct LNode  *next;  //指针域，指向下一个结点的地址
}LNode, *LinkList;
//1、初始化单链表，就是创建出头结点
Status InitList_Link(LinkList &L);
//（2）判断一个链表是否是空表ListEmpty_Link
Status ListEmpty_Link(LinkList L);
//（3）求长度：ListLength_Link
int ListLength_Link_1(LinkList L); //方法一：p从L开始，即头结点
int ListLength_Link_2(LinkList L); //方法二：p从L->next开始，即第一个真正的元素结点
//（4）取第i个元素的值：GetElem_List
Status GetElem_List(LinkList L,int i,ElemType &e);
（5）向第i个位置上插入结点，值为e
Status ListInsert_Link(LinkList &L,int i,ElemType e);
//（6）删除第i个结点，注意如果i值太大或太小，删除失败，返回ERROR
Status ListDelete_Link(LinkList &L,int i,ElemType &e);
//（7）构造链表
 //方法一：每次插入到最末尾，向尾生长，所得到的顺序与插入时的元素顺序一致。
Status CreateList_Link_Rear(LinkList &L,ElemType a[],int n);
 //方法二：每次插入到第1个结点，就是直接插入到头结点之后，向头生长，所得到的顺序与插入时的元素顺序相反
Status CreateList_Link_Head(LinkList &L,ElemType a[],int n);
//（8）遍历链表：从表头到表尾，一个一个结点进行访问
Status TraverseList_Link(LinkList L);
//（9）查找：从链表L中查找与指定元素x相同的结点，如果存在，返回该结点指针，如果不存在，返回NULL
LinkList SearchList_Link(LinkList L,ElemType x);
//（10）清空：将链表L清空，就是将L变成一个空表
//方法一：调用前面的Delete函数，每次删除表头结点（就是删除第一个结点），这样，删除了第一个结点后，原来的第二个结点就变成了新的第一个结点，以此类推，一直删除下去，直到链表为空：
Status ClearList_Link_1(LinkList &L);
//方法二：每次都删除第1个结点，直到链表为空
Status ClearList_Link_2(LinkList &L);
//（11）销毁：销毁链表L
Status DestroyList_Link(LinkList &L);
//逆置单链表L
Status InverseList_Link(LinkList &L);

#endif

单链表定义

初始化单链表的头结点 InitList_Link

//1、初始化单链表的头结点
Status InitList_Link(LinkList &L)
{
	L=(LinkList)malloc(sizeof(LNode));	
	L->next=NULL;  //因为L是指针，所以用->符号，也可以用：
 	//(*L).next=NULL;
 	return OK;
}

判断一个链表是否是空表ListEmpty_Link

//（2）判断一个链表是否是空表ListEmpty_Link
Status ListEmpty_Link(LinkList L)
{
 return L->next==NULL ? TRUE : FALSE;
}

求链表长度：ListLength_Link

代码如下（示例）：

//（3）求长度：ListLength_Link
Status ListLength_Link_1(LinkList L) //方法一：p从L开始，即头结点
{
 	int n=0;
 	LinkList p=L;
 	while(p->next!=NULL)
 	{
 		n++;
  		p=p->next;
 	}
 	return n;
}
Status ListLength_Link_2(LinkList L) //方法二：p从L->next开始，即第一个真正的元素结点
{
 	int n=0;
 	LinkList p=L->next;
 	while(p!=NULL)
 	{
	  	n++;
	  	p=p->next;
 	}
 	return n;
}

取第i个元素的值：GetElem_List

Status GetElem_List(LinkList L,int i,ElemType &e)
{
	LinkList p;
 	int n;
 	p=L;
 	n=0;
 	while(p->next!=NULL && n<i)
 	{
	  	p=p->next;
	  	n++;
	 }
	 if(n<i)
	  	return  ERROR;
	 e=p->data;	//获取的值
	 return  OK;
}

向第i个位置上插入结点，值为e

Status ListInsert_Link(LinkList &L,int i,ElemType e)
{ //向链表L的第i个位置插入元素e
 	 LinkList p;
	 int n;
	 p=L;
	 n=0;
	 while(p!=NULL && n<i-1) //寻找p，让p指向第i-1个元素
	 {
		  p=p->next;
		  n++;
	 }
	 if(p==NULL || n>=i)  //i的值太大或太小，插入位置非法
	 	 return ERROR;
	 LinkList s;
	 s=(LinkList)malloc(sizeof(LNode));
	 s->data=e;
	 s->next=p->next;
	 p->next=s;
	 return OK;
}

删除第i个结点

//（6）删除第i个结点，注意如果i值太大或太小，删除失败，返回ERROR
Status ListDelete_Link(LinkList &L,int i,ElemType &e)
{
	 //先找到第i-1个结点，由p指向它
	 LinkList p,s;
	 int n;
	 p=L;
	 n=0;
	 while(p!=NULL && n<i-1) //寻找p，让p指向第i-1个元素
	 {
		  p=p->next;
		  n++;
	 }
	 if(p->next==NULL || n>i-1) //如果i的值太大或太小，无法删除
	  	return ERROR;
	 s=p->next;
	 p->next=s->next;
	 e=s->data;
	 free(s);
	 return OK;
	}

构造链表

//方法一：每次插入到最末尾，向尾生长，所得到的顺序与插入时的元素顺序一致。
Status CreateList_Link_Rear(LinkList &L,ElemType a[],int n)
{ //向尾生长方式，将有n个元素的数组a中的元素生成链表L
	 L=(LinkList)malloc(sizeof(LNode));
	 L->next=NULL;
	 LinkList p=L;  //让p始终指向表尾，方便插入操作
	 LinkList s;
	 int i;
	 for(i=0;i<n;i++)
	 {
		  s=(LinkList)malloc(sizeof(LNode));
		  s->data=a[i];
		  s->next=NULL;
		  p->next=s;
		  p=s;
	 }
	 return OK;
}
 //方法二：每次插入到第1个结点，就是直接插入到头结点之后，向头生长，所得到的顺序与插入时的元素顺序相反
Status CreateList_Link_Head(LinkList &L,ElemType a[],int n)
{ //向头生长方式，将有n个元素的数组a中的元素生成链表L
	 L=(LinkList)malloc(sizeof(LNode));
	 L->next=NULL;
	 LinkList s;
	 int i;
	 for(i=0;i<n;i++)
 	 {
		  s=(LinkList)malloc(sizeof(LNode)); //生成新结点
		  s->data=a[i];
		  s->next=L->next;     //s作为第一个结点，就是直接插入到头结点的后面
		  L->next=s;
	 }
	 return OK;
}

遍历链表

//（8）遍历链表：从表头到表尾，一个一个结点进行访问
Status TraverseList_Link(LinkList L)
{
	 LinkList p=L->next;
	 while(p!=NULL)
	 {
	  printf("%5d",p->data);  //输出p的值
	  p=p->next;
	 }
	 putchar('\n');
 	return OK;
}

查找

//（9）查找：从链表L中查找与指定元素x相同的结点，如果存在，返回该结点指针，如果不存在，返回NULL
LinkList SearchList_Link(LinkList L,ElemType x)
{
 LinkList p=L->next;
 while(p!=NULL)
 {
  if(p->data==x)
   break;
  p=p->next;
 }
 return p;
}

清空：将链表L清空，就是将L变成一个空表

//方法一：调用前面的Delete函数，每次删除表头结点（就是删除第一个结点），这样，删除了第一个结点后，原来的第二个结点就变成了新的第一个结点，以此类推，一直删除下去，直到链表为空：
Status ClearList_Link_1(LinkList &L)
{
 ElemType e;
 while(!ListEmpty_Link(L))  //一直删除，直到链表为空
  ListDelete_Link(L,1,e);  //删除第一个结点
 return OK;
}
//方法二：每次都删除第1个结点，直到链表为空
Status ClearList_Link_2(LinkList &L)
{
 LinkList p=L->next;  //p始终指向第一个结点，就是L后面的
 while(p!=NULL)
 {
  L->next=p->next;  //L->next绕过p，指向p后面的那个结点
  free(p);    //删除p
  p=L->next;    //p始终指向第一个结点，就是L后面的
 }
 return OK;
}

销毁：销毁链表L

Status DestroyList_Link(LinkList &L)
{
 ClearList_Link_1(L);  //先将链表清空
 free(L);     //然后再将头结点释放
 L=NULL;     //释放了的指针，通常应该让它指向NULL
 return OK;
}

逆置单链表L

Status InverseList_Link(LinkList &L)
{
 LinkList M;
 M=(LinkList)malloc(sizeof(LNode)); //先生成一个头结点M
 M->next=NULL;
 LinkList p=L->next;
 while(p!=NULL)
 {
  L->next=p->next; //先让p从L中脱落，就是让L绕过p
  p->next=M->next; //将p结点向头生长插入到M的第一个结点
  M->next=p; 
  p=L->next;   //p又指向L中的第一个结点
 }
 free(L);
 L=M;
 return OK;
}

声明汇总 LinkList.c

#include "LinkList.h"
#include <stdio.h>
#include <stdlib.h>

//1、初始化单链表的头结点
Status InitList_Link(LinkList &L)
{
 L=(LinkList)malloc(sizeof(LNode));
 L->next=NULL;  //因为L是指针，所以用->符号，也可以用：
 //(*L).next=NULL;
 return OK;
}
//（2）判断一个链表是否是空表ListEmpty_Link
Status ListEmpty_Link(LinkList L)
{
 return L->next==NULL ? TRUE : FALSE;
 // return !(L->next);
 // if(L->next==NULL)
 //  return TRUE;
 // else
 //  return FALSE;
}
//（3）求长度：ListLength_Link
Status ListLength_Link_1(LinkList L) //方法一：p从L开始，即头结点
{
 int n=0;
 LinkList p=L;
 while(p->next!=NULL)
 {
  n++;
  p=p->next;
 }
 return n;
}
Status ListLength_Link_2(LinkList L) //方法二：p从L->next开始，即第一个真正的元素结点
{
 int n=0;
 LinkList p=L->next;
 while(p!=NULL)
 {
  n++;
  p=p->next;
 }
 return n;
}
//（4）取第i个元素的值：GetElem_List
Status GetElem_List(LinkList L,int i,ElemType &e)
{
 LinkList p;
 int n;
 p=L;
 n=0;
 while(p->next!=NULL && n<i)
 {
  p=p->next;
  n++;
 }
 if(n<i)
  return  ERROR;
 e=p->data;
 return  OK;
}
//（5）向第i个位置上插入结点，值为e
Status ListInsert_Link(LinkList &L,int i,ElemType e)
{ //向链表L的第i个位置插入元素e
 LinkList p;
 int n;
 p=L;
 n=0;
 while(p!=NULL && n<i-1) //寻找p，让p指向第i-1个元素
 {
  p=p->next;
  n++;
 }
 if(p==NULL || n>=i)  //i的值太大或太小，插入位置非法
  return ERROR;
 LinkList s;
 s=(LinkList)malloc(sizeof(LNode));
 s->data=e;
 s->next=p->next;
 p->next=s;
 return OK;
}
//（6）删除第i个结点，注意如果i值太大或太小，删除失败，返回ERROR
Status ListDelete_Link(LinkList &L,int i,ElemType &e)
{
 //先找到第i-1个结点，由p指向它
 LinkList p,s;
 int n;
 p=L;
 n=0;
 while(p!=NULL && n<i-1) //寻找p，让p指向第i-1个元素
 {
  p=p->next;
  n++;
 }
 if(p->next==NULL || n>i-1) //如果i的值太大或太小，无法删除
  return ERROR;
 s=p->next;
 p->next=s->next;
 e=s->data;
 free(s);
 return OK;
}
//（7）构造链表
 //方法一：每次插入到最末尾，向尾生长，所得到的顺序与插入时的元素顺序一致。
Status CreateList_Link_Rear(LinkList &L,ElemType a[],int n)
{ //向尾生长方式，将有n个元素的数组a中的元素生成链表L
 L=(LinkList)malloc(sizeof(LNode));
 L->next=NULL;
 LinkList p=L;  //让p始终指向表尾，方便插入操作
 LinkList s;
 int i;
 for(i=0;i<n;i++)
 {
  s=(LinkList)malloc(sizeof(LNode));
  s->data=a[i];
  s->next=NULL;
  p->next=s;
  p=s;
 }
 return OK;
}
 //方法二：每次插入到第1个结点，就是直接插入到头结点之后，向头生长，所得到的顺序与插入时的元素顺序相反
Status CreateList_Link_Head(LinkList &L,ElemType a[],int n)
{ //向头生长方式，将有n个元素的数组a中的元素生成链表L
 L=(LinkList)malloc(sizeof(LNode));
 L->next=NULL;
 LinkList s;
 int i;
 for(i=0;i<n;i++)
 {
  s=(LinkList)malloc(sizeof(LNode)); //生成新结点
  s->data=a[i];
  s->next=L->next;     //s作为第一个结点，就是直接插入到头结点的后面
  L->next=s;
 }
 return OK;
}
//（8）遍历链表：从表头到表尾，一个一个结点进行访问
Status TraverseList_Link(LinkList L)
{
 LinkList p=L->next;
 while(p!=NULL)
 {
  printf("%5d",p->data);  //输出p的值
  p=p->next;
 }
 putchar('\n');
 return OK;
}
//（9）查找：从链表L中查找与指定元素x相同的结点，如果存在，返回该结点指针，如果不存在，返回NULL
LinkList SearchList_Link(LinkList L,ElemType x)
{
 LinkList p=L->next;
 while(p!=NULL)
 {
  if(p->data==x)
   break;
  p=p->next;
 }
 return p;
}
//（10）清空：将链表L清空，就是将L变成一个空表
//方法一：调用前面的Delete函数，每次删除表头结点（就是删除第一个结点），这样，删除了第一个结点后，原来的第二个结点就变成了新的第一个结点，以此类推，一直删除下去，直到链表为空：
Status ClearList_Link_1(LinkList &L)
{
 ElemType e;
 while(!ListEmpty_Link(L))  //一直删除，直到链表为空
  ListDelete_Link(L,1,e);  //删除第一个结点
 return OK;
}
//方法二：每次都删除第1个结点，直到链表为空
Status ClearList_Link_2(LinkList &L)
{
 LinkList p=L->next;  //p始终指向第一个结点，就是L后面的
 while(p!=NULL)
 {
  L->next=p->next;  //L->next绕过p，指向p后面的那个结点
  free(p);    //删除p
  p=L->next;    //p始终指向第一个结点，就是L后面的
 }
 return OK;
}
//（11）销毁：销毁链表L
Status DestroyList_Link(LinkList &L)
{
 ClearList_Link_1(L);  //先将链表清空
 free(L);     //然后再将头结点释放
 L=NULL;     //释放了的指针，通常应该让它指向NULL
 return OK;
}
//逆置单链表L
Status InverseList_Link(LinkList &L)
{
 LinkList M;
 M=(LinkList)malloc(sizeof(LNode)); //先生成一个头结点M
 M->next=NULL;
 LinkList p=L->next;
 while(p!=NULL)
 {
  L->next=p->next; //先让p从L中脱落，就是让L绕过p
  p->next=M->next; //将p结点向头生长插入到M的第一个结点
  M->next=p; 
  p=L->next;   //p又指向L中的第一个结点
 }
 free(L);
 L=M;
 return OK;
}
@Hwang
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
[Python]数据结构--链表
Festinatione facit vastum
01-11 616
[Python]数据结构–链表 ‘Festinatione facit vastum’ 链表的概念 单链表的实现 循环单链表的实现 链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另
C++ 链表
m0_62175410的博客
07-26 3万+
C++链表笔记
C++ 数据结构与算法（四）（链表）
chenyfan_blog
02-24 6846
链表 LeetCode 代码随想录
C++ 万字长文，链表详解
jinjiayang的博客
12-02 4789
C++链表详解（包括迭代器，链式存储等诸多干货）
C语言/C++实现链表的详细教程
qq_43884946的博客
06-14 1万+
链表是一种常用的数据结构，它由一系列节点组成，每个节点包含两部分内容：数据和指向下一个节点的指针,最后一个节点指向空。链表的节点可以动态添加和删除，因此可以方便地进行插入、删除等操作。链表有多种类型，包括单向链表、双向链表和循环链表等。
数据结构-单链表-实验报告.rar_C++_tripk8z_单链表_单链表实验_实验报告
09-21
（1）掌握线性表的顺序存储结构； （2）验证单链表及其基本操作的实现； （3）进一步理解算法与程序的关系，能够将单链表算法转换为对应的程序。 1.2 实验要求： （1）用头插法（或尾插法）建立带头结点的单链表； ...
数据结构-单链表的操作
06-28
数据结构-单链表的操作
数据结构-单链表的学习及代码实现
09-03
【数据结构-单链表的学习及代码实现】 单链表是一种基本的数据结构，它由一系列节点组成，每个节点包含数据域和一个指向下一个节点的指针。与数组不同，链表中的元素在内存中并不一定是连续存储的，而是通过指针...
C语言-数据结构-单链表完整程序
10-22
本项目提供的“C语言-数据结构-单链表完整程序”应该包含了上述所有功能的实现，通过学习和实践这个项目，你可以深入理解单链表的工作原理，提升C语言编程能力，并巩固数据结构基础。在实际使用中，可以结合具体的...
数据结构-单链表以及对单链表进行的操作
01-08
数据结构-单链表以及对单链表进行的操作
c++链表（详解版）
热门推荐
slandarer的博客
06-13 21万+
在自学C++的时候，看到好多人都在提链表，于是就自学了一下，看了很多别人的文章，加入了一些自己的理解，做了一下总结
C++数据结构之链表（详解）
suren_jun的博客
10-18 3768
链表的定义一种线性表数据结构。它使用一组任意的存储单元，来存储一组具有相同类型的地址，但是链表一般是内嵌到数据结构中，而数据结构的类型可以是不同的。
c++数据结构——链表
qq_35686734的博客
06-13 2万+
1.链表基础知识： 链表分类：单链表、双链表、循环链表 链表的存储：散乱分布，通过指针域的指针链接在一起 链表的定义：此处给出单链表的c++定义 struct ListNode { int val; // 节点上存储的元素 ListNode *next; // 指向下一个节点的指针 ListNode(int x) : val(x), next(NULL) {} // 节点的构造函数 }; 链表初始化及调用： ListNode* head = new ListNode(5);
利用C++超详细解释数据结构中的链表
Mr.林先生的博客
03-24 2765
链表是一种线性数据结构，它由一系列节点组成，每个节点包含两个部分：数据部分和指针部分。数据部分用来存储节点的数据，指针部分用来指向下一个节点。int val;// 数据部分// 指针部分，指向下一个节点ListNode(int x) : val(x), next(nullptr) {} // 构造函数其中，val表示节点的数据，next指向下一个节点的指针。构造函数用来初始化节点的数据和指针部分。
C++基础语法：链表
baiyechangjiu的博客
08-19 7711
链表是物理存储单元上非连续的，非顺序的存储结构，链表是由一个个结点，通过指针来联系起来的，其中每个结点包含数据和指针： 或者我们采用另一张更加明显的图： 因为在C++语言中，当我们生成一个数组的时候，就要声明数组的长度，如此计算机便会在内存上开辟一个连续的不间断的内存空间来存储数据，因为存在着这样的一种可能，也就是数组所使用的内存空间之后的内存空间已经被使用，所以C++中一旦数组的大小明确了，就不能够再改变了。而且因为数组是存储一系列的同一类型的变量的集合，所以构成数组的每一个元素占用的内.
C++链表
qq_41779169的博客
03-18 4382
链表是由一系列连接在一起的结点构成，其中的每个结点都是一个数据结构。 链表的结点通常是动态分配、使用和删除的，允许链表在程序运行时增大或缩小。如果需要将新信息添加到链表中，则程序只需分配另一个结点并将其插入到系列中。如果需要从链表中删除特定的信息块，则程序将删除包含该信息的结点。 链表对数组和矢量的优点 尽管链表的编码和管理比数组更复杂，但它们有一些明显的优势。首先，链表可以容易地扩大或缩小。实际上，程序员并不需要知道链表中有多少个结点。它们只是根据需要在内存中创建。 有人可能会争辩说，链表并不优于矢量
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
最新发布
铁匠匠匠的博客
07-18 268
可以参考以下视频。
-3 数据结构-单链表-TODO：ReverseLinkList 原地逆转单链表, gCC ）
05-12
下面是使用C语言实现的单链表原地逆转的代码： ```c #include #include struct Node { int data; struct Node* next; }; void reverseList(struct Node** head) { struct Node* prev = NULL; struct Node* ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

@Hwang

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值