C语言线性表的链式表示及实现详解

目录
  • 前言
  • 代码实现
    • 1. 单链表的结点构造
    • 2. 构造一个空的头结点
    • 3. 对线性表进行赋值
    • 4.对线性表进行销毁
    • 5.对线性表进行重置
    • 6.判断线性表是否为空
    • 7.获取线性表的长度
    • 8.获取线性表某一位置对应的元素
    • 9.在线性表某一位置插入元素
    • 10.删除线性表某一位置的元素
    • 11.求线性表某一元素的前驱
    • 12.求线性表某一元素的后继
    • 13.打印线性表
  • 运行结果演示
  • 源码

前言

线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素,而线性表的链式存储特点则是用一组任意的存储单元存储线性表的数据元素。这组存储单元既可以是连续的,也可以是不连续的。

对于链式存储的每个数据元素而言,除了存储其本身的信息之外,还需要存储一个指示其直接后继的信息,即直接后继的存储位置。这两部分信息组成了数据元素的存储映像,称为结点

链式存储的结构包含两个域:一个用于存储数据元素的信息,另一个用于存储直接后继的存储位置;存储数据元素信息的域称为数据域存储直接后继存储位置的域称为指针域

图示:

数据结构中,在单链表的开始结点之前一般要附设一个类型相同的结点,称之为头结点头结点的数据域可以不存储任何信息,头结点的指针域存储指向开始结点的指针,即第一个元素结点的存储位置。

附设头结点的作用:

  • 防止单链表是空的而设的。当链表为空的时候,带头结点的头指针就指向头结点,如果当链表为空的时候,单链表没有带头结点,那么它的头指针就为NULL
  • 方便单链表的特殊操作,插入在表头或者删除第一个结点,加入头结点的话就可以保持单链表操作的统一性
  • 当单链表加上头结点之后,无论单链表是否为空,头指针始终指向头结点,因此空表和非空表的处理也就统一了,方便了单链表的操作,也减少了程序的复杂性和出现bug的机会

链式表示要实现的功能:

实现工具:Dev C++

  • 构造一个空的头结点
  • 对线性表进行赋值
  • 对线性表进行销毁
  • 对线性表进行重置
  • 判断线性表是否为空
  • 获取线性表的长度
  • 获取线性表某一位置对应的元素
  • 在线性表某一位置插入元素
  • 删除线性表某一位置的元素
  • 求线性表某一元素的前驱
  • 求线性表某一元素的后继
  • 打印线性表
  • 退出

准备工作:

打开Dev C++后新建一个Source File文件即可 File>new>Source File

代码实现

在实现线性表的链式存储时导入的头文件有

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

在这里我调用windows头文件是为了在后面的代码中修改控制台的名称,在实现线性表的链式存储时真正用到的只有前三个头文件

在写各种函数之前先对一些表示结果状态的字符进行预定义

//函数结果状态代码
#define TRUE     1     //代码中出现TRUE相当于出现了1
#define FALSE    0     //出现FALSE相当于出现了0
#define OK       1     //出现OK相当于出现了1
#define ERROR    0     //出现ERROR相当于出现了0
#define INFEASIBLE    -1
#define OVERFLOW      -2 

typedef int Status;    //定义函数的返回状态
typedef int ElemType;

在这里使用了typedef定义了Status和ElemType为int类型,也就是说之后的代码当中如果出现了Status和ElemType,它们与int作用相同

1. 单链表的结点构造

typedef struct LNode{
	ElemType  data;               //数据域
	struct LNode * next;          //指针域,指向一整个结点(结构体,该结构体中包含数据域和指针域)
}LNode , * LinkList;

代码中的* LinkList指的是结点的类型,在之后的代码中出现了它就相当于出现了指向这个结点的指针

2. 构造一个空的头结点

//构造一个空的头结点
Status InitList_L(LinkList &L){
	L = (LinkList)malloc(sizeof(LNode));      //产生头结点,并使L指向该头结点(L也称头指针)
	if(!L)  return ERROR;          //如果存储空间分配失败,返回ERROR
	L->next = NULL;                //将指针域赋值为NULL
	printf("空的头结点创建成功\n");
	return OK;
}

