数据结构（一）线性结构（2）链表

最新推荐文章于 2022-03-27 10:40:22 发布
最新推荐文章于 2022-03-27 10:40:22 发布
阅读量258 收藏
点赞数
分类专栏： 数据结构及算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/floatinglong/article/details/104950277
版权

链表是线性表的另一种表示方法，其特点是每个元素包含数据域和指针域，指针域的存在使得链表元素之间在空间上不必连续（即地址不连续），并且链表元素节点可以用时分配，比顺序表要灵活，但如果节点数较多，耗费空间资源比顺序表要多

链表有单向链表、双向链表、十字链表、循环链表等，这里仅简单介绍单向链表，其它链表形式大同小异

其基本定义：

typedef struct LIST{
    int idata;
    struct LIST *ptNext;
}T_List, *PT_List;

idata是节点的数据域，ptNext为指针域，指向下一个节点

 

为链表提供一个头节点，会给链表（对头部节点的）操作带来极大的便利，下面会给出无头节点和有头节点两个版本的代码

 

 

链表主要操作有：

1、创建一个链表：PT_List createList(void)

在无头节点版本中，创建链表要知道第一个数据的值

在有头节点版本中，创建链表只需要创建一个头节点，不需要有实际的元素

2、从链表中查找指定元素节点：PT_List findInList(int iX, PT_List ptHead)

两版本查找元素过程是一致的，只需要判空然后按照节点指针域遍历节点的数据域即可

3、从链表中修改指定节点的数据域：PT_List alterInList(int iNew, int iPre, PT_List ptHead, int iFlag)

两版本的修改节点数据域过程一致，根据数据域找到指定节点进行修改即可

4、向链表插入元素节点：PT_List addToList(int iNew, int iPre, PT_List ptHead, int iFlag)

插入节点可以分为从链表头插入、从链表尾插入、从链表中某个节点后插入

对于无头节点版本，无论哪种插入，都需要判空，如果链表为空，则创建第一个节点，如果不为空，从链表头插入时，可以采用两种方法：①创建新节点，新节点的指针域指向原链表第二个节点，然后原链表第一个节点的指针域指向新节点，这样就把新节点插入到原链表的第一、第二节点之间，然后把新节点数据域与第一个节点数据域交换即可；②创建新节点，指针域指向链表第一个节点，保存新节点数据域后，修改链表头部指针，指向新节点，这要求子函数传入参数为二重指针

对于有头节点版本，从链表头插入时，只需要按照①的方法插入即可，数据域无需交换，因为头节点只起标志性作用，不作为真实数据节点

后面两种插入方法，有无头节点其过程都是一致的（除了无头节点情况需要判空以外）

从链表尾插入时，遍历找到尾节点（单链表查找依据是指针域为NULL），然后让尾节点指向新节点即可从某个节点后插入时，遍历找到特定节点（查找依据是数据域），然后用变量暂存特定节点的下一个节点，插入过程类似从链表头插入

5、从链表中删除指定节点PT_List deleteFromList(int iX, PT_List ptHead, int iFlag)

删除节点也可以分为删除头节点、尾节点、中间节点三种情况，方法类似插入节点

 

无头节点版本代码：

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

#ifdef DEBUG_LIST_VERSION_1



#define MENU_EXIT				0
#define MENU_FIND				1
#define MENU_ADD				2
#define MENU_ALTER				3
#define MENU_DELETE				4
#define MENU_PRINT				5


#define ADD_IN_HEAD			1
#define ADD_IN_TAIL			2
#define ADD_IN_MID			3
#define DELETE_ONE_VALUE	1		
#define DELETE_ALL_VALUE	2	
#define ALTER_ONE			1	
#define ALTER_ALL			2

typedef struct LIST{
	int idata;
	struct LIST *ptNext;
}T_List, *PT_List;


