C语言描述：单向链表的相关操作

最新推荐文章于 2022-07-25 16:38:34 发布
最新推荐文章于 2022-07-25 16:38:34 发布
阅读量398 收藏
点赞数
分类专栏： 数据结构（C语言描述） 文章标签： 单链表 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhenguann/article/details/66473046
版权 


#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct LNode
{
	ElemType data;//有效数据域 
	struct LNode *next;//下一个结点的地址 
}LNode;
typedef LNode* LinkList;//引用链表的参数是头指针，所以把结点型地址命名为LinkList 
//建立空表：为头结点分配内存，头结点的地址域为空 
void InitList(LinkList *L)
{
	*L = (LNode*)malloc(sizeof(LNode));//为头结点分配内存，地址返回链表的头指针 
	if(*L==NULL)    exit(-1);//动态分配内存必须检测返回地址判断是否成功分配 
	(*L)->next = NULL;//头结点地址域为NULL 
}
//销毁单向链表：free(头结点和表头到表尾的所有结点的地址)  
void DestroyList(LinkList *L)
{
	LNode* p;
	while(*L)
	{
		p = (*L)->next;
		free(*L);//free(p)：释放p指向的内存，归还给操作做系统。
		*L = p;  //p变量仍存在，仍旧指向已经恢复自由的原先内存，一般还需要让p=NULL 
	}
}
//清空单链表：free(表头和表尾的所有结点，保留头结点并使其地址域为NULL) 
void ClearList(LinkList *L)
{
	LNode*q,*p = (*L)->next;//指向表头，而不是头结点 
	while(p)
	{
		q = p;
		free(p);
		p = q;
	}
	(*L)->next = NULL;
}
//判断单项链表是否为空 
bool EmptyList(LinkList L)
{
	return L->next?false:true;
}
//返回单向链表的长度 
int LengthList(LinkList L)
{
	LNode* p = L->next;
	int i = 0;//计数器 
	while(p)//数据流 
	{
		i++;
		p = p->next;
	}
	return i;
}
//得到链表某个位置的结点值 
bool GetElem(LinkList L,int i,ElemType* e)
{//1<=i<=length 
	if(i<1)
	{
		printf("i的值不合理！\n");
		return false;
	}
	int j = 0;
	LNode* p = p->next;
	while(p&&j<i-1)//检测i是否>length 
	{
		p = p->next;
		j++;
	}
	if(!p)//pls+1状态是每个循环结束后的最终状态值 
	{
		printf("i的值不合理！\n");
		return false;
	}
	*e = p->data;
	return true; 
}
//在第i个位置前插入新结点：i<=i<=length+1 
bool InsertList(LinkList L,int i,ElemType e)
{//寻找第i-1个结点，满足0<=i-1<=length，i的值自然合理 
	if(i-1<0)
	{
		printf("i的值不合理！\n");
		return false;
	}
	LNode*p = L;//指向头结点 
	int j = 0;
	while(p&&j<i-1)//有两种理解方式：数据流，流下一个计数一次，流i-1次停止 
	{             //p切换指i-1次，直到p指向最后一个结点后停止
		p = p->next; 
		j++;
	}
	if(!p)
	{
		printf("i的值不合理！\n");
		return false;
	}//p指向第i-1个结点 
	LNode* q;
	q = (LNode*)malloc(sizeof(LNode));//构建要插入的新结点 
	q->data = e;
	q->next = p->next;//新节点保存第i个的地址 
	p->next = q;//第i-1个结点保存新结点的地址 
	return true; 
} 
//删除某个位置的结点：1<=i<=length 
bool DeleteList(LinkList L,int i,ElemType *e)
{//寻找第i-1个结点 0<=i<=length-1 
	if(i-1<0)
	{
		printf("i的值不合理！\n");
		return false;
	}
	LNode* p = L;
	int j = 0;
	while(p&&j<i-1)
	{
		p = p->next;
		j++;
	}
	if(!p||p->next==NULL)//pls+1或指向最后一个结点说明i值不合理 
	{
		printf("i的值不合理！\n");
		return false;
	}
	p->next = p->next->next;
	return true;
	
}
int LocateList(LinkList L,ElemType e)
{
    int i = 1;
	LNode*p = L->next;
	while(p)//数据流 
	{
		if(p->data==e)
		return i;
		p = p->next;//满足切换下一个数据的要求，如果p=p->next->next，是跳跃切换 
		i++;
	}
	if(!p)
	return 0;
}
void TraverseList(LinkList L)
{
	LNode* p = L->next;
	while(p)
	{
		printf("%d  ",p->data);
		p = p->next;
	}
	printf("\n");
}
// 输入n个元素的值，依次插在表头，建立带头结点结构的单向链表L 
 void CreateList(LinkList *L,int n) 
 { 
   int i;
   LinkList p;
   *L=(LinkList)malloc(sizeof(struct LNode));
   (*L)->next=NULL; //为头结点分配内存 
   printf("请输入%d个数据\n",n);
   for(i=n;i>0;--i)
   {
     p=(LinkList)malloc(sizeof(struct LNode)); 
     scanf("%d",&p->data); 
     p->next=(*L)->next; 
     (*L)->next=p;
   }
 }