在该函数传参时一定要在L之前加"&"符号,表示引用传递,保证形参和实参同时改变。之前在写代码时因为没有输入"&"符号,没有使用引用传递也就意味着没有开辟了新的内存空间,所以在之后赋值的时候会出现无法赋值的情况 在这里要强调一点:"->"是一个指针类型的运算符,它是用于指向结构体子数据的指针

3. 对线性表进行赋值

//对线性表进行赋值
Status ValueList_L(LinkList &L,ElemType e){
	LinkList s,p;
	p = L;
	while(p->next){
		p = p->next;
	}
	s = (LinkList)malloc(sizeof(LNode));       //生成一个新结点
	s->data = e;                 //将e赋值给新结点的数据域
	s->next = p->next;           //将新结点与后一个结点的地址连接
	p->next = s;
	return OK;
}

因为要实现构造一个单链表,所以在main函数中会循环调用ValueList_L方法,所以通过以下的循环是用来使p指向要赋值的位置

while(p->next){

	p = p->next;
}

之后利用malloc()函数开辟新的结点来存放数据和下一个结点的位置即可,因为malloc()函数开辟空间之后返回的不是LinkList结点类型,所以在利用malloc()函数开辟新的结点时要将其通过强制类型转换使其转换成LinkList类型

4.对线性表进行销毁

//对线性表进行销毁
Status DistoryList_L(LinkList &L) {
	if(!L){            //如果线性表不存在,返回ERROR
		printf("线性表不存在\n");
		return ERROR;
	}
	LinkList q = L->next;    //使q指向单链表的首元结点
	while(q != NULL){     //当q结点不为空时一直进入循环
		free(L);          //释放L结点
		L = q;            //将q结点赋值给L结点
		q = L->next;      //将q结点赋值给L结点以后使q结点指向L的下一个结点
	}
	free(L);    //此时q的值为NULL,L指向尾结点,将其释放
	L = NULL;
	printf("线性表已销毁\n");
}

在对单链表进行销毁操作时,从头结点开始逐一释放,释放前使q指向开始释放的结点,当开始结点不为空时,执行释放过程,先释放头结点,然后将L,q都向后移,依次释放,因为q始终是L的后继,所以最后一定是L留到最后,最后释放L结点

L = NULL;

为什么在feel(L);之后还要将L赋值为空?

因为free函数只是将之前动态分配给L的内存归还给系统,但是指针类型的结点L仍然存在,为了防止之后发生野指针访问,将L赋值为NULL

5.对线性表进行重置

//对线性表进行重置
Status ClearList_L(LinkList &L)
{
	if(!L->next){
		printf("线性表为空表,不需要重置\n");
		return ERROR;
	}
	LinkList p,q;
	p = L->next;          //将单链表的头结点赋值给p
	while(p){
		q = p->next;      //将单链表的首元结点赋值给q
		free(p);
		p = q;
	}
	L->next = NULL;     //将头结点的指针域赋值为空
	printf("线性表已重置\n");
	return OK;
}