PT_List createList(void)
{
	int i, iNum;
	PT_List ptHead, ptPre, ptTmp;

	printf("Enter the num of nodes: ");
	scanf_s("%d", &iNum);
	if (iNum <= 0)
	{
		printf("Err: num <= 0\r\n");
		return NULL;
	}

	printf("Enter your data: ");
	ptHead = (PT_List)malloc(sizeof T_List);
	scanf_s("%d", &ptHead->idata);
	ptHead->ptNext = NULL;
	ptPre = ptHead;

	for (i = 1; i < iNum; i++)
	{		
		ptTmp = (PT_List)malloc(sizeof T_List);
		scanf_s("%d", &ptTmp->idata);
		ptTmp->ptNext = NULL;
		ptPre->ptNext = ptTmp;	
		ptPre = ptTmp;
	}

	return ptHead;
}

void printList(PT_List ptHead)
{
	PT_List ptTmp = ptHead;
	
	printf("\r\n");
	if(!ptTmp)
		printf("List is empty\r\n");
	while (ptTmp)
	{
		printf("%d ", ptTmp->idata);
		ptTmp = ptTmp->ptNext;
	}
	printf("\r\n\r\n");
}

PT_List findTheListTail(PT_List ptHead)
{
	PT_List	ptTmp = ptHead;

	while (ptTmp->ptNext)
		ptTmp = ptTmp->ptNext;

	return ptTmp;
}

PT_List findBeforeOne(int iX, PT_List ptHead)
{
	PT_List ptTmp = ptHead, ptPre = NULL;
	int i = 1;


	while (ptTmp->idata != iX && ptTmp->ptNext)
	{
		ptPre = ptTmp;
		ptTmp = ptTmp->ptNext;
		i++;
	}
	if (ptTmp->idata != iX)
	{
		printf("Can't Find the node %d\r\n", iX);
		return NULL;
	}
	printf("Find the node in %d\r\n", --i);

	return ptPre;
}

PT_List findInList(int iX, PT_List ptHead)
{
	PT_List ptTmp = ptHead;
	int i = 1;

	if (!ptHead)
	{
		printf("List is empty\r\n");
		return NULL;
	}
	while (ptTmp->idata != iX && ptTmp->ptNext)
	{
		ptTmp = ptTmp->ptNext;
		i++;
	}
	if (ptTmp->idata != iX)
	{
		printf("Can't Find the node %d\r\n", iX);
		return NULL;
	}

	return ptTmp;
}

PT_List addToList(int iNew, int iPre, PT_List *pptHead, int iFlag)
{
	PT_List ptTmp = NULL, ptNew;
	int iTmp;

	if (iFlag != ADD_IN_HEAD && iFlag != ADD_IN_TAIL && iFlag != ADD_IN_MID)
	{
		printf("Err in iFlag\r\n");
		return NULL;
	}

	ptNew = (PT_List)malloc(sizeof T_List);
	if (!ptNew)
	{
		printf("Err in memory\r\n");
		return NULL;
	}
	if (!*pptHead)
	{
		*pptHead = ptNew;
		(*pptHead)->idata = iNew;
		(*pptHead)->ptNext = NULL;
		return *pptHead;
	}


	if (iFlag == ADD_IN_HEAD)
	{
		ptNew->ptNext =( *pptHead)->ptNext;
		(*pptHead)->ptNext = ptNew;
		iTmp = iNew;
		ptNew->idata = (*pptHead)->idata;
		(*pptHead)->idata = iTmp;
	}
	else if (iFlag == ADD_IN_TAIL)
	{
		ptTmp = findTheListTail(*pptHead);
		ptTmp->ptNext = ptNew;
		ptNew->ptNext = NULL;
		ptNew->idata = iNew;
	}
	else if (iFlag == ADD_IN_MID)
	{
		ptTmp = findInList(iPre, (*pptHead));
		if (!ptTmp)
		{
			printf("Err in the location\r\n");
			free(ptNew);
			return NULL;
		}
		ptNew->ptNext = ptTmp->ptNext;
		ptTmp->ptNext = ptNew;
		ptNew->idata = iNew;
	}

	return *pptHead;
}

