数据结构:2.链式表

原创 已于 2026-02-01 20:51:11 修改 · 492 阅读 · 5 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
于 2026-01-29 20:11:34 首次发布

几乎全是代码，概念配合代码，可以多打几遍熟练

目录

1.链表分类

2.单向链表

3.双向链表

4.循环链表

5.数组和链表的区别

1.链表分类

  • 单向链表
  • 双向链表
  • 循环链表

2.单向链表

  • 单向链表又分有头链表和无头链表
  • 有头链表（又称带头节点的链表）是在链表的第一个元素之前增加一个特殊的"头节点"，这个节点不存储实际数据，只作为链表的入口
  • 无头链表是指链表的第一个节点就是实际存储数据的节点，没有额外的头节点
  • 由于无头链表要用到大量二级指针，过于麻烦，有头链表更为常用
  • 多文件编程makefile

makefile

mu:=main
lai+=lian.c
lai+=main.c
$(mu):$(lai)
    gcc $^ -g -o $@                                                         

.PHONY:
clean:
    rm $(mu)
//查看是否有内存泄漏
cha:
    valgrind --tool=memcheck --leak-check=full ./$(mu)

下为单向链表的创建，插入值(头插)，打印，删除值，寻找值，修改值，插入值(尾插)，销毁链表，查找中间节点，查找倒数第n个，倒置链表，冒泡排序，选择排序，lian.c文件