在对线性表进行重置前首先要判断线性表是为空表,当其不为空时构造两个LinkList类型的结点p和q,使p指向L的首元结点,当p不为空即单链表不为空时进入while循环,将p的下一个结点复制给q,将p释放后再将q赋值给p。p为空时说明此时单链表只剩下了头结点,将头结点的指针域设置为NULL,完成单链表的重置(因为LinkList为指针类型的数据,所以赋值的内容都是地址

图示:

6.判断线性表是否为空

//判断线性表是否为空
Status ListEmpty_L(LinkList L)
{
	if(L){
		if(L->next == NULL)       //如果首元结点不存在
	    printf("线性表是空表\n");
	    else
	    printf("线性表不是空表\n");
	}
	else{
	printf("线性表不存在,无法判断\n");
	}
	return OK;
}

在判断线性表是否为空时,首先判断头结点是否存在,当头结点存在时看头结点的指针域是否为空,当指针域为空时说明首元结点不存在,单链表是空表当指针域不为空时说明存在首元结点,单链表不是空表。如果头结点不存在的话说明单链表不存在,无法判断是否为空表。

7.获取线性表的长度

//获取线性表的长度
Status ListLength_L(LinkList L,int count)
{
	//L为带头结点的单链表的头指针,count为计数器
	LinkList p = L->next;    //定义p为单链表L的指针域
	while(p){
		p = p->next;
		count++;
	}
	return count;
}

获取线性表长度的核心思路是遍历单链表,定义LinkList类型的变量p,将单链表的首元结点赋值给p。在该函数中count为计数器,形参count传来的值始终为1,count的值为1代表从首元结点开始计数,所以才将L->next赋值给p,目的是为了让count与存储数据元素的结点位置对应一致。(在单链表中有头结点的存在,所以这种方法计算出的长度最后的值要比线性表的实际长度大1)进入循环后每当p不断向后移动,每当p后移一次,计数器count的值就加1,直到p为空,此时count的位置就对应着最后一个存储着数据元素的结点位置。

8.获取线性表某一位置对应的元素

//获取线性表某一位置对应的元素
Status GetElem_L(LinkList L,int index)
{
	LinkList p;
	p = L->next;       //使p指向L的首元结点
	int  count = 1;    //count为计数器 ,赋值等于1的原因是从首元结点开始计数
	while(p && count < index){    //顺着指针向后查找,直到p指向第index个元素或p为空
		p = p->next;
		count++;        //此时p一直指向第count个元素
	}
	if(!p || count > index){
		printf("当前位置没有元素\n");
		return ERROR;
	}
	printf("第%d个元素的值是:%d\n",index,p->data);
	return OK;
}

与获取单链表的长度思路一样,获取单链表某一位置的元素也需要遍历单链表,只不过什么时候停止遍历由自己决定,可能不需要全部遍历。定义LinkList类型的变量p并且将首元结点的地址赋值给p。定义计数器count的初始值为1之后,进入while循环,循环判断有两个:

  • p    因为p一直指向第count个结点,所以此循环判断条件的意思是当第count个结点存在时才能进入循环
  • count < index   当count还不是我们想要获取的结点位置时继续循环

退出循环以后p指向的位置就是我们想要获取的结点位置,这个时候要先进行越界判断,!p的意思是如果在之前的循环中index的值大于单链表的长度,那么退出循环的原因就是p为NULL,那么!p就为true,满足if语句中的条件,返回ERROR,所以 !p的作用就是限制index不大于单链表的长度。 count > index的目的是为了限制index的值小于1

9.在线性表某一位置插入元素

//在线性表某一位置插入元素
Status ListInsert_L(LinkList &L,int index,ElemType e)
{
	LinkList p,q;
	p = L;      //将线性表的头结点赋值给p
	int count = 0;    //count为计数器
	while(p && count < index - 1){      //寻找第index-1个结点
		p = p->next;         //此时的p结点指向第index-1个结点
		count++;
	}
	if(!p || count > index -1){        //越界判断,index小于1或是index大于表长加1
		printf("当前结点无法插入元素\n");
		return ERROR;
	}
	q = (LinkList)malloc(sizeof(LNode));
	q->data = e;            //将e赋值到q的数据域当中
	q->next = p->next;
	p->next = q;
	printf("元素插入成功\n");
	return OK;
}

与寻找某个位置结点的值思路一致,需要先找到要插入结点的位置。但是这里不同的地方在于要插入结点的话,可以在单链表的表尾插入元素,也可以在头结点和首元结点间插入元素,所以计数器count的初值为0(为了保证从头结点开始遍历,count的值与实际的结点位置相匹配),所以判断条件变为index - 1。在结束循环和越界判断结束后p之后的位置就是要插入结点的位置,先构造出一个空结点并赋值给q,将p的下一个结点位置赋值给q的指针域,再将p的下一个结点位置赋值给q完成插入操作。

图示:

10.删除线性表某一位置的元素

//删除线性表某一位置的元素
Status DeleteList_L(LinkList &L,int index)
{
	LinkList p,q;
	p = L;           //将线性表的头结点赋值给p
	int count = 0;   //计数器
	while(p->next && count < index - 1){
		p = p->next;
		count++;            //此时p一直指向第count个结点
	}
	if(!(p->next) || count > index - 1){     //越界判断
		printf("当前位置无法删除元素\n");
		return ERROR;
	}
	q = p->next;
	p->next = q->next;
	free(q);
	q = NULL;
	printf("当前位置元素已删除\n");
	return OK;
}

删除某一结点的思路仍然是从头结点开始遍历找到要删除的结点的位置的前一个结点,此时p就是要删除结点位置的前一个结点。将p的后一个结点赋值给q,此时q就是要删除的结点,将q的下一个结点与p的下一个结点连接,释放q结点,完成删除操作。

11.求线性表某一元素的前驱

//求线性表某一元素的前驱
Status PriorElem_L(LinkList L,int index)
{
	LinkList p;
	int count = 0;       //count为计数器
	p = L;
	while(p->next && count < index - 1){       //寻找第index-1个结点
		p = p->next;            //p一直指向第count个结点
		count++;
	}
	if(!(p->next) || count > index - 1){       //越界判断
		printf("当前位置无法求该元素的前驱\n");
		return ERROR;
	}
	if(p != L)            //如果要获取第一个元素的前驱,就是获取头结点数据域的值
	printf("该元素的前驱为:%d\n",p->data);
	else
	printf("该位置的前驱是头结点\n头结点的数据域中存储的值为:%d\n",p->data);
	return OK;
}

和删除结点的思路完全一致,只不过求前驱时不需要进行删除结点,在循环中控制循环条件使p在index - 1位置结束循环,此时p指向的就是第index的前驱,直接将p结点的数据域输出即可

12.求线性表某一元素的后继

//求线性表某一元素的后继
Status NextElem_L(LinkList L,int index)
{
	LinkList p;
	int count = 0;
	p = L->next;
	while(p && count < index){        //不断遍历寻找第index之后的结点
		p = p->next;      //p一直指向index-1的后一个结点
		count++;
	}
	//!p的目的是为了确保i不大于表长-1,count>index的目的是为了确保index不小于0
	if(!p || count > index){          //越界判断
		printf("当前位置无法求该元素的后继\n");
		return ERROR;
	}
	printf("该元素的后继为:%d\n",p->data);
}

在声明LinkList类型变量p时将L的首元结点赋值给p,在循环中p一直指向第index的下一个结点,所以直接将p结点的数据域输出即可

13.打印线性表

//打印线性表
Status PrintList_L(LinkList L)
{
	if(!L){            //如果线性表不存在,返回ERROR
		printf("线性表不存在,无法打印\n");
		return ERROR;
	}
	LinkList p;
	p = L->next;    //将L的首元结点赋值给p ,为了不将头结点打印出来
	while(p){
		printf(" %d",p->data);   //将p结点的数据域输出
		p = p->next;    //结点不断的向后移动
	}
	printf("\n");
	return OK;
}

打印单链表的思路也是进行对单链表的遍历,在遍历的过程中将每个结点的数据域中存储的值输出

运行结果演示

为了方便演示,在这里为单链表一次赋值为1,2,3,4,5

构造一个空的头结点

赋值操作

判断此时线性表是否为空

获取单链表的长度

获取2号位置的元素

在3号位置插入520并打印单链表

获取此时单链表的长度

删除3号位置的元素并打印单链表

求3号位置元素的前驱和后继

重置单链表并获取长度以及判断是否为空表

销毁单链表并进行赋值和判断是否为空

以上便是线性表链式表示和实现,由于链表在空间的合理利用上和插入、删除是不需要移动等的优点,因此在很多场合下它

是线性表的首选存储结构。然而,它也存在着实现某些基本操作的缺点,比如:求线性表长度时不如顺序存储结构......

源码

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

//函数结果状态代码
#define TRUE     1     //代码中出现TRUE相当于出现了1
#define FALSE    0     //出现FALSE相当于出现了0
#define OK       1     //出现OK相当于出现了1
#define ERROR    0     //出现ERROR相当于出现了0
#define INFEASIBLE    -1
#define OVERFLOW      -2 

typedef int Status;    //定义函数的返回状态
typedef int ElemType; 

typedef struct LNode{
	ElemType  data;               //数据域
	struct LNode * next;          //指针域,指向一整个结点(结构体,该结构体中包含数据域和指针域)
}LNode , * LinkList;        //* LinkList是结点的类型,在之后的代码中出现了它就相当于出现了指向这个结点的指针 

//构造一个空的头结点
Status InitList_L(LinkList &L){     //之前因为没有输入"&"符号,没有使用引用传递也就意味着没有开辟了新的内存空间,所以在之后赋值的时候会出现无法赋值的情况
	L = (LinkList)malloc(sizeof(LNode));      //产生头结点,并使L指向该头结点(L也称头指针)
	if(!L)  return ERROR;          //如果存储空间分配失败,返回ERROR
	L->next = NULL;                //将指针域赋值为NULL,在这里要强调一点:"->"是一个整体,它是用于指向结构体子数据的指针
	printf("空的头结点创建成功\n");
	return OK;
} 

//对线性表进行赋值
Status ValueList_L(LinkList &L,ElemType e){
	LinkList s,p;
	p = L;
	while(p->next){
		p = p->next;
	}
	s = (LinkList)malloc(sizeof(LNode));       //生成一个新结点
	s->data = e;                 //将e赋值给新结点的数据域
	s->next = p->next;           //将新结点与后一个结点的地址连接
	p->next = s;
	return OK;
} 

//对线性表进行销毁
Status DistoryList_L(LinkList &L) {
/*从头结点开始逐一释放,释放前使p指向头结点,q指向开始释放的结点
  当开始结点不为空时,执行释放过程
  先释放头结点,然后将p,q都向后移,依次释放
  因为q始终是p的后继,所以最后一定是p留到最后,最后释放p
*/
	if(!L){            //如果线性表不存在,返回ERROR
		printf("线性表不存在\n");
		return ERROR;
	}
	LinkList q = L->next;    //使q指向单链表的首元结点
	while(q != NULL){     //当q结点不为空时一直进入循环
		free(L);          //释放L结点
		L = q;            //将q结点赋值给L结点
		q = L->next;      //将q结点赋值给L结点以后使q结点指向L的下一个结点
	}
	free(L);    //此时q的值为NULL,L指向尾结点,将其释放
	L = NULL;   //free函数只是将之前动态分配给L的内存归还给系统,但是指针类型的结点L仍然存在
	//为了防止之后发生野指针访问,将L赋值为NULL
	printf("线性表已销毁\n");
}

//对线性表进行重置
Status ClearList_L(LinkList &L)
{
	if(!L->next){
		printf("线性表为空表,不需要重置\n");
		return ERROR;
	}
	LinkList p,q;
	p = L->next;          //将单链表的头结点赋值给p
	while(p){
		q = p->next;      //将单链表的首元结点赋值给q
		free(p);
		p = q;
	}
	L->next = NULL;     //将头结点的指针域赋值为空
	printf("线性表已重置\n");
	return OK;
} 

//判断线性表是否为空
Status ListEmpty_L(LinkList L)
{
	if(L){
		if(L->next == NULL)       //如果首元结点不存在
	    printf("线性表是空表\n");
	    else
	    printf("线性表不是空表\n");
	}
	else{
	printf("线性表不存在,无法判断\n");
	}
	return OK;
} 

//获取线性表的长度
Status ListLength_L(LinkList L,int count)
{
	//L为带头结点的单链表的头指针,count为计数器
	LinkList p = L->next;    //定义p为单链表L的指针域
	while(p){
		p = p->next;
		count++;
	}
	return count;
}	

//获取线性表某一位置对应的元素
Status GetElem_L(LinkList L,int index)
{
	LinkList p;
	p = L->next;       //使p指向L的首元结点
	int  count = 1;    //count为计数器 ,赋值等于1的原因是从首元结点开始计数
	while(p && count < index){    //顺着指针向后查找,直到p指向第index个元素或p为空
		p = p->next;
		count++;        //此时p一直指向第count个元素
	}
	if(!p || count > index){
		printf("当前位置没有元素\n");
		return ERROR;
	}
	printf("第%d个元素的值是:%d\n",index,p->data);
	return OK;
} 

//在线性表某一位置插入元素
Status ListInsert_L(LinkList &L,int index,ElemType e)
{
	LinkList p,q;
	p = L;      //将线性表的头结点赋值给p
	int count = 0;    //count为计数器
	while(p && count < index - 1){      //寻找第index-1个结点
		p = p->next;         //此时的p结点指向第index-1个结点
		count++;
	}
	if(!p || count > index -1){        //越界判断,index小于1或是index大于表长加1
		printf("当前结点无法插入元素\n");
		return ERROR;
	}
	q = (LinkList)malloc(sizeof(LNode));
	q->data = e;            //将e赋值到q的数据域当中
	q->next = p->next;
	p->next = q;
	printf("元素插入成功\n");
	return OK;
}

//删除线性表某一位置的元素
Status DeleteList_L(LinkList &L,int index)
{
	LinkList p,q;
	p = L;           //将线性表的头结点赋值给p
	int count = 0;   //计数器
	while(p->next && count < index - 1){
		p = p->next;
		count++;            //此时p一直指向第count个结点
	}
	if(!(p->next) || count > index - 1){     //越界判断
		printf("当前位置无法删除元素\n");
		return ERROR;
	}
	q = p->next;
	p->next = q->next;
	free(q);
	q = NULL;
	printf("当前位置元素已删除\n");
	return OK;
} 

//求线性表某一元素的前驱
Status PriorElem_L(LinkList L,int index)
{
	LinkList p;
	int count = 0;       //count为计数器
	p = L;
	while(p->next && count < index - 1){       //寻找第index-1个结点
		p = p->next;            //p一直指向第count个结点
		count++;
	}
	if(!(p->next) || count > index - 1){       //越界判断
		printf("当前位置无法求该元素的前驱\n");
		return ERROR;
	}
	if(p != L)            //如果要获取第一个元素的前驱,就是获取头结点数据域的值
	printf("该元素的前驱为:%d\n",p->data);
	else
	printf("该位置的前驱是头结点\n头结点的数据域中存储的值为:%d\n",p->data);
	return OK;
}

//求线性表某一元素的后继
Status NextElem_L(LinkList L,int index)
{
	LinkList p;
	int count = 0;
	p = L->next;
	while(p && count < index){        //不断遍历寻找第index之后的结点
		p = p->next;      //p一直指向index-1的后一个结点
		count++;
	}
	//!p的目的是为了确保i不大于表长-1,count>index的目的是为了确保index不小于0
	if(!p || count > index){          //越界判断
		printf("当前位置无法求该元素的后继\n");
		return ERROR;
	}
	printf("该元素的后继为:%d\n",p->data);
}

//打印线性表
Status PrintList_L(LinkList L)
{
	if(!L){            //如果线性表不存在,返回ERROR
		printf("线性表不存在,无法打印\n");
		return ERROR;
	}
	LinkList p;
	p = L->next;    //将L的首元结点赋值给p ,为了不将头结点打印出来
	while(p){
		printf(" %d",p->data);   //将p结点的数据域输出
		p = p->next;    //结点不断的向后移动
	}
	printf("\n");
	return OK;
}

int main(){
	SetConsoleTitle("Dream_飞翔");              //控制windows终端控制台的名称
    //system("mode con cols=60 lines=30");        这条语句可以控制windows终端控制台的大小
	LinkList L = NULL;               //声明线性表的头结点,但是并未进行初始化
	int choose,index,e,Num,Value,k;
	while(1){
		printf("*****************************************\n");
		printf("*                                       *\n");
		printf("*  线性表的链式表示和实现:             *\n");
		printf("*                                       *\n");
		printf("*    1.  构造一个空的头结点             *\n");
		printf("*    2.  对线性表进行赋值               *\n");
		printf("*    3.  对线性表进行销毁               *\n");
		printf("*    4.  对线性表进行重置               *\n");
		printf("*    5.  判断线性表是否为空             *\n");
		printf("*    6.  获取线性表的长度               *\n");
		printf("*    7.  获取线性表某一位置对应的元素   *\n");
		printf("*    8.  在线性表某一位置插入元素       *\n");
		printf("*    9.  删除线性表某一位置的元素       *\n");
		printf("*    10. 求线性表某一元素的前驱         *\n");
		printf("*    11. 求线性表某一元素的后继         *\n");
		printf("*    12. 打印线性表                     *\n");
		printf("*    13. 退出                           *\n");
		printf("*                                       *\n");
		printf("*****************************************\n");
		printf("请做出您的选择:");
		scanf("%d",&choose);
		switch(choose){
			case 1:InitList_L(L);break;
			case 2:{
				if(L){      //对线性表赋值的前提是线性表的头结点存在
					printf("请输入线性表元素的个数:");
					scanf("%d",&Num);
					if(Num > 0){
						for(int i = 1;i <= Num;i++){
						printf("请输入第%d个元素的值:",i);
						scanf("%d",&Value);
						ValueList_L(L,Value);
						}
					printf("线性表赋值成功\n");
					}
					else
					printf("请输入一个有效数字\n");
				}
				else
				printf("线性表不存在,无法赋值\n");
				}
			break;
			case 3:DistoryList_L(L);break;
			case 4:ClearList_L(L);break;
			case 5:ListEmpty_L(L);break;
			case 6:{
				int count = ListLength_L(L,1);
				printf("线性表的长度为:%d\n",count-1);
			};break;
			case 7:{
				printf("请输入要获取元素的位置:");
				scanf("%d",&index);
				GetElem_L(L,index);
			}
			break;
			case 8:{
				printf("请输入插入元素的位置:");
				scanf("%d",&index);
				printf("请输入插入元素的值:");
				scanf("%d",&e);
				ListInsert_L(L,index,e);
			}
			break;
			case 9:{
				printf("请输入要删除元素的位置:");
				scanf("%d",&index);
				DeleteList_L(L,index);
			}
			break;
			case 10:{
				if(L){
					printf("请输入想要查找哪一个元素的前驱:");
					scanf("%d",&index);
					PriorElem_L(L,index);
				}
				else
				printf("线性表不存在,无法获取其中元素的前驱\n");
			}
			break;
			case 11:{
				if(L){
					printf("请输入想要查找哪一个元素的后继:");
					scanf("%d",&index);
					NextElem_L(L,index);
				}
				else
				printf("线性表不存在,无法获取其中元素的后继\n");
			}
			break;
			case 12:PrintList_L(L);break;
			case 13:exit(0);
		}
	}
	return 0;
}

以上就是C语言线性表的链式表示及实现详解的详细内容,更多关于C语言线性表链式表示的资料请关注我们其它相关文章!

(0)

相关推荐

  • C语言线性表顺序表示及实现

    目录 准备工作 实现线性表 线性表的动态分配顺序存储结构 构造一个空的线性表 对线性表进行赋值 对线性表进行销毁 对线性表进行重置 判断线性表是否为空 获取线性表的长度 获取线性表某一位置对应的元素 在线性表某一位置插入元素 删除线性表某一位置的元素 求线性表某一元素的前驱 求线性表某一元素的后继 打印线性表 运行结果演示: 源码 线性表是最常用且最简单的一种数据结构.简而言之,一个线性表是n个数据元素的有限序列 线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素. 实现工具

  • C语言线性表的顺序表示与实现实例详解

    1.概述 通常来说顺序表是在计算机的内存中以数组的形式保存的线性表,是用一组地址连续的存储单元依次存储数据元素的线性数据结构.线性表采用顺序存储的方式存储就称之为顺序表.顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中. 将表中元素一个接一个的存入一组连续的存储单元中,这种存储结构就是顺序结构. 采用顺序存储结构的线性表简称为" 顺序表".顺序表的存储特点是:只要确定了起始位置,表中任一元素的地址都通过下列公式得到:LOC(ai)=LOC(a1)+(i-1)*L 1≤

  • C语言数据结构之线性表的链式存储结构

    1.什么是线性表的链式存储结构 -链表 存储结点:包括元素本身的信息,还有元素之间的关系逻辑的信息 这个结点有:数据域和指针域 一个指针域:指向后继结点, 单链表 二个指针域: 指向前继结点,还有一个指向后继结点 双链表 2.原理是: s=(LinkNode *)malloc(sizeof(LinkNode));// s->data=e; //这里赋值了 s->next=p->next; // p->next=s; //这里把指针s给到了p 结点a-> 结点b -> 结

  • C语言线性表的链式表示及实现详解

    目录 前言 代码实现 1. 单链表的结点构造 2. 构造一个空的头结点 3. 对线性表进行赋值 4.对线性表进行销毁 5.对线性表进行重置 6.判断线性表是否为空 7.获取线性表的长度 8.获取线性表某一位置对应的元素 9.在线性表某一位置插入元素 10.删除线性表某一位置的元素 11.求线性表某一元素的前驱 12.求线性表某一元素的后继 13.打印线性表 运行结果演示 源码 前言 线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素,而线性表的链式存储特点则是用一组任意的存储

  • JS实现线性表的链式表示方法示例【经典数据结构】

    本文实例讲述了JS实现线性表的链式表示方法.分享给大家供大家参考,具体如下: 从上一节可以,顺序存储结构的弱点就是在插入或删除操作时,需要移动大量元素.所以这里需要介绍一下链式存储结构,由于它不要求逻辑上相邻的元素在物理位置上也相邻,所以它没有顺序存储结构的弱点,但是也没有顺序表可随机存取的优点. 下面介绍一下什么是链表. 线性表的链式存储结构用一组任意的存储单元存储线性表的数据元素.所以,每一个数据元素除了存储自身的信息之外,还需要存储一个指向其后继的存储位置的信息.这两部分信息组成了元素的存

  • Java实现线性表的链式存储

    本文实例为大家分享了Java实现线性表的链式存储,供大家参考,具体内容如下 链表:一种物理存储结构上非连续.非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的. package algorithm.datastructure.linklist; import java.util.NoSuchElementException; /* * 链表 * 物理存储上非连续的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现 * * */ public class LinkedLi

  • C语言实现二叉树链式结构的示例详解

    目录 前言 1. 链式二叉树结构 2. 二叉树的遍历 2.1 前序遍历 2.2 中序遍历 2.3 后序遍历 2.4 层序遍历 3. 常见功能 3.1 二叉树结点个数 3.2 二叉树叶子结点个数 3.3 第K层结点的个数 3.4 二叉树的深度 3.5 判断是不是树是不是完全二叉树 3.6 在二叉树中查找值为x的结点 3.7 拿到每一层的数据 4. 二叉树的创建和销毁 4.1 二叉树的创建 4.2 二叉树的销毁 前言 前面我们已经对堆进行学习,堆就是一个顺序结构的二叉树,把数组看成二叉树,下面一起学

  • C语言顺序表的基本结构与实现思路详解

    目录 一.顺序表的概念与结构 1.线性表的解释 2.顺序表概念解释 二.顺序表的思路及代码实现详解 1.静态顺序表的实现 2.动态顺序表思路及代码实现 2.1 动态顺序表的整体思路 2.2 定义结构体的实现 2.3 初始化结构体 2.4 结构体打印 2.5 检查数组容量 2.6 头插 2.7 尾插 2.8 头删 2.9 尾删 2.10 任意删除 2.11 任意插入 2.12 空间释放 三.顺序表代码整合 SeqList.h SeqList.c test.c 一.顺序表的概念与结构 1.线性表的解

  • PHP实现链式操作的原理详解

    在一个类中有多个方法,当你实例化这个类,并调用方法时只能一个一个调用,类似: db.php <?php class db { public function where() { //code here } public function order() { //code here } public function limit() { //code here } } index.php <?php $db = new db(); $db->where(); $db->order()

  • Iptables防火墙四表五链概念及使用技巧详解

    目录 1.链的概念 2.Iptables五种链的概念 3.Iptables数据流向经过的表 4.Iptables防火墙四种表的概念 5.Iptables防火墙表与链之间的优先级概念 6.Iptables防火墙表和链之间的使用技巧 **问题1:** **问题2:** 结论: 7.Iptables防火墙几种动作 1.链的概念 在防火墙中,用户想要成功进入内网环境,就需要发送请求报文,请求报文要和防火墙设置的各种规则进行匹配和判断,最后执行相应的动作(放行或者拒绝),一个防火墙中通常针对不同的来源设置

  • 一起来看看C语言线性表的线性链表

    目录 定义 1.插入 2.建立线性链表 1)头插法 2)尾插法 3.删除 4.查找 5.求线性链表的表长 总结 定义 链表是通过一组任意的存储单元来存储线性表中的数据元素,每一个结点包含两个域:存放数据元素信息的域称为数据域,存放其后继元素地址的域称为指针域.因此n个元素的线性表通过每个结点的指针域连接成了一个“链条”,称为链表.若此链表的每个结点中只包含一个指针域,则被称为线性链表或单链表. 线性表的链式存储结构,它不需要用地址连续的存储单元来实现,因为它不要求逻辑上相邻的两个数据元素物理位置

随机推荐