//输入n个元素的值，依次插在表尾，建立带表头结构的单链线性表 
 void CreateList2(LinkList *L,int n)
 { 
   int i;
   LinkList p,q;
   *L=(LinkList)malloc(sizeof(struct LNode)); // 生成头结点 
   (*L)->next=NULL;
   q=*L;//q指向表尾 
   printf("请输入%d个数据\n",n);
   for(i=1;i<=n;i++)
   {
     p=(LinkList)malloc(sizeof(struct LNode));
     scanf("%d",&p->data);
     q->next=p;
     q=q->next;//q始终指向表尾 
   }
   p->next=NULL;
 }
 //已知单向链表La和Lb的元素按值非递减排列。
 //归并La和Lb得到新的单链线性表Lc，Lc的元素也按值非递减排列 
void MergeList(LinkList La,LinkList *Lb,LinkList *Lc)
 { 
   LinkList pa=La->next,pb=(*Lb)->next,pc;
   *Lc=pc=La; 
   while(pa&&pb)
     if(pa->data<=pb->data)
     {
       pc->next=pa;
       pc=pa;
       pa=pa->next;
     }
     else
     {
       pc->next=pb;
       pc=pb;
       pb=pb->next;
     }
   pc->next=pa?pa:pb; 
   free(*Lb); 
   Lb=NULL;
 }
 /********************************************************************
 int main()//测试MergeList
 {
   int n=5;
   LinkList La,Lb,Lc;
   printf("按非递减顺序, ");
   CreateList2(&La,n); // 正位序输入n个元素的值 
   printf("La="); 
   TraverseList(La);
   printf("按非递增顺序, ");
   CreateList(&Lb,n); 
   printf("Lb="); 
   TraverseList(Lb);
   MergeList(La,&Lb,&Lc); 
   printf("Lc="); 
   TraverseList(Lc);
   return 0;
 }
 ************************************************************/
int main()
{
	LinkList L;
	ElemType e;
	InitList(&L);
	int i;
	for(i=1;i<5;i++)
	{
		InsertList(L,i,i);	
	}
	printf("遍历单向链表\n");
	TraverseList(L);
	printf("在第5个位置插入11\n");
	InsertList(L,5,11);
	printf("遍历单向链表\n");
	TraverseList(L);
	printf("在第7个位置插入100\n");
	InsertList(L,7,100);
	printf("遍历单向链表\n");
	TraverseList(L);
	printf("删除第6个位置结点\n");
	DeleteList(L,6,&e);
	printf("遍历单向链表\n");
	TraverseList(L);
	printf("删除第0个位置结点\n");
	DeleteList(L,0,&e);
	printf("遍历单向链表\n");
	TraverseList(L);
	DeleteList(L,5,&e);
	printf("遍历单向链表\n");
	TraverseList(L);
}

先找到课本，熟悉单向链表的结构；         关键词： 头结点，头指针，表头，表尾，数据域，地址域（指针域）
1，生成空表销毁链表               2，清空链表                 3，是否为空表               4，表长                  5，查找第i个结点的值
6，查找第一个等于e的结点在链表的位置                      7，插入                         8，删除                    9，遍历                             10，正序插入结点到单链表                               11，逆序插入结点到单链表                   12，将两个有序链表合并成一个有序链表
13，测试10，11，12的MAIN函数                  14，测试1-9的MAIN函数


练习题   （1）合并La，Lb，去掉重复结点
             （2）排序单向链表
