C/C++教程

数据结构C语言—线性表【链式存储】动态单链表(malloc动态分配实现)【2021-07-03】

本文主要是介绍数据结构C语言—线性表【链式存储】动态单链表(malloc动态分配实现)【2021-07-03】,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

数据结构C语言—线性表【链式存储】动态单链表(malloc动态分配实现)

  • SingleLinkListMalloc.h
  • SingleLinkListMalloc.c
  • main.c
  • 运行结果示例

SingleLinkListMalloc.h

#define NOEXIST -1
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE 1
#define OVERFLOW 1

typedef int Status;
typedef int DataType;
typedef int *Pt;

typedef struct LNode 
{
	DataType data;//该结点的数据域
	struct LNode* next;//指向下一个结点的指针 
}LNode,*LinkList;//默认带头结点
typedef struct SLinkList
{
	LinkList head,tail;//指向线性单链表头结点和最后一个结点 
	DataType len;//线性单链表中元素的个数,即顺序表长度 
}SLinkList;
/*
Status InsFirst(LinkList h,LinkList s);
Status DelsFirst(LinkList h,LinkList q);
Status Append(LinkList L,LinkList s);
Status Remove(LinkList L,LinkList q);
..........等等,《数据结构》-C语言版——严蔚敏,书37页、38页其余带头结点的线性链表操作函数,不再具体实现,
因为,本代码已经实现了在任意合法位置的插入与删除函数,可以轻易的实现这些省略的函数,故不在重复实现! 
*/
Status Init_SLinkList(SLinkList* S);//初始化一个空的线性表S
void Head_Init_SLinkList(SLinkList* S);//头插法建立线性动态单链表S
void Tail_Init_SLinkList(SLinkList* S);//尾插法建立线性动态单链表S
Status DestoryList(SLinkList* S);//销毁线性表S
void ClearList(SLinkList* S);//清空线性表S

Status IsEmptySLinkList(SLinkList* S);//若S为空表,则返回TRUE,否则返回FALSE
DataType SLinkListLength(SLinkList* S);//返回S中数据元素个数
DataType GetElem(SLinkList* S,DataType i,Pt e);//用e返回S中第i个元素的值,操作成功返回OK,否则返回ERROR
DataType LocateElem(SLinkList* S,DataType e);//返回e在S中的位置,有该数据元素则返回其位置,否则返回0

Status PriorElem(SLinkList* S,DataType e,Pt proe);//若e是S的数据元素,且不是第一个,则用proe返回它的前驱。操作成功返回OK,否则返回-6699
Status NextElem(SLinkList* S,DataType e,Pt nexte);//若e是S的数据元素,且不是最后一个,则用nexte返回它的后继。操作成功返回OK,否则返回-6699
Status SLinkListInsert(SLinkList* S,DataType i,DataType e);//在S第i个位置之前插入新的元素e,S长度加1,成功操作返回OK,否则返回ERROR
DataType SLinkListDelete(SLinkList* S,DataType i,Pt e);//删除S的第i个数据元素,并用e返回其值,S长度减1,操作成功返回删除的值,否则返回ERROR

Status SLinkListTraverse(SLinkList* S);//依次对S每个数据元素调用函数,成功遍历返回OK,否则返回ERROR

SingleLinkListMalloc.c