PT_List alterInList(int iNew, int iPre, PT_List ptHead, int iFlag)
{
	PT_List ptTmp;
	
	if (iFlag != ALTER_ONE && iFlag != ALTER_ALL)
	{
		printf("Err in iFlag\r\n");
		return NULL;
	}

	ptTmp = findInList(iPre, ptHead);
	if (!ptTmp)
		return NULL;
	do
	{
		ptTmp->idata = iNew;
		if (iFlag == ALTER_ONE)
			break;
		ptTmp = findInList(iPre, ptHead);
	} while (ptTmp);


	return ptHead;
}

PT_List deleteFromList(int iX, PT_List *pptHead, int iFlag)
{
	PT_List ptPre, ptTmp = NULL;

	if(iFlag != DELETE_ONE_VALUE && iFlag != DELETE_ALL_VALUE)
	{
		printf("Err in iFlag\r\n");
		return NULL;
	}

	if (!(*pptHead)->ptNext)
	{
		ptTmp = *pptHead;
		*pptHead = NULL;
		free(ptTmp);
		return NULL;
	}

	while ((*pptHead)->idata == iX)
	{
		ptTmp = (*pptHead)->ptNext;
		(*pptHead)->idata = ptTmp->idata;
		(*pptHead)->ptNext = ptTmp->ptNext;
		free(ptTmp);
		if (iFlag == DELETE_ONE_VALUE)
			return *pptHead;
	}
	ptPre = findBeforeOne(iX, *pptHead);
	if (!ptPre)
	{
		printf("Err in the element\r\n");
		return NULL;
	}
	while (ptPre)
	{
		ptTmp = ptPre->ptNext;
		ptPre->ptNext = ptTmp->ptNext;
		free(ptTmp);
		if (iFlag == DELETE_ONE_VALUE)
			break;
		ptPre = findBeforeOne(iX, *pptHead);
	}

	return *pptHead;
}

int menu(PT_List *pptHead)
{
	int iNum, iEle, iTmp = 0;

	printf(	"Enter\r\n"
			"0 to exit\r\n"
			"1 to find\r\n"
			"2 to add\r\n"
			"3 to alter\r\n"
			"4 to delete\r\n"
			"5 to print\r\n");

	scanf_s("%d", &iNum);
	switch (iNum)
	{
		case MENU_EXIT:
			return -1;
		case MENU_FIND:
			printf("Enter the element: ");
			scanf_s("%d", &iEle);
			findInList(iEle, *pptHead);
			break;
		case MENU_ADD:
			printf( "Enter\r\n"
					"1 to add in head\r\n"
					"2 to add in tail\r\n"
					"3 to add in mid\r\n");
			scanf_s("%d", &iNum);
			if (iNum == ADD_IN_MID)
			{
				printf("Enter the num before the one to be altered: ");
				scanf_s("%d", &iTmp);
			}
			printf("Enter the element: ");
			scanf_s("%d", &iEle);
			addToList(iEle, iTmp, pptHead, iNum);
			break;
		case MENU_ALTER:
			printf("Enter\r\n"
				"1 to alter one\r\n"
				"2 to alter all\r\n");
			scanf_s("%d", &iNum);
			printf("Enter the Pre element: ");
			scanf_s("%d", &iTmp);
			printf("Enter the new element: ");
			scanf_s("%d", &iEle);
			alterInList(iEle, iTmp, *pptHead, iNum);
			break;
		case MENU_DELETE:
			printf("Enter\r\n"
				"1 to delete in one\r\n"
				"2 to delete in all\r\n");
			scanf_s("%d", &iNum);
			printf("Enter the element: ");
			scanf_s("%d", &iEle);
			deleteFromList(iEle, pptHead, iNum);
			break; 
		case MENU_PRINT:
			printList(*pptHead);
			break;
	}

	return 0;
}

int main(void)
{
	PT_List ptHead;
	
	ptHead = createList();
	if (!ptHead)
		return -1;

	
	while (menu(&ptHead) >= 0);

	return 0;
}

#endif

 

 

 

 

 

有头节点版本代码：

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

#ifdef DEBUG_LIST_VERSION_2

#define MENU_EXIT	0
#define MENU_FIND	1
#define MENU_ADD	2
#define MENU_ALTER	3
#define MENU_DELETE	4
#define MENU_PRINT	5

#define ADD_IN_HEAD	1
#define ADD_IN_TAIL	2
#define ADD_IN_MID	3