#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct LNode
{
	ElemType data;//有效数据域 
	struct LNode *next;//下一个结点的地址 
}LNode;
typedef LNode* LinkList;//引用链表的参数是头指针，所以把结点型地址命名为LinkList 
//建立空表：为头结点分配内存，头结点的地址域为空 
void InitList(LinkList *L)
{
	*L = (LNode*)malloc(sizeof(LNode));//为头结点分配内存，地址返回链表的头指针 
	if(*L==NULL)    exit(-1);//动态分配内存必须检测返回地址判断是否成功分配 
	(*L)->next = NULL;//头结点地址域为NULL 
}
//销毁单向链表：free(头结点和表头到表尾的所有结点的地址)  
void DestroyList(LinkList *L)
{
	LNode* p;
	while(*L)
	{
		p = (*L)->next;
		free(*L);//free(p)：释放p指向的内存，归还给操作做系统。
		*L = p;  //p变量仍存在，仍旧指向已经恢复自由的原先内存，一般还需要让p=NULL 
	}
}
//清空单链表：free(表头和表尾的所有结点，保留头结点并使其地址域为NULL) 
void ClearList(LinkList *L)
{
	LNode*q,*p = (*L)->next;//指向表头，而不是头结点 
	while(p)
	{
		q = p;
		free(p);
		p = q;
	}
	(*L)->next = NULL;
}
//判断单项链表是否为空 
bool EmptyList(LinkList L)
{
	return L->next?false:true;
}
//返回单向链表的长度 
int LengthList(LinkList L)
{
	LNode* p = L->next;
	int i = 0;//计数器 
	while(p)//数据流 
	{
		i++;
		p = p->next;
	}
	return i;
}
//得到链表某个位置的结点值 
bool GetElem(LinkList L,int i,ElemType* e)
{//1<=i<=length 
	if(i<1)
	{
		printf("i的值不合理！\n");
		return false;
	}
	int j = 0;
	LNode* p = p->next;
	while(p&&j<i-1)//检测i是否>length 
	{
		p = p->next;
		j++;
	}
	if(!p)//pls+1状态是每个循环结束后的最终状态值 
	{
		printf("i的值不合理！\n");
		return false;
	}
	*e = p->data;
	return true; 
}
//在第i个位置前插入新结点：i<=i<=length+1 
bool InsertList(LinkList L,int i,ElemType e)
{//寻找第i-1个结点，满足0<=i-1<=length，i的值自然合理 
	if(i-1<0)
	{
		printf("i的值不合理！\n");
		return false;
	}
	LNode*p = L;//指向头结点 
	int j = 0;
	while(p&&j<i-1)//有两种理解方式：数据流，流下一个计数一次，流i-1次停止 
	{             //p切换指i-1次，直到p指向最后一个结点后停止
		p = p->next; 
		j++;
	}
	if(!p)
	{
		printf("i的值不合理！\n");
		return false;
	}//p指向第i-1个结点 
	LNode* q;
	q = (LNode*)malloc(sizeof(LNode));//构建要插入的新结点 
	q->data = e;
	q->next = p->next;//新节点保存第i个的地址 
	p->next = q;//第i-1个结点保存新结点的地址 
	return true; 
} 
//删除某个位置的结点：1<=i<=length 
bool DeleteList(LinkList L,int i,ElemType *e)
{//寻找第i-1个结点 0<=i<=length-1 
	if(i-1<0)
	{
		printf("i的值不合理！\n");
		return false;
	}
	LNode* p = L;
	int j = 0;
	while(p&&j<i-1)
	{
		p = p->next;
		j++;
	}
	if(!p||p->next==NULL)//pls+1或指向最后一个结点说明i值不合理 
	{
		printf("i的值不合理！\n");
		return false;
	}
	p->next = p->next->next;
	return true;
	
}
int LocateList(LinkList L,ElemType e)
{
    int i = 1;
	LNode*p = L->next;
	while(p)//数据流 
	{
		if(p->data==e)
		return i;
		p = p->next;//满足切换下一个数据的要求，如果p=p->next->next，是跳跃切换 
		i++;
	}
	if(!p)
	return 0;
}
void TraverseList(LinkList L)
{
	LNode* p = L->next;
	while(p)
	{
		printf("%d  ",p->data);
		p = p->next;
	}
	printf("\n");
}
// 输入n个元素的值，依次插在表头，建立带头结点结构的单向链表L 
 void CreateList(LinkList *L,int n) 
 { 
   int i;
   LinkList p;
   *L=(LinkList)malloc(sizeof(struct LNode));
   (*L)->next=NULL; //为头结点分配内存 
   printf("请输入%d个数据\n",n);
   for(i=n;i>0;--i)
   {
     p=(LinkList)malloc(sizeof(struct LNode)); 
     scanf("%d",&p->data); 
     p->next=(*L)->next; 
     (*L)->next=p;
   }
 }