#include"lian.h"
Node_t *chuanglian(void)
{
	Node_t *pnewnode = NULL;
	pnewnode = malloc(sizeof(Node_t));
	if(NULL == pnewnode)
	{
		perror("失败");
		return NULL;
	}
	pnewnode->pnext = NULL;

	return pnewnode;
}
int chalian(Node_t *ptou,datatype data)
{
	Node_t *pnewnode = NULL;
	pnewnode = malloc(sizeof(Node_t));
	if(NULL == pnewnode)
	{
		perror("失败");
		return -1;
	}
	pnewnode->data = data;
	pnewnode->pnext = ptou->pnext;
	ptou->pnext = pnewnode;
	return 0;
}
void showlian(Node_t *ptou)
{
	Node_t * pzhong = NULL;
	pzhong = ptou->pnext;
	while(pzhong != NULL)
	{
		printf("%d ",pzhong->data);
		pzhong = pzhong->pnext;
	}
	putchar('\n');
}
int shanlian(Node_t *ptou,datatype a)
{
	int cnt = 0;
	Node_t *pqian = NULL;
	Node_t *phou = NULL;
	pqian = ptou->pnext;
	phou = ptou;
	while(pqian != NULL)
	{
		if(pqian->data == a)
		{
			phou->pnext = pqian->pnext;
			free(pqian);
			pqian = phou->pnext; 
			cnt++;
		}
		else
		{
			pqian = pqian->pnext;
			phou = phou->pnext;
		}
	}
	return cnt;
}
Node_t * zhaolian(Node_t *ptou,datatype a)
{
	Node_t *pzhong = NULL;
	Node_t *pfu = NULL;
	pzhong = ptou->pnext;
	while(pzhong != NULL)
	{
		if(a == pzhong->data)
		{
			pfu = pzhong;
			return pfu;
		}
		pzhong = pzhong->pnext;
	}
	return NULL;
}
int gailian(Node_t *ptou,datatype jiu,datatype xin)
{
	int cnt = 0;
	Node_t *pzhong = NULL;
	pzhong = ptou->pnext;
	while(pzhong != NULL)
	{
		if(pzhong->data==jiu)
		{
			pzhong->data = xin;
			cnt++;
		}
		pzhong = pzhong->pnext;
	}
	return cnt;
}
int weichalian(Node_t *ptou,datatype data)
{
	Node_t *pnewnode = NULL;
	//如果Node_t *pzhong = ptou;当只有一个头时，会出现段错误，NULL
	Node_t *pzhong = ptou;
	pnewnode = malloc(sizeof(Node_t));
	if(NULL == pnewnode)
	{
		perror("失败");
		return -1;
	}
	pnewnode->data = data;
	while(pzhong->pnext != NULL)
	{
		pzhong=pzhong->pnext;
	}
	//此时，pzhong->pnext == NULL
	pnewnode->pnext = NULL;//pnewnode->pnext = pzhong->pnext;
	pzhong->pnext = pnewnode;
	return 0;
}
void hui(Node_t **pptou)
{
	Node_t *pqian = NULL;
	Node_t *phou = NULL;
	pqian = *pptou;
	phou = *pptou;
	while(pqian != NULL)
	{
		pqian = pqian->pnext;
		free(phou);
		phou = pqian;
	}
	*pptou = NULL;
}
Node_t *zhaozhlian(Node_t *ptou)
{
	Node_t *pkuai = NULL;
	Node_t *pman = NULL;
	pkuai = pman = ptou->pnext;
	while(pkuai != NULL)
	{
		pkuai = pkuai->pnext;
		if(pkuai == NULL)
		{
			return pman;
		}
		pkuai = pkuai->pnext;
		pman = pman->pnext;
	}
	return pman;
}
Node_t *zhaoalian(Node_t *ptou,int a)
{
	Node_t *pkuai = NULL;
	Node_t *pman = NULL;
	pkuai = pman = ptou->pnext;
	int x = 0;
	for(x = 0;x<a && pkuai!=NULL;x++)
	{
		pkuai = pkuai->pnext;
	}
	while(pkuai != NULL)
	{
		pkuai = pkuai->pnext;
		pman = pman->pnext;
	}
	return pman;
}
void daozhilian(Node_t *ptou)
{
	Node_t *pqian = NULL;
	Node_t *phou = NULL;
	pqian = phou = ptou->pnext;
	ptou->pnext = NULL;
	while(pqian != NULL)
	{
		pqian = pqian->pnext;
		phou->pnext = ptou->pnext;
		ptou->pnext = phou;
		phou = pqian;

	}
}
int maopaolian(Node_t *ptou)
{
	Node_t *pqian = NULL;
	Node_t *phou = NULL;
	Node_t *pend = NULL;
	datatype zhong;
	if(ptou->pnext==NULL || ptou->pnext->pnext==NULL )
		return 0;
	while(1)
	{
		pqian = ptou->pnext->pnext;
		phou = ptou->pnext;
		if(pend == pqian)
			break;
		while(pqian != pend)
		{
			if(pqian->data < phou->data)
			{
				zhong = phou->data;
				phou->data = pqian->data;
				pqian->data = zhong;
			}
			pqian = pqian->pnext;
			phou = phou->pnext;
		}
		pend = phou;
	}
	return 0;
}
int xuanzelian(Node_t *ptou)
{
	Node_t *pqian = NULL;
	Node_t *phou = NULL;
	Node_t *pmax = NULL;
	datatype zhong;
	if(ptou->pnext==NULL || ptou->pnext->pnext==NULL )
		return 0;
	phou = ptou->pnext;
	while(phou->pnext != NULL)
	{
		pqian = phou->pnext;
		pmax = phou;
		while(pqian != NULL)
		{
			if(pmax->data < pqian->data)
				pmax = pqian;
			pqian = pqian->pnext;
		}
		if(pmax->data != phou->data)
		{
			zhong = phou->data;
			phou->data = pmax->data;
			pmax->data = zhong;
		}
		phou = phou->pnext;
	}
	return 0;
}

main.c文件

#include"lian.h"
int main()
{
	Node_t *plian = NULL;
	plian = chuanglian();
	Node_t *pliana = chuanglian();
	chalian(plian,1);
	chalian(plian,2);
	chalian(plian,3);
	chalian(plian,3);
	chalian(plian,4);
	chalian(plian,2);
	chalian(plian,5);
	printf("头插：1、2、3、3、4、2、5\n");
	showlian(plian);
	int a=shanlian(plian,3);
	printf("删了%d个3\n",a);
	showlian(plian);
	Node_t *fu = zhaolian(plian,4);
	printf("找4：%p %d \n",fu,fu->data);
	int b=gailian(plian,2,9);
	printf("9换2：");
	showlian(plian);
	weichalian(plian,0);
	weichalian(plian,1);
	weichalian(plian,2);
	weichalian(plian,3);
	weichalian(plian,4);
	weichalian(plian,5);
	printf("尾插：0、1、2、3、4、5\n");
	showlian(plian);
	maopaolian(plian);
	printf("lian冒泡排序：");
	showlian(plian);
	xuanzelian(plian);
	printf("lian选择排序：");
	showlian(plian);
	weichalian(pliana,0);
	weichalian(pliana,1);
	weichalian(pliana,2);
	weichalian(pliana,3);
	weichalian(pliana,4);
	weichalian(pliana,5);
	printf("尾插：0、1、2、3、4、5\n");
	showlian(pliana);
	daozhilian(pliana);
	printf("倒置：");
	showlian(pliana);
	fu = zhaozhlian(pliana);
	printf("pliana中间：%d\n",fu->data);
	fu = zhaoalian(pliana,2);
	printf("pliana倒数第二个值：%d\n",fu->data);
	hui(&plian);
	printf("lian = %p\n",plian);
	hui(&pliana);
	printf("liana = %p\n",pliana);
	return 0;
}