#define ALTER_ONE	1
#define ALTER_ALL	2

#define DELETE_ONE	1
#define DELETE_ALL	2

typedef struct LIST {
	int idata;
	struct LIST *ptNext;
}T_List, *PT_List;

PT_List createList(void)
{
	PT_List ptPre, ptNew, ptHead;
	int iNum;

	printf("Enter the num of nodes: ");
	scanf_s("%d", &iNum);
	if (iNum < 0)
	{
		printf("Err in the num of nodes\r\n");
		return NULL;
	}
	ptHead = (PT_List)malloc(sizeof T_List);
	ptHead->ptNext = NULL;
	ptPre = ptHead;
	printf("Enter your data: ");
	while (iNum-- > 0)
	{
		ptNew = (PT_List)malloc(sizeof T_List);
		scanf_s("%d", &ptNew->idata);
		ptNew->ptNext = NULL;
		ptPre->ptNext = ptNew;
		ptPre = ptNew;
	}

	return ptHead;
}

void printList(PT_List ptHead)
{
	PT_List ptTmp = ptHead->ptNext;

	printf("\r\n");
	if (!ptTmp)
		printf("List is empty\r\n");
	while (ptTmp)
	{
		printf("%d ", ptTmp->idata);
		ptTmp = ptTmp->ptNext;
	}
	printf("\r\n\r\n");
}

int isEmpty(PT_List ptHead)
{
	return ptHead->ptNext == NULL ? 1: 0;
}

PT_List findListTail(PT_List ptHead)
{
	PT_List ptTmp = ptHead->ptNext;

	if (isEmpty(ptHead))
	{
		printf("List is empty\r\n");
		return NULL;
	}

	while (ptTmp->ptNext)
		ptTmp = ptTmp->ptNext;

	return ptTmp;
}

PT_List findInList(int iX, PT_List ptHead)
{
	PT_List ptTmp = ptHead->ptNext;
	int i = 1;

	if (isEmpty(ptHead))
	{
		printf("List is empty\r\n");
		return NULL;
	}
	while (ptTmp->idata != iX && !isEmpty(ptTmp))
	{
		i++;
		ptTmp = ptTmp->ptNext;
	}
	if (ptTmp->idata != iX)
	{
		printf("Can't find the %d\r\n", iX);
		return NULL;
	}
	printf("Find the node %d in %d\r\n", iX, i);

	return ptTmp;
}

PT_List addToList(int iNew, int iPre, PT_List ptHead, int iFlag)
{
	PT_List ptNew, ptTmp, ptPre;

	if (iFlag != ADD_IN_HEAD && iFlag != ADD_IN_TAIL && iFlag != ADD_IN_MID)
	{
		printf("Err in iFlag\r\n");
		return NULL;
	}
	ptNew = (PT_List)malloc(sizeof T_List);
	ptNew->idata = iNew;
	ptNew->ptNext = NULL;
	switch (iFlag)
	{
		case ADD_IN_HEAD:
			ptTmp = ptHead->ptNext;
			ptHead->ptNext = ptNew;
			ptNew->ptNext = ptTmp;
			break;
		case ADD_IN_TAIL:
			ptPre = findListTail(ptHead);
			ptPre->ptNext = ptNew;
			break;
		case ADD_IN_MID:
			ptPre = findInList(iPre, ptHead);
			ptTmp = ptPre->ptNext;
			ptNew->ptNext = ptTmp;
			ptPre->ptNext = ptNew;
			break;
	}

	return ptHead;
}


PT_List alterInList(int iNew, int iOld, PT_List ptHead, int iFlag)
{
	PT_List ptTmp;

	if (iFlag != ALTER_ONE && iFlag != ALTER_ALL)
	{
		printf("Err in iFlag\r\n");
		return NULL;
	}

	ptTmp = findInList(iOld, ptHead);
	if (!ptTmp)	
		return NULL;
	
	while (ptTmp)
	{
		ptTmp->idata = iNew;
		if (iFlag == ALTER_ONE)
			break;
		ptTmp = findInList(iOld, ptHead);
	}

	return ptHead;
}