//输入n个元素的值，依次插在表尾，建立带表头结构的单链线性表 
 void CreateList2(LinkList *L,int n)
 { 
   int i;
   LinkList p,q;
   *L=(LinkList)malloc(sizeof(struct LNode)); // 生成头结点 
   (*L)->next=NULL;
   q=*L;//q指向表尾 
   printf("请输入%d个数据\n",n);
   for(i=1;i<=n;i++)
   {
     p=(LinkList)malloc(sizeof(struct LNode));
     scanf("%d",&p->data);
     q->next=p;
     q=q->next;//q始终指向表尾 
   }
   p->next=NULL;
 }
 //已知单向链表La和Lb的元素按值非递减排列。
 //归并La和Lb得到新的单链线性表Lc，Lc的元素也按值非递减排列 
void MergeList(LinkList La,LinkList *Lb,LinkList *Lc)
 { 
   LinkList pa=La->next,pb=(*Lb)->next,pc;
   *Lc=pc=La; 
   while(pa&&pb)
     if(pa->data<=pb->data)
     {
       pc->next=pa;
       pc=pa;
       pa=pa->next;
     }
     else
     {
       pc->next=pb;
       pc=pb;
       pb=pb->next;
     }
   pc->next=pa?pa:pb; 
   free(*Lb); 
   Lb=NULL;
 }
 /********************************************************************
 int main()//测试MergeList
 {
   int n=5;
   LinkList La,Lb,Lc;
   printf("按非递减顺序, ");
   CreateList2(&La,n); // 正位序输入n个元素的值 
   printf("La="); 
   TraverseList(La);
   printf("按非递增顺序, ");
   CreateList(&Lb,n); 
   printf("Lb="); 
   TraverseList(Lb);
   MergeList(La,&Lb,&Lc); 
   printf("Lc="); 
   TraverseList(Lc);
   return 0;
 }
 ************************************************************/
int main()
{
	LinkList L;
	ElemType e;
	InitList(&L);
	int i;
	for(i=1;i<5;i++)
	{
		InsertList(L,i,i);	
	}
	printf("遍历单向链表\n");
	TraverseList(L);
	printf("在第5个位置插入11\n");
	InsertList(L,5,11);
	printf("遍历单向链表\n");
	TraverseList(L);
	printf("在第7个位置插入100\n");
	InsertList(L,7,100);
	printf("遍历单向链表\n");
	TraverseList(L);
	printf("删除第6个位置结点\n");
	DeleteList(L,6,&e);
	printf("遍历单向链表\n");
	TraverseList(L);
	printf("删除第0个位置结点\n");
	DeleteList(L,0,&e);
	printf("遍历单向链表\n");
	TraverseList(L);
	DeleteList(L,5,&e);
	printf("遍历单向链表\n");
	TraverseList(L);
}