lian.h文件

#ifndef __LINKLIST_H__
#define __LINKLIST_H__
#include<stdio.h>
#include<stdlib.h>
typedef int datatype;
typedef struct node
{
	datatype data;
	struct node *pnext;
}Node_t;
//创建链表
extern Node_t *chuanglian(void);
//插入值（头插）
extern int chalian(Node_t *ptou,datatype data);
//打印链表
extern void showlian(Node_t *ptou);
//删除值
extern int shanlian(Node_t *ptou,datatype a);
//查找值
extern Node_t *zhaolian(Node_t *ptou,datatype a);
//修改值
extern int gailian(Node_t *ptou,datatype jiu,datatype xin);
//插入值（尾插）
extern int weichalian(Node_t *ptou,datatype data);
//销毁链表
extern void hui(Node_t **pptou);
//找中间值
extern Node_t *zhaozhlian(Node_t *ptou);
//找倒数第a个值
extern Node_t *zhaoalian(Node_t *ptou,int a);
//倒置链表
extern void daozhilian(Node_t *ptou);
//冒泡排序
extern int maopaolian(Node_t *ptou);
//选择排序
extern int xuanzelian(Node_t *ptou);
#endif

3.双向链表

下为双向链表的创建，插入值(头插)，插入值(尾插)，打印，删除值，寻找值，修改值，销毁链表，lian.c文件

#include"lian.h"
lian *chuanglian(void)
{
	lian *ptou = malloc(sizeof(lian));
	if(ptou == NULL)
	{
		perror("失败");
		return NULL;
	}
	ptou->zhens = NULL;
	ptou->zhenx = NULL;
	return ptou;
}
int chalian(lian *ptou,type a)
{
	lian *pnew = malloc(sizeof(lian));
	if(pnew == NULL)
	{
		perror("失败");
		return -1;
	}
	pnew->zhi = a;
	if(ptou->zhenx != NULL)
		ptou->zhenx->zhens = pnew;
	pnew->zhenx = ptou->zhenx;
	pnew->zhens = ptou;
	ptou->zhenx = pnew;
	return 0;
}
int weilian(lian *ptou,type a)
{
	lian *pnew = malloc(sizeof(lian));
	lian *pzh = ptou;
	if(pnew == NULL)
	{
		perror("失败");
		return -1;
	}
	while(pzh->zhenx != NULL)
	{
		pzh = pzh->zhenx;
	}
	pnew->zhi = a;
	pnew->zhenx = NULL;
	pzh->zhenx = pnew;
	pnew->zhens = pzh;
	return 0;
}
int showlian(lian *ptou)
{
	lian *pzh = ptou->zhenx;
	while(pzh != NULL)
	{
		printf("%d ",pzh->zhi);
		pzh = pzh->zhenx;
	}putchar('\n');
	return 0;
}
int shanlian(lian *ptou,type a)
{
	lian *pzh = ptou->zhenx;
	lian *pfree = NULL;
	int cnt = 0;
	while(pzh != NULL)
	{
		if(a == pzh->zhi)
		{
			pzh->zhens->zhenx = pzh->zhenx;
			if(pzh->zhenx != NULL)
				pzh->zhenx->zhens = pzh->zhens;
			pfree = pzh;
			pzh = pzh->zhenx;
			free(pfree);
			pfree = NULL;
			cnt++;
		}
		else
			pzh = pzh->zhenx;
	}
	return cnt;
}
void gailian(lian *ptou,type xin,type jiu)
{
	lian *pzh = ptou->zhenx;
	while(pzh != NULL)
	{
		if(pzh->zhi == jiu)
			pzh->zhi = xin;
		pzh = pzh->zhenx;
	}
}
lian *zhaolian(lian *ptou,type a)
{
	lian *pzh = ptou->zhenx;
	while(pzh != NULL)
	{
		if(pzh->zhi == a)
			return pzh;
		pzh = pzh->zhenx;
	}
	return NULL;
}
int huilian(lian **pptou)
{
	lian *pqian = *pptou;
	lian *phou = *pptou;
	while(pqian != NULL)
	{
		pqian = pqian->zhenx;
		free(phou);
		phou = pqian;
	}
	*pptou = NULL;
	return 0;
}