PT_List findBeforeOne(int iEle, PT_List ptHead)
{
	PT_List ptTmp = ptHead->ptNext, ptPre = ptHead;

	if (isEmpty(ptHead))
	{
		printf("List is empty\r\n");
		return NULL;
	}
	
	while (ptTmp->idata != iEle && ptTmp->ptNext)
	{
		ptPre = ptTmp;
		ptTmp = ptTmp->ptNext;
	}

	if (ptTmp->idata != iEle)
	{
		printf("Can't find the element\r\n");
		return NULL;
	}

	return ptPre;
}

PT_List deleteFromList(int iEle, PT_List ptHead, int iFlag)
{
	PT_List ptPre, ptTmp;
	if (iFlag != DELETE_ONE && iFlag != DELETE_ALL)
	{
		printf("Err in iFlag\r\n");
		return NULL;
	}

	ptPre = findBeforeOne(iEle, ptHead);
	while (ptPre)
	{
		ptTmp = ptPre->ptNext;
		if (!ptTmp->ptNext)
			ptPre->ptNext = NULL;
		else
			ptPre->ptNext = ptTmp->ptNext;
		free(ptTmp);
		if (iFlag == DELETE_ONE)
			break;
		ptPre = findBeforeOne(iEle, ptHead);
	}

	return ptHead;
}

int menu(PT_List ptHead)
{
	int iNum, iEle, iLoc = 0;

	printf("Enter\r\n"
		"0 to exit\r\n"
		"1 to find\r\n"
		"2 to add\r\n"
		"3 to alter\r\n"
		"4 to delete\r\n"
		"5 to print\r\n");

	scanf_s("%d", &iNum);
	switch (iNum)
	{
		case MENU_EXIT:
			return -1;
		case MENU_FIND:
			printf("Enter the element to be found: ");
			scanf_s("%d", &iEle);
			findInList(iEle, ptHead);
			break;
		case MENU_ADD:
			printf("Enter\r\n"
				"1 to add in head\r\n"
				"2 to add in tail\r\n"
				"3 to add in mid\r\n");
			scanf_s("%d", &iNum);
			printf("Enter the element to be added: ");
			scanf_s("%d", &iEle);
			if (iNum == ADD_IN_MID)
			{
				printf("Enter the element before the one to be added: ");
				scanf_s("%d", &iLoc);
			}
			addToList(iEle, iLoc, ptHead, iNum);
			break;
		case MENU_ALTER:
			printf("Enter\r\n"
				"1 to alter one\r\n"
				"2 to alter all\r\n");
			scanf_s("%d", &iNum);
			printf("Enter the Pre element: ");
			scanf_s("%d", &iLoc);
			printf("Enter the new element: ");
			scanf_s("%d", &iEle);
			alterInList(iEle, iLoc, ptHead, iNum);
			break;
		case MENU_DELETE:
			printf("Enter\r\n"
				"1 to delete in one\r\n"
				"2 to delete in all\r\n");
			scanf_s("%d", &iNum);
			printf("Enter the element: ");
			scanf_s("%d", &iEle);
			deleteFromList(iEle, ptHead, iNum);
			break;
		case MENU_PRINT:
			printList(ptHead);
			break;
	}

	return 0;
}

int main(void)
{
	PT_List ptHead;

	ptHead = createList();
	if (!ptHead)
		return -1;

	while (menu(ptHead) >= 0);

	return 0;
}

#endif

 

 