#include "SingleLinkListMalloc.h"
#include <stdio.h>
Status Init_SLinkList(SLinkList* S)//初始化一个空的线性表S,只创建一个头结点;成功,返回OK,否则返回ERROR 
{
	
	DataType i;
	puts("====开始初始化动态单链表S!====");
	S->head=(LinkList)malloc(sizeof(LNode));//创建一个头结点
	if(S->head!=NULL)
	{
		S->head->next=NULL;//将头结点的指针域赋NULL,因为此时只有头结点 
		S->head->data=0;//头结点的数据域不存元素,只是给定义的变量赋个初始值
		S->tail=S->head;//tail本来要指向最后最后一个结点,而目前只有一个头结点,也让它指向头结点,表示线性动态单链表空状态! 
		S->len=0;//同时把动态单链表长度len置0
		puts("====动态单链表S初始化完成!====");
		return OK;
	}
	else
	{
		puts("动态链表初始化(创建头结点)失败!");
		return ERROR;
	}
}
void Head_Init_SLinkList(SLinkList* S)//头插法建立动态单链表S
{
	DataType n,k,co=0;
	LinkList q;//定义一个q指向新分配且待链入的结点
	fflush(stdin);
	printf("\n开始头插法(以f结束):");
	while(1)
	{
		k=scanf("%d",&n);
		if(k==0)
		{
			break;
		}
		else
		{
			
			q=(LinkList)malloc(sizeof(LNode));
			if(q!=NULL)
			{
				q->data=n;//给分配的结点赋值 
				//下面开始头插法:
				q->next=S->head->next; 
				S->head->next=q;
				co++;
				(S->len)++;//单链表长度加一
				if(co==1)
				{
					S->tail=q;//由于是头插法,因此第一个插入的结点就始终都是最后一个结点,让尾指针指向它 
				}
			}
			else
			{
				puts("头插法创建元素结点失败!");
			}
		}
	}
	fflush(stdin);
}
void Tail_Init_SLinkList(SLinkList* S)//尾插法建立动态单链表S
{
	DataType n,k; 
	LinkList q;//定义一个q指向新分配且待链入的结点
	fflush(stdin);
	printf("\n开始尾插法(以f结束):");
	while(1)
	{
		k=scanf("%d",&n);
		if(k==0)
		{
			break;
		}
		else
		{
			q=(LinkList)malloc(sizeof(LNode));
			if(q!=NULL)
			{
				q->data=n;//给分配的结点赋值 
				//下面开始头插法:
				q->next=S->tail->next; 
				S->tail->next=q;
				(S->len)++;//单链表长度加一
				S->tail=q;//让尾指针指向最后一个结点 
			} 
			else
			{
				puts("尾插法创建元素结点失败!");
			}

		}
	}
	fflush(stdin);
}
Status DestoryList(SLinkList* S)//销毁线性表S
{
	if(S->len==0)
	{
		puts("\n==开始【销毁】静态单链表S!==");	
	}
	else
	{
		puts("\n==开始【销毁】静态单链表S!==");
		LinkList p=S->head->next; //让p指向首元结点,即第一个元素; 
		LinkList q=p;//让q也指向p的所指
		while(p!=NULL)
		{
			q=p->next;//让q保存p位置所指的下一个结点 
			free(p);//释放p所指的结点
			p=q;//让p又指向q的所指 
		} 
		S->len=0;//让表长归0
		S->tail=S->head;//让尾指针指向头结点 
		S->head->next=NULL;
	} 
	free(S->head);
	S->head=NULL;
	puts("==【销毁】静态单链表S完成!==");
	return OK;
}
void ClearList(SLinkList* S)//清空线性表S,使单链表长度为0,只保留头结点,释放其他结点即可 
{
	if(S->len==0)
	{
		puts("\n==开始【清空】静态单链表S!==");
		puts("==【清空】静态单链表S完成!==");	
	}
	else
	{
		puts("\n==开始【清空】静态单链表S!==");
		LinkList p=S->head->next; //让p指向首元结点,即第一个元素; 
		LinkList q=p;//让q也指向p的所指
		while(p!=NULL)
		{
			q=p->next;//让q保存p位置所指的下一个结点 
			free(p);//释放p所指的结点
			p=q;//让p又指向q的所指 
		} 
		S->len=0;//让表长归0
		S->tail=S->head;//让尾指针指向头结点 
		S->head->next=NULL;
		puts("==【清空】静态单链表S完成!==");
	} 
}
Status IsEmptySLinkList(SLinkList* S)//若S为空表,则返回TRUE,否则返回FALSE;表若不存在,返回NOEXIST 
{
	if(S->head==NULL)
	{
		puts("======表不存在!不能判断是否为空表!======");	
		return  NOEXIST;
	} 
	if(S->len==0)
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}
DataType SLinkListLength(SLinkList* S)//返回S中数据元素个数
{
	return S->len; 
}
DataType GetElem(SLinkList* S,DataType i,Pt e)//用e返回S中第i个元素的值,操作成功返回OK,否则返回ERROR
{
	if(IsEmptySLinkList(S)==TRUE)
	{
		printf("\n当前表空,不能查询!\n",i);
		return ERROR;
	}
	if(i>SLinkListLength(S)||i<1) 
	{
		printf("\n当前查询位置%d不合法!\n",i);
		return ERROR;
	}
	LinkList p=S->head->next;
	DataType co=0; 
	while(p!=NULL)
	{
		co++;
		if(co==i)
		{
			*e=p->data; 
			return OK;
		}
		p=p->next;
	}
}
DataType LocateElem(SLinkList* S,DataType e)//返回e在S中的位置,有该数据元素则返回其位置,否则返回0
{
	if(IsEmptySLinkList(S)==TRUE)
	{
		return ERROR;
	}
	LinkList p=S->head->next;
	DataType co=0; 
	while(p!=NULL)
	{
		co++;
		if(p->data==e)
		{
			return co;
		}
		p=p->next;
	}
	return ERROR;
}
Status PriorElem(SLinkList* S,DataType e,Pt proe)//若若e是S的数据元素,且不是第一个,则用proe返回它的前驱。操作成功返回OK,否则返回-6699
{
	if(IsEmptySLinkList(S)==TRUE)
	{
		*proe=-6699; 
		printf("\n当前表S空,不能查询%d的前驱值!\n",e);
		return ERROR;
	}
	if(IsEmptySLinkList(S)!=TRUE&&LocateElem(S,e)==ERROR)
	{
		*proe=-6699; 
		printf("\n值%d不在表S中,无法返回其前驱值!\n",e);
		return ERROR;
	}
	if(LocateElem(S,e)==1)
	{
		*proe=-6699; 
		printf("值%d是表S第一个元素,无前驱值!\n",e);
		return ERROR;
	}
	LinkList p=S->head->next;
	DataType co=0; 
	while(p!=NULL)
	{
		co++;
		if(co==LocateElem(S,e)-1)
		{
			*proe=p->data;
			return OK;
		}
		p=p->next;
	}
}
Status NextElem(SLinkList* S,DataType e,Pt nexte)//若e是S的数据元素,且不是最后一个,则用nexte返回它的后继。操作成功返回OK,否则返回-6699
{
	if(IsEmptySLinkList(S)==TRUE)
	{
		*nexte=-6699; 
		printf("\n当前表S空,不能查询%d的前驱值!\n",e);
		return ERROR;
	}
	if(IsEmptySLinkList(S)!=TRUE&&LocateElem(S,e)==ERROR)
	{
		*nexte=-6699; 
		printf("\n值%d不在表S中,无法返回其前驱值!\n",e);
		return ERROR;
	}
	if(LocateElem(S,e)==S->len)
	{
		*nexte=-6699; 
		printf("值%d是表S最后一个元素,无后继值!\n",e);
		return ERROR;
	}
	LinkList p=S->head->next;
	DataType co=0; 
	while(p!=NULL)
	{
		co++;
		if(co==LocateElem(S,e)+1)
		{
			*nexte=p->data;
			return OK;
		}
		p=p->next;
	}
}
Status SLinkListInsert(SLinkList* S,DataType i,DataType e)//在S第i个位置之前插入新的元素e,S长度加1,成功操作返回OK,否则返回ERROR
{

	if(i>SLinkListLength(S)+1||i<1)
	{
		printf("\n插入位置%d不合法,不能再插入!\n",i);
		return ERROR;
	}
	LinkList p=S->head;
	LinkList q;
	DataType co=-1; 
	q=(LinkList)malloc(sizeof(LNode));//q指向新分配的待插入元素结点; 
	if(q!=NULL)
	{
		q->data=e;
		while(p!=NULL)
		{
			co++;
			if(co==i-1)
			{
				q->next=p->next;
				p->next=q; 
				S->len++;//新插入一个元素结点,长度加一 
				if(i==SLinkListLength(S))
				{
					S->tail=q;//如果待插入的是尾结点,则让尾指针指向它 
				}
				return OK;
			}
			p=p->next;
		}
	}
	else
	{
		puts("待插入元素结点失败!");
	}
}
DataType SLinkListDelete(SLinkList* S,DataType i,Pt e)//删除S的第i个数据元素,并用e返回其值,S长度减1,操作成功返回删除的值,否则返回ERROR
{
	if(SLinkListLength(S)==0) 
	{
		printf("\n当前表S空,不能删除任何值!\n");
		return ERROR;
	}
	if(i>SLinkListLength(S)||i<1)
	{
		printf("\n删除位置%d不合法,不能删除任何值!\n",i);
		return ERROR;
	}
	LinkList p=S->head;
	LinkList q;//指向待删除元素的前一个元素 
	DataType co=-1; 
	while(p!=NULL)
	{
		co++;
		if(co==i-1)
		{
			q=p;
		}
		if(co==i) 
		{
			//此时,p指向要被删除的元素 
			q->next=p->next;
			free(p); 
			S->len--;//新插入一个元素结点,长度加一 
			if(i==SLinkListLength(S))
			{
				S->tail=q;//如果待删除的是尾结点,则让尾指针指向它的前一个元素,即指向q
			}
			return OK;
		}
		p=p->next;
	}
}
Status SLinkListTraverse(SLinkList* S)//依次对LS每个数据元素调用函数,成功遍历返回OK,否则返回ERROR
{
	if(S->head==NULL)
	{
		puts("<===============线性动态单链表S已被销毁!无法遍历检查!===============>");
		return ERROR;
	}
	LinkList p=S->head->next;
	if(S->len==0)
	{
		printf("【遍历检查】|长度:%d|头结点-->NULL\n",S->len);
	}
	else
	{
		printf("【遍历检查】|长度:%d|头结点",S->len);
		while(p!=NULL)
		{
			printf("--->%d",p->data);
			p=p->next;
		}
		printf("-->NULL\n"); 
	}
	return OK;
}