main.c

#include"lian.h"
int main(void)
{
	lian *nian = chuanglian();
	lian *year = chuanglian();
	int a = 0;
	
	chalian(nian,1);
	chalian(nian,3);
	chalian(nian,0);
	chalian(nian,0);
	chalian(nian,5);
	chalian(nian,7);
	chalian(nian,9);
	chalian(nian,2);
	chalian(nian,0);
	chalian(nian,4);
	chalian(nian,6);
	printf("nain头插：1 3 0 0 5 7 9 2 0 4 6\n");
	showlian(nian);
	weilian(year,0);
	weilian(year,1);
	weilian(year,2);
	weilian(year,3);
	weilian(year,4);
	weilian(year,5);
	printf("year尾插：0 1 2 3 4 5\n");
	showlian(year);
	a = shanlian(nian,0);
	printf("nian删了%d个0\n",a);
	showlian(nian);
	gailian(nian,0,2);
	printf("nian2改0：");
	showlian(nian);
	lian *niana = zhaolian(nian,9);
	printf("nian找9：%d %p\n",niana->zhi,niana);
	printf("nian未销毁：%p\n",nian);
	printf("year未销毁：%p\n",year);
	huilian(&nian);
	huilian(&year);
	printf("nian销毁：%p\n",nian);
	printf("year销毁：%p\n",year);
	return 0;
}

lian.h

#ifndef __LIAN_H__
#define __LIAN_H__
#include<stdio.h>
#include<stdlib.h>

typedef int type;
typedef struct lian
{
	struct lian *zhens;
	type zhi;
	struct lian *zhenx;
}lian;
//创建双向链表
extern lian *chuanglian(void);
//头插法
extern int chalian(lian*ptou,type a);
//尾插法
extern int weilian(lian*ptou,type a);
//打印双向链表
extern int showlian(lian *ptou);
//删除某值
extern int shanlian(lian *ptou,type a);
//改变某值
extern void gailian(lian *ptou,type xin,type jiu);
//寻找某值
extern lian *zhaolian(lian *ptou,type a);
//销毁双向链表
extern int huilian(lian **pptou);
#endif

4.循环链表

下为循环链表的创建，插入值(头插)，插入值(尾插)，打印，删除值，销毁链表，lian.c文件

#include"lian.h"
xun *chuanglian(void)
{
	xun *ptou = malloc(sizeof(xun));
	if(ptou == NULL)
	{
		perror("失败");
		return NULL;
	}
	ptou->zhens = ptou;
	ptou->zhenx = ptou;
	return ptou;
}
int chalian(xun *ptou,type a)
{
	xun *pnew = malloc(sizeof(xun));
	if(pnew == NULL)
	{
		perror("失败");
		return -1;
	}
	pnew->zhi = a;
	pnew->zhenx = ptou->zhenx;
	ptou->zhenx = pnew;
	pnew->zhenx->zhens = pnew;
	pnew->zhens = ptou; 
	return 0;
}
int weilian(xun *ptou,type a)
{
	xun *pnew = malloc(sizeof(xun));
	if(pnew == NULL)
	{
		perror("失败");
		return -1;
	}
	pnew->zhi = a;
	pnew->zhenx = ptou;
	pnew->zhens = ptou->zhens;
	ptou->zhens = pnew;
	pnew->zhens->zhenx = pnew;
	return 0;
}
int showlian(xun *ptou)
{
	xun *pzh = ptou->zhenx;
	while(pzh != ptou)
	{
		printf("%d ",pzh->zhi);
		pzh = pzh->zhenx;
	}putchar('\n');
	return 0;
}