floatinglong
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构（一）线性链表、非线性链表、稀疏数组与队列、单向链表
codinglover5的博客
08-07 3238
数据结构和算法的关系 ➢数据data结 构(structure)是一门研究组织数据方式的学科，有了编程语言也就有了 数据结构.学好数据结构可以编写出更加漂亮更加有效率的代码。 ➢要学习好数据结构就要多多考虑如何将生活中遇到的问题,用程序去实现解决. ➢程序=数据结构+算法 ➢数据结构是算法的基础，换言之，想要学好算法，需要把数据结构学到位。 线性链表和非线性链表 数据结构包括:线性结构和非线性结构。 线性结构 1)线性结构作为最常用的数据结构，其特点是数据元素之间存在- -对- - 的线性关系（a[0]=3
线性结构之链表
xiaohongya的博客
08-04 271
面试题：一个单向链表，不知道头节点,一个指针指向其中的一个节点，问如何删除这个指针指向的节点？ 答：将这个指针指向的next节点值copy到本节点，将next指向next->next,并随后删除原next指向的节点 所以设指向待删除节点的指针为p，设其后节点为q； q=p->next; temp = q->data; q->data = p->data; p->...
链表-线性结构
qq_50034496的博客
11-23 568
线性表是最基础的线性结构 #mermaid-svg-Y6GSSwhSHDF8u0OM .label{font-family:'trebuchet ms', verdana, arial;font-family:var(--mermaid-font-family);fill:#333;color:#333}#mermaid-svg-Y6GSSwhSHDF8u0OM .label text{fill:#333}#mermaid-svg-Y6GSSwhSHDF8u0OM .node rect,#mermaid-s
线性结构-链表
weixin_34198762的博客
07-25 101
链表定义 n个节点离散分配 彼此通过指针相连 每个节点只有一个前驱节点，每个节点只有一个后继节点 首节点没有前驱节点，尾节点没有后继节点 专业术语 头结点： 第一个有效节点为前的节点 头节点一般不存放数据 加头结点的目的是为了方便链表的操作 首结点：第一个存放有效数据的节点 尾结点：最后一个存放...
链表——一种线性数据结构
weixin_43772228的博客
05-13 1525
链表 链表中的每个元素实际上是一个单独的对象，而所有对象都通过每个元素中的引用字段链接在一起。 线性数据结构 与数组一样，链表也是线性数据结构，他们的区别在于存储方式不同。 顺序存储结构（数组）：快速的存和取，逻辑上相邻，物理上也相邻。 链式存储结构（链表）：快速的删和改，节点在内存中并不相邻，且相比数组需要更多存储空间。 Tips:链表的遍历时间复杂度为O(n),增删的时间复杂度为O(1)...
线性数据结构——链表
SilentLand的博客
05-18 1391
线性数据结构——链表 链表是一个线性结构，同时也是一个天然的递归结构。链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。 js模拟链表 // 节点 (构成链表) class Node { constructor (v, next) { this.value = v this.next = next } } // 链表的管理, 增删改查 class LinkList { constructor () { // 链表的长度 this.size =
数据结构实验三-有关线性链表的操作_数据结构实验三-有关线性链表的操作_
10-03
线性链表是一种基本的数据结构，它在计算机科学中扮演着重要的角色，特别是在数据结构与算法的学习中。在这个数据结构实验三中，我们将探讨如何操作线性链表，包括建立、初始化、插入元素、删除元素、清空以及摧毁...
链表教程，链表是一种常见的数据结构，用于存储一系列线性数据
最新发布
07-31
链表
数据结构线性链表
06-28
数据结构实现C++线性链表，实现增删改查基本方法
数据结构课设报告，城市链表
08-09
在数据结构中，链表是一种线性数据结构，其元素（节点）在内存中不是连续存储的，而是通过指针链接。单链表每个节点包含数据域和指针域，指针域指向下一个节点。链表操作相比于数组更灵活，但访问速度相对较慢。 3....
线性结构_链表
gzhu_wzb
03-19 407
1、定义： n个节点离散分配； 每个节点只有一个前驱结点，每个节点只有一个后续节点； 首节点没有前驱结点，尾节点没有后续节点； 2、专业术语： 头节点：第一个有效节点之前的节点，方便对链表进行操作，并不存放有效数据，头节点的数据类型与首节点一致； 首节点：第一个有效节点； 尾节点：最后一个有效节点； 头指针：指向头节点的指针变量； 尾指针：指向尾节点的指针变量。
线性表-链式结构
weixin_34019144的博客
12-03 133
昨天在学习顺序结构的内容时感觉并不难,但是你会在编写代码的时候发现他的结构的弊端 只要是扩容,或者中间插入,那么你必须把数组拷贝来拷贝去的麻烦 昨天在测试一千万还是五千万的时候,由于需要分配内存空间,直接涨上1G的使用空间,如果你电脑没有这个内存富余,那么分配空间很可能会会失败掉 为了克服上面的问题,那么我们今天来学习饿线性表的链式结构 什么...
【数据结构】线性结构——线性表之链式存储结构（链表）
Jacky_Feng的博客
09-13 5152
文章目录 前言 一、链表概述 二、单链表的定义 1.定义 三、单链表的操作 前言 为了克服顺序表存储结构的缺点，充分利用存储空间和提高运行效率，线性表可以采用另一种存储结构——链式存储结构。线性表的链式存储结构简称“链表（link list）” 一、链表概述 链表的数据元素所占的存储单元地址可以是连续的，也可以是不连续的，可根据需要临时、动态地申请分配相应的存储空间，数据元素之间的逻辑关系可以用“链”来表达。 链表的插入和删除不需要移动数据元素，只需要修改链即可实现。 ..
线性表 —— 三种链表
qq_52473141的博客
10-30 739
三种链表单链表基本操作（带头结点）IntiList L(LinkList &L);ListEmpty(LinkList L);DestroyList(LinkList &L);ClearList(LinkList &L); 对比DestroyListListLength(LinkList L)GetElem(LinkList L, int i, ElemType **&e**);LocateElem(L,e)LinkInsert(&L, i, e)ListDelete
数据结构系列-线性表（顺序表和链表）
weixin_52199109的博客
05-01 1642
线性表的定义和特点 线性结构的基本特点：除第一个元素无直接前驱，最后一个元素无直接后继，其他元素都有一个前驱和一个后继。 说人话就是：第一个元素不能向前访问，最后一个元素不能向后访问，中间的元素都可以前后访问其他元素。 例如：26个字母表{A,B,C,D,E,F…}就是一个线性表. 虽然该线性表中数据元素各不相同，但每个元素都具有相同的特性，都属于同一数据对象 线性表：由有限个数据特性相同的数据元素构成的***有限序列*** 如果没有数据元素，该线性表也叫空表。 ...
线性表--链表
weixin_60840655的博客
03-27 955
对链表的理解，和示例演示，洛谷--队列安排
线性链表
wst1419809286的博客
09-15 404
线性链表（list）：零个或多个数据元素的有限序列。   ADT 线性表（List） Data 线性表的数据对象集合为{a1,a2,……,an},每个元素的类型均为DataType。其中，除第一个元素外，每一个元素有且只有一个直接前去元素，出最后一个元素an外，每一个元素有且只有一个直接后继元素，元素之间的关系是一对一的关系。 Operation    ...
线性表的链式表示：链表详解
ln_acmc的博客
03-20 2652
文章目录（一）链表的定义 （一）链表的定义 线性表的链式存储结构即链表，其特点是用一组**任意**的存储单元存储线性表的数据元素，这组在内存 中的存储单元可以是连续的，也可以是不连续的。链表，顾名思义，是由各个节点链接。节点的信息包含**数 据域**和**指针域**。数据域存储元素信息，指针域用来存储直接后继节点的地址（两节点间的箭头）。n个节点 链接成一个链表，每个元素节点都只有一个指针域，又称为**单链表**。 (https://img-blog.csdnimg.cn/20210320160
数据结构——线性表的链式表示
Tyler_Zx的博客
07-17 3667
线性表的定义 线性表是具有相同数据类型的n(n >= 0)个数据元素的有限序列。其中n为表长，当n = 0时，该线性表是一个空表。若用L命名线性表，其一般表示为：L = (a1, a2, ..., ai, ai+1, ..., an)。其中a1是唯一的”第一个”数据元素，an是唯一的”最后一个”数据元素。除第一个元素外，每个元素有且仅有一个直接前驱。除最后一个元素外，每个元素有且仅有一个直...
数据结构解析：线性链表与存储结构
在数据结构中，线性链表是一种基础且重要的数据结构类型。它不同于数组，链表的元素不需在内存中连续存放，而是通过指针连接。这里提到了两种特殊的链表形式：循环链表和双向链表。 循环链表的特点是链表的最后一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值