main.c

#include <stdio.h>
#include <stdlib.h>
#include "SingleLinkListMalloc.h"
/* 线性表——链式表(动态单链表)【自编代码】 */
int main() 
{
	SLinkList S;
	DataType i,e,proe,nexte,n;
	Init_SLinkList(&S);
	SLinkListTraverse(&S);
	printf("S中当前元素个数是:%d",SLinkListLength(&S));
	if(IsEmptySLinkList(&S))
	{
		printf("\n======S是空表!======\n");
	}
	else
	{
		printf("\n======S不是空表!======\n");
	}

	Tail_Init_SLinkList(&S);
	SLinkListTraverse(&S);
//	printf("尾结点元素值:%d\n",S.tail->data);
	printf("S中当前元素个数是:%d\n",SLinkListLength(&S));
	if(IsEmptySLinkList(&S))
	{
		printf("\n======S是空表!======\n");
	}
	else
	{
		printf("\n======S不是空表!======\n");
	}
	printf("请输入要查询的位置:");
	scanf("%d",&i); 
	if(GetElem(&S,i,&e))
	{
		printf("S表中%d位置值是:%d\n",i,e);
	}

	printf("请输入要查询位置的值:");
	scanf("%d",&n); 
	if(LocateElem(&S,n)!=ERROR)
	{
		printf("\nS表中值%d所在位置是:%d\n",n,LocateElem(&S,n));
	}
	else
	{
		if(IsEmptySLinkList(&S)==TRUE)
		{
			printf("\n当前表空,不能查询%d的位置!\n",n);
		}
		else
		{
			printf("\n值%d的不在表中,可以加入表中!\n",n);
		}
	}

	printf("请输入要返回其前驱的元素值:");
	scanf("%d",&e); 
	if(PriorElem(&S,e,&proe)!=ERROR)
	{
		printf("值%d的前驱值是:%d\n",e,proe);	
	} 

	printf("请输入要返回其后继的元素值:");
	scanf("%d",&e); 
	if(NextElem(&S,e,&nexte)!=ERROR)
	{
		printf("值%d的后继值是:%d\n",e,nexte);	
	} 

	printf("请输入要插入的位置和值:");
	scanf("%d %d",&i,&e); 
	SLinkListInsert(&S,i,e);
	SLinkListTraverse(&S);
	
//	printf("尾节点是:%d\n",S.tail->data); 
	fflush(stdin);
	printf("请输入要删除的位置:");
	scanf("%d",&i); 
	SLinkListDelete(&S,i,&e); 
	SLinkListTraverse(&S);
	ClearList(&S);
	SLinkListTraverse(&S);
	printf("S中当前元素个数是:%d",SLinkListLength(&S));
	if(IsEmptySLinkList(&S))
	{
		printf("\n======S是空表!======\n");
	}
	else
	{
		printf("\n======S不是空表!======\n");
	}

	Head_Init_SLinkList(&S);
	SLinkListTraverse(&S);
//	printf("尾结点元素值:%d\n",S.tail->data);
	printf("S中当前元素个数是:%d\n",SLinkListLength(&S));
	if(IsEmptySLinkList(&S))
	{
		printf("\n======S是空表!======\n");
	}
	else
	{
		printf("\n======S不是空表!======\n");
	}
	printf("请输入要查询的位置:");
	scanf("%d",&i); 
	if(GetElem(&S,i,&e))
	{
		printf("S表中%d位置值是:%d\n",i,e);
	}

	printf("请输入要查询位置的值:");
	scanf("%d",&n); 
	if(LocateElem(&S,n)!=ERROR)
	{
		printf("\nS表中值%d所在位置是:%d\n",n,LocateElem(&S,n));
	}
	else
	{
		if(IsEmptySLinkList(&S)==TRUE)
		{
			printf("\n当前表空,不能查询%d的位置!\n",n);
		}
		else
		{
			printf("\n值%d的不在表中,可以加入表中!\n",n);
		}
	}

	printf("请输入要返回其前驱的元素值:");
	scanf("%d",&e); 
	if(PriorElem(&S,e,&proe)!=ERROR)
	{
		printf("值%d的前驱值是:%d\n",e,proe);	
	} 

	printf("请输入要返回其后继的元素值:");
	scanf("%d",&e); 
	if(NextElem(&S,e,&nexte)!=ERROR)
	{
		printf("值%d的后继值是:%d\n",e,nexte);	
	} 

	printf("请输入要插入的位置和值:");
	scanf("%d %d",&i,&e); 
	SLinkListInsert(&S,i,e);
	SLinkListTraverse(&S);
	
//	printf("尾节点是:%d\n",S.tail->data); 
	fflush(stdin);
	printf("请输入要删除的位置:");
	scanf("%d",&i); 
	SLinkListDelete(&S,i,&e); 
	SLinkListTraverse(&S);
	ClearList(&S);
	SLinkListTraverse(&S);
	printf("S中当前元素个数是:%d",SLinkListLength(&S));
	if(IsEmptySLinkList(&S))
	{
		printf("\n======S是空表!======\n");
	}
	else
	{
		printf("\n======S不是空表!======\n");
	}
 	DestoryList(&S); 
	SLinkListTraverse(&S);
	system("pause");
	return 0;
}

运行结果示例

在这里插入图片描述


------------------------------------------------------第四次发文章有点激动啊!-----------------------------------------------------
-----------------------------------------------------【数据结构代码自编练习】------------------------------------------------------
----------------------------------------------------------------【TDTX】-----------------------------------------------------------------

这篇关于数据结构C语言—线性表【链式存储】动态单链表(malloc动态分配实现)【2021-07-03】的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!