int Deletecycle(xun *pHead,type a)
{
	xun *pzh = NULL;
	xun *pFreeNode = NULL;
	pzh = pFreeNode = pHead->zhenx;
	while(pzh != pHead)
	{
		if(a == pzh->zhi)
		{
			pzh->zhens->zhenx = pzh->zhenx;
			pzh->zhenx->zhens = pzh->zhens;
			pFreeNode = pzh;
			pzh = pzh->zhenx;
			free(pFreeNode);
			pFreeNode = NULL;
		}
		else
			pzh = pzh->zhenx;
	}
	return 0;
}
int Destorycycle(xun **ppHead)
{
	xun *pTmpNode = NULL;
	xun *pFreeNode = NULL;
	pTmpNode = pFreeNode = (*ppHead)->zhenx;
	while(pTmpNode != *ppHead)
	{
		pFreeNode = pTmpNode;
		pTmpNode = pTmpNode->zhenx;
		free(pFreeNode);
		pFreeNode = NULL;
	}
	free(*ppHead);
		*ppHead = NULL;
	return 0;
}

main.c

#include"lian.h"
int main(void)
{
	xun *year = chuanglian();
	xun *sui = chuanglian();
	
	chalian(year,1);
	chalian(year,0);
	chalian(year,0);
	chalian(year,3);
	chalian(year,5);
	chalian(year,7);
	chalian(year,9);
	chalian(year,0);
	weilian(sui,2);
	weilian(sui,4);
	weilian(sui,6);
	weilian(sui,8);
	weilian(sui,10);
	showlian(year);
	showlian(sui);
	Deletecycle(year,0);
	showlian(year);
	printf("year:%p\n",year);
	printf("sui:%p\n",sui);
	Destorycycle(&year);
	Destorycycle(&sui);
	printf("year:%p\n",year);
	printf("sui:%p\n",sui);
	return 0;
}

lian.h

#ifndef __CIRLIST_H__
#define __CIRLIST_H__

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

typedef int type;
typedef struct xun
{
	type zhi;
	struct xun *zhens;
	struct xun *zhenx;
}xun;
//创建双向循环链表
extern xun *chuanglian(void);
//头插法
extern int chalian(xun *ptou,type a);
//尾插法
extern int weilian(xun *ptou,type a);
//打印链表
extern int showlian(xun *ptou);
//删除值
extern int Deletecycle(xun *pHead,type a);
//销毁链表
extern int Destorycycle(xun **pHead);
#endif

5.数组和链表的区别

  • 数组空间是连续的
  • 链表空间可以是不连续的
  • 数组必须元素有限
  • 链表元素是没有上限的
  • 数组插入和删除效率比较低
  • 链表的插入和删除效率比较高
  • 数组访问元素比较方便
  • 链表访问元素不太方便