JoyeeHe
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现单向链表及操作
03-24
数据结构，c语言实现的单向链表。代码分享 struct LinkNode { int data; struct LinkNode *next; }; typedef struct LinkNode *Lnode;
L=(Linklist)malloc(sizeof(Node))含义
热门推荐
weixin_41845265的博客
08-16 1万+
sizeof函数计算数据（包bai括数组、变量、du类型、结构体等）所占内存空间，用zhi字节数表示。 malloc函数用于在内存开辟了一段地址，而这段地址的首地址存在返回的那个指针变量里，由于不知道到底这段地址有多长，可以存什么变量，所以它的类型是空的，你可以强制类型转换，使其变成确定长度，固定存放一种数据类型的地址，而不管它是哪种类型，其首地址还是原来那个，还是存在一个指针变量中，指针变量就是放指针的嘛，指针是一个地址，指针变量是一个我们定义的，用来放那个地址的变量。 那么代码的意思就是说 获取Node
数据结构 - 线性表的链式表示和实现
如图所示
07-25 743
数据结构 - 线性表的链式表示和实现
正逆序建立单链表（第二章 P30 算法2.11）
但行好事，莫问前程
03-16 1633
正逆序建立单链表 typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */ typedef int ElemType; #include<malloc.h> /* malloc()等 */ #include<...
单链表
yanjiahong01的专栏
10-03 625
#include #include using namespace std; #define OK 1 #define ERROR 0 typedef int Status; typedef int ElemType; //-------------单链表的存储结构-------------------- typedef struct LNode {  ElemType dat
数据结构1
shiyuan的专栏
09-19 1197
ＣＣＮＵ开课了，听了几节课，感觉神马都不会。。。。。 上了一节实验课，酱油，就敲了个结构体，初始化，啥都没敲出来，郁闷 然后开学了，各种无聊，但是感觉没时间搞ＡＣＭ了。 坐了一晚上，终于搞定了实验一。。。累啊 先敲完了十二个基本的函数： 顺序表： //代码很搓，大神请绕行，请勿鄙视 #include #include #include using namespace
C语言单向链表的表示与实现实例详解
12-31
C语言中的单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。 链表中最简单的一种是单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向列表中的...
数据结构与算法:单向链表实现与封装
08-26
今天，我们将介绍如何使用C语言实现单向链表的实现与封装。 单向链表的实现： 单向链表可以分为单向有头链表和单向无头链表，本文将针对单向有头链表进行实现。单向有头链表的特点是，每个节点都有一个指向下一个...
C语言单向链表的基本操作12个
最新发布
03-06
以上12个操作是理解和操作C语言单向链表的基础。熟练掌握这些操作后，你可以解决更复杂的问题，如二叉树、图等更高级数据结构的问题。在实际编程中，链表常常用于实现队列、栈和哈希表等数据结构，是编程中不可或缺...
C语言之单向链表详解及实例代码
12-31
1，单向链简洁。...根据示例代码中的例子，完成单向链表(single linked list)中的以字符串为数据的链表的插入、删除以及查找，并支持单向链表的反转； 3，代码实现。 #include #include <math.h>
纯c语言单向链表
shanghaisanmao的专栏
11-19 327
/************************************************* * 单链表操作 * **************************************************/ #include #include #define OK 0 #define ERROR (-1) typedef int Status; typedef struc
数据结构 线性链表
ylxy
11-10 723
发现自己敲代码有个习惯……注释写的那么详细干嘛啊。。。以后注意 #include #include typedef struct LNode { int data; struct LNode *next; } LNode,*LinkList; //算法2.11*******31 //逆位序输入n个元素的值，建立带表头结点的单链线性表L void Create
链表（C/C++）
AryCra_07的博客
03-04 905
链表的构建与操作
LinkList L与LinkList *L Lnode与*LinkList的区别
m0_46314516的博客
10-13 7633
typedef struct node { int data; struct node* next; }Lnode,*LinkList; 对于结构体前面加typedef是给结构体起了个别名， struct node=Lnode struct node*=LinkList; Lnode L定义了一个结构体变量 LinkLnode L=Lnode *L=struct node *L定义的是一个指向node结构体的指针L，必须初始化，可以用->指向结构体成员变量 L->data;或者 (
单向链表操作(C++实现)
aaron19890330的专栏
08-17 733
单向链表操作，某司笔试题答案： project1为链表新建，增、删节点，逆转等常规操作； project2为链表数字指定和插入+，-或空格； project3为聚类。 #include<iostream> #include<vector> usingnamespacestd; /*Project1 定义一个单向链表node,每个节点值为int. ...
数据结构笔记——线性表
Wmiracle的博客
10-30 1065
本篇学习笔记包含线性表的定义以及顺序表、链表的代码实现，内容综合各方资料及本人的理解将线性表最基础的理论整合而成。
DS20-练习3-函数题-求单链表元素序号
u011339832的博客
03-21 1887
6-1 (10 分) 本题要求实现一个函数，求带头结点的单链表中元素序号。 函数接口定义： int Locate ( LinkList L, ElemType e); L是带头结点的单链表的头指针，e是要查找的元素值。如果e在单链表中存在，函数Locate返回其序号（序号从1开始）；否则，返回0。 裁判测试程序样例： #include <stdio.h> #include <stdlib.h> typedef int ElemType; typedef struct LNode
单向链表移位
Joway
12-16 1894
结构 第9题 【描述】 输入若干个正整数，输入-1时输入结束，用单向链表组织输入的正整数。定义和调用函数：struct node *createList(void)，建立单向链表，返回指向链表头结点的指针。定义和调用函数：void printList(struct node *head)，输出单向链表。定义和调用函数：int sum(struct node *head)，计算并返回所有结点中
C语言入门：单向链表节点访问与操作详解
在C语言编程入门教程中，单向链表的访问是关键概念之一。单向链表是一种线性数据结构，每个节点包含数据和指向下一个节点的指针。通过头指针（通常是链表的第一个节点），可以逐个访问和操作链表中的元素。以下是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值