标签
#数据结构
顺序表的空间利用率高于链表1 数据 数据元素 数据结构 基本概念 2、 逻辑结构分类 3、存储结构 4 数据运算 5 算法概念 1、线形表 栈的应用： 链式队列Q判空：
ZhangJiqun&191cm&85kg
11-11 826
1 数据（data）是对客观事物的符号表示 数据元素（data element）是数据的基本单位，一个数据元素可由若干个数据项（data item）组成，数据项为数据的不可分割的最小单位，数据对象（data object）是性质相同的数据元素的集合，是数据的一个子集。 数据结构（data structure）是相互之间存在一种或多种特定关系的数据元素的集合。数据元素相互之间的关系称为结构（s...
6-5 链式表操作集 (20分) 本题要求实现链式表的操作集。
07-27 6347
函数接口定义： Position Find( List L, ElementType X ); List Insert( List L, ElementType X, Position P ); List Delete( List L, Position P ); 其中List结构定义如下： typedef struct LNode *PtrToLNode; struct LNode { ElementType Data; PtrToLNode Next; }; typedef PtrTo
C语言数据结构与算法pta合集：6-2 链式表操作集
我就知道你会来，我们一起进步吧！
01-05 842
其中List：返回线性表中首次出现X的位置。若找不到则返回ERROR；：将X插入在位置P指向的结点之前，返回链表的表头。如果参数P指向非法位置，则打印“Wrong Position for Insertion”，返回ERROR；：将位置P的元素删除并返回链表的表头。若参数P指向非法位置，则打印“Wrong Position for Deletion”并返回ERROR。
卢同学的Java笔记_2：链式表--数据结构
weixin_44745766的博客
04-17 216
Hey，我是寒水，一名大二学生，电子商务专业在读，正在学习Java中。我试图将在Java学习中遇到的一些困惑和最终的解答发在这个账号上，希望以此来激励我不要放弃学习！ 链表是一种数据元素按照链式存储结构进行存储的数据结构，物理上具有非连续的特点。链表有一系列的数据结点组成，每个结点又包含数据域和应用域两部分。 数据部分，保存的是该节点的实际数据 地址部分，保存的是下一个结点的地址 ...
《数据结构：python语言描述》2.5上机实验顺序表和链式表
weixin_43116971的博客
03-18 2691
顺序表和链式表的一些基础操作
【PTA】数据结构第二次上机实验：2-1 逆序数据建立链表2-3 链式表的按序号查找2-4 求链式表的表长2-5 单链表逆转2-6 两个有序链表序列的合并2-7 单链表 - 20. 单值化(去重)
qq_61903414的博客
10-27 2489
函数createlist利用scanf从输入中获取一系列正整数，当读到−1时表示输入结束。按输入数据的逆序建立一个链表，并返回链表头指针。链表节点结构定义如2-2 链式表操作集分数 20全屏浏览题目切换布局作者 陈越单位 浙江大学本题要求实现链式表的操作集。while(L!}L=L->Next;}}L = n;return L;
顺序表、链式表、顺序栈、链式栈以及顺序队列、链式队列
weixin_65012900的博客
08-06 615
数据结构 表 栈 队列
PTA_数据结构与算法_6-3 求链式表的表长 (10分)
hqy的草稿本
03-28 680
本题要求实现一个函数，求链式表的表长。 函数接口定义： int Length( List L ); 其中List结构定义如下： typedef struct LNode *PtrToLNode; struct LNode { ElementType Data; PtrToLNode Next; }; typedef PtrToLNode List; L是给定单链表，函数Leng...
数据结构 链式表
abcdefghijk0987的博客
12-03 204
　　数据结构课作业之链式表。 1 #include <cstdio> 2 #include <cstring> 3 #include <iostream> 4 using namespace std; 5 6 struct Node 7 { 8 char name[30]; 9 ...
数据结构之顺序表、链式表
weixin_49237256的博客
08-20 754
一、什么是数据结构 1、数据结构的起源 1968年，美国的高纳德教授开设了一门基本算法的课程，开创了数据结构的先河。 数据结构是一门研究数据之间关系和操作的学科，而非是计算方法。 数据结构+算法=程序 沃思凭借这名个论点，获得图灵奖，这句话展示出了程序的本质。 2、数据结构的基本概念 数据：所有能够输入到计算机中去描述事物的符号。 数据项：有独立含义的数据最小单位，也叫域。 数据元素：数据的基本单位也叫节点、记录。 数据结构：数据元素和数据关系的集合。 算法：数据结构所具备的功能，解决特定的问题的方法。 3
深入理解数据结构中的链式表及其C#实现
weixin_36238982的博客
10-19 1045
本文还有配套的精品资源，点击获取 简介：链式表作为计算机科学的基础数据结构，在编程中扮演关键角色。本文详细介绍了链式表的原理、特点及C#语言实现，包括单链表、循环链表和双链表的定义、操作与应用。通过VS2008开发环境和C#语言示例，读者将学习到链表节点的创建、链表操作如添加、删除和遍历节点的实现方法。链式表在多种数据处理场合中的应用也被提及，强调了其在编程中的重要性和实用...
数据结构顺序表和链式表
xiaoyu1381的博客
08-05 504
数据结构中顺序表、链式表
数据结构----线性表（二）链式表
yjh3319227265的博客
11-05 1427
此篇文章为线性表的链式表的学习笔记（根据老师所讲），如有雷同，纯属意外。链式表又称单链表、链式存出结构，用于存储逻辑关系“一对一”的数据。与顺序表的不同，使用链式表存储数据，不强制要求数据在内存中集中存储，各个元素可以分散存储在内存中。数据域用来存储元素数值数据，指针域用来存储直接后继结点的存储位置。结点是数据元素的存储映像，由数据域和指针域两个部分组成。链表是n个结点由指针链组成一个链表，它是线性表的链式存储映像，称为线性表的链式存储结构。上图为一个整体称为结点。
顺序表与链式表的数据结构实现与比较
weixin_31419153的博客
05-02 824
在计算机科学中，数据结构是用于存储和组织数据的一种方式，它决定了数据如何被处理、检索、修改和存储。合理选择和使用数据结构对于程序性能优化至关重要。在数据结构中，顺序表是一种常见的线性数据结构，它利用一段连续的存储单元一次存放线性表的数据元素。顺序表可以是静态分配的，也可以是动态扩展的。静态顺序表在定义时就需要指定最大长度，而动态顺序表则在运行过程中可以根据需要动态地增加容量。顺序表的特性主要体现在以下几个方面：随机访问。
看数据结构写代码（51） 广义表的头尾链式存储
fuming0210sc的专栏
04-18 1920
广义表是一种非线性的数据结构。但如果广义表的每个元素都是原子，它就变成了线性表。广义表广泛地用于人工智能等领域的LISP语言。 广义表一般记作 LS = (a1, a2, ···, an), n是它的长度，ai可以是单个元素(原子)，也可以是广义表(子表)，当广义表非空时，称第一个元素a1为LS的表头，称其余元素组成的表为LS的表尾。注意：表头是元素(可以是原子，也可以是广表)，表尾一定是广
数据结构C++版链式表
qq_46891664的博客
06-07 421
//链式表 #include<iostream> using namespace std; struct LinkNode { int data; LinkNode* link; LinkNode(LinkNode* ptr = NULL) { link = ptr; } LinkNode(const int& item, LinkNode* ptr = NULL) { data = item; link = ptr; } }; class List { publ
【数据结构与算法】6-3 求链式表的表长 (10分)
qq_42292109的博客
02-26 1906
本题要求实现一个函数，求链式表的表长。 函数接口定义： int Length( List L ); 其中List结构定义如下： typedef struct LNode *PtrToLNode; struct LNode { ElementType Data; PtrToLNode Next; }; typedef PtrToLNode List; L是给定单链表，函...
数据结构 链式表的按序号查找
inooll的博客
04-20 647
本题要求实现一个函数，找到并返回链式表的第K个元素。 函数接口定义： ElementType FindKth( List L, int K ); 其中List结构定义如下： typedef struct LNode *PtrToLNode; struct LNode { ElementType Data; PtrToLNode Next; }; typedef PtrToLNod...
C语言实现链式表：数据结构基础与实战
weixin_31569663的博客
10-25 904
在C语言中，链表的本质是一个由结构体构成的动态数据集合，各节点通过指针相互关联。要正确建模链表，必须掌握结构体定义、指针成员声明以及类型别名的使用技巧。这些基础语法元素共同构成了链表的底层支撑框架。首先需要定义栈节点的基本结构。每个节点包含两个部分：数据域用于存储实际值，指针域指向下一个节点（即向下一层的元素）。以下是使用C语言struct和typedef实现的链式栈节点模型：// 定义栈节点结构int data;// 数据域，存放整型数据// 指针域，指向下一个节点。
GXF 3.2.0 to 4.0 CUDA 12 路径 API 与数据结构增量分析
最新发布
eloudy的专栏
08-18 237
分析范围：以仓库中与分支对比为基础，聚焦）可用的公共 API 与数据结构变化。由于 GXF 核心头文件在各 CUDA 版本间共享，下列新增/修改的接口在 CUDA 12 构建上同样生效。对比链接：https://github.com/NVIDIA-ISAAC-ROS/isaac_ros_nitros/compare/release-3.2…release-4.0。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

you-_ling

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

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

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

打赏作者

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

抵扣说明：

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

余额充值