【数据结构笔记】线性表NOTE2——单链表

最新推荐文章于 2023-03-24 18:00:00 发布
最新推荐文章于 2023-03-24 18:00:00 发布
阅读量169 收藏
点赞数 1
分类专栏： 数据结构笔记 文章标签： 指针 链表 数据结构 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51057584/article/details/115824229
版权

一 单链表的概念

不同于在内存空间中连续存放线性表的顺序存储方式，链式存储为线性表的另一种存储方式，在链式存储中，表中逻辑上相邻的元素在物理地址空间上不一定相邻，只要元素的指针域中存放的指针指向下一个元素结点即可。
图1

二 单链表的定义

单链表的每个结点都是一个结构体变量LNode，其中数据域变量存储结点数据（这里，以double类型的变量为结点数据的类型），指针域变量为LNode*类型的指针变量。

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

typedef struct LNode {
	double Data; //数据域
	struct LNode* next; //指针域
}LNode, *LinkList;
//定义单链表的结点

int main(void) {

	LinkList Head = (LinkList)malloc(sizeof(LNode)); 
	//动态分配头结点，并将指向头结点的指针赋值给头指针Head
	if (!Head) {
		printf("Allocation Failure!\n");
		exit(EXIT_FAILURE);
	} //检验存储头结点的内存空间是否分配成功，若失败则退出程序

	return 0;
}

三 单链表的基本操作

与顺序表一样，同为线性表，单链表常见基本操作如下：
①初始化；
②求表长；
③插入操作；
④删除操作；
⑤按位查找；
⑥按值查找；
⑦输出操作；
⑧判空操作；
⑨销毁操作
下面一一讨论上述列举的九种单链表基本操作。

①初始化
我们将初始化操作交由函数InitList完成，而非在main函数中完成。

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

typedef struct LNode {
	double Data; //数据域
	struct LNode* next; //指针域
}LNode, *LinkList;
//定义单链表的结点

void InitList(LinkList* list) {
	*list = (LinkList)malloc(sizeof(LNode)); 
	//动态分配头结点，并将指向头结点的指针的值赋给头指针
	
	if (!*list) {
		printf("Allocation Failure!\n"); //输出提示分配错误
		exit(EXIT_FAILURE);
	} //若存放头结点的存储空间分配失败，则退出程序

	(*list)->next = NULL; //头结点指针域置空
} 
//初始化链表

注意头指针置空这一步操作不能少，否则(*list)->next将为野指针。

②求表长
沿着指针域中的指针，一个一个结点地移动，每移动一个结点，计数器变量便加1，直到访问到末尾一个结点的空指针域，此时便可将计数器的值作为求表长函数的返回值。

typedef struct LNode {
	double Data; //数据域
	struct LNode* next; //指针域
}LNode, *LinkList;
//定义单链表的结点

int ListLength(LinkList head) {
	LinkList mover = head; 
	//声明在计算表长过程中往前移动的指针
	
	int Counter = 0;
	//表长的计数器，初始值置为0
	
	while (mover->next) {
		mover = mover->next; //向下一个结点的指针域移动
		Counter++; //表长计数器加1
	} //表长计数
	return Counter;
}
//求链表的表长

③插入操作
单链表插入操作示意图如下：
图2
先将指针移动到相应位序，再进行上图所示的插入操作。

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

typedef struct LNode {
	double Data; //数据域
	struct LNode* next; //指针域
}LNode, *LinkList;
//定义单链表的结点

bool ListInsert(LinkList head, double value, int Loc) {
	LinkList move = head, insert; 
	//用于在寻找相应位序的结点时移动的指针，及接收新插入的结点的指针
	
	int length = ListLength(head); 
	//声明并计算操作对象链表的长度
	
	if (Loc<1 || Loc>length + 1) {
		printf("Input valid location!\n"); //提示位序非有效位序
		return false;
	} //检查位序参数Loc是否在有效位序范围1~length+1之间
	
	for (int count = 1; count <= Loc - 1; count++) {
		move = move->next;
	} //移动到相应的位序处进行操作
	
	insert = (LinkList)malloc(sizeof(LNode)); 
	//为新插入的结点分配内存空间

	if (!insert) {
		printf("Allocation Failure!\n"); //输出提示分配错误
		exit(EXIT_FAILURE);
	} //若存放新插入的结点的存储空间分配失败，则退出程序
	
	insert->Data = value; //为新结点的数据域赋值
	insert->next = move->next; //新结点指针域指向原先的第Loc个结点
	move->next = insert; //第Loc-1个结点指针域指向新结点
	return true;
} 
//结点插入操作

④删除操作

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

typedef struct LNode {
	double Data; //数据域
	struct LNode* next; //指针域
}LNode, *LinkList;
//定义单链表的结点

bool ListDelete(LinkList head, int Loc, double* deleted) {
	LinkList mover = head, reduce; //声明移动的指针，及指向被删除的结点的指针
	int length = ListLength(head); //声明并计算操作对象链表的长度
	if (Loc<1 || Loc>length) {
		printf("Input valid location!\n"); //提示位序非有效位序
		return false;
	} //检查位序参数Loc是否在有效位序范围1~length之间

	for (int count = 1; count <= Loc-1; count++) {
		mover = mover->next;
	} //移动到相应的位序处进行操作
	
	reduce = mover->next; //将指向即将被删除的结点的指针赋给指针变量reduce
	mover->next = reduce->next; //指针移动，指向后一个结点
	*deleted = reduce->Data; //将被删除的结点的数据域的值返回给*deleted
	free(reduce); //释放被删除的结点所占内存空间
	return true;
} 
//结点删除操作

⑤按位查找操作

#include<stdio.h>
#include<stdbool.h>

typedef struct LNode {
	double Data; //数据域
	struct LNode* next; //指针域
}LNode, *LinkList;
//定义单链表的结点

bool GetElem(LinkList head, int Loc, double* Elem) {
	LinkList mover = head; //声明移动的指针
	int length = ListLength(head); //声明并计算操作对象链表的长度
	if (Loc<1 || Loc>length) {
		printf("Input valid location!\n"); //提示位序非有效位序
		return false;
	} //检查位序参数Loc是否在有效位序范围1~length之间

	for (int count = 1; count <= Loc; count++) {
		mover = mover->next;
	} //移动到相应的位序处进行操作

	*Elem = mover->Data; //将第Loc个结点数据域的值赋给*Elem
	return true;
}
//按位查找操作

⑥按值查找操作

#include<stdio.h>
#include<stdbool.h>

typedef struct LNode {
	double Data; //数据域
	struct LNode* next; //指针域
}LNode, *LinkList;
//定义单链表的结点

bool LocateElem(LinkList head, double value, int* result) {
	LinkList mover = head; //声明移动的指针
	int Counter = 0; 
	//计数器初值为0，搜索目标值的过程中，指针mover每往前移动一步，计数器Counter便加1，直到寻找到目标值

	*result = Counter; //结果值*result首先被赋值为初始无效位序0
	
	while (mover->next) {
		mover = mover->next; //若指针域不为空，则指针mover向下一个结点移动
		Counter++; //指针mover每往前移动一步，计数器加1
		if (mover->Data == value) {
			*result = Counter; //查找成功，将目标值第一次出现的位序返回给*result
			return true;
		}
	} //查找操作

	printf("Selection Failure!\n"); //查找失败，屏幕输出失败提示
	return false;
}
//按值查找操作，得到目标值第一次出现时的位序

⑦输出操作

#include<stdio.h>
#include<stdbool.h>

typedef struct LNode {
	double Data; //数据域
	struct LNode* next; //指针域
}LNode, *LinkList;
//定义单链表的结点

void PrintList(LinkList head) {
	LinkList mover = head->next;
	//声明在计算表长过程中往前移动的指针

	while (mover) {
		printf("%.3lf", mover->Data); //指针mover不为空则输出其指向的结点的数据域中存储的值
		if (mover->next) {
			printf(",  "); //格式设定，除最后一个元素外每一个元素输出后都要在后面打个逗号
		}
		mover = mover->next; //向下一个结点的指针域移动
	} //按顺序输出链表各元素
}
//屏幕输出线性表

⑧判空操作
算法非常简单，头结点指针域中存储的指针指向NULL则为空表，反之则不是。

#include<stdbool.h>

typedef struct LNode {
	double Data; //数据域
	struct LNode* next; //指针域
}LNode, *LinkList;
//定义单链表的结点

bool Empty(LinkList head) {
	if (!head->next) {
		return true;
	} //是空表则返回true

	return false; //非空表则返回false
}
//判空操作，若为空表则返回true，反之则返回false

⑨销毁操作

#include<stdlib.h>

typedef struct LNode {
	double Data; //数据域
	struct LNode* next; //指针域
}LNode, *LinkList;
//定义单链表的结点

void DestroyList(LinkList head) {
	LinkList mover = head, destroy = head; 
	//声明用于移动的指针mover，及用于销毁的指针destroy

	while (mover) {
		destroy = mover; //将前一个结点交付给destroy
		mover = mover->next; //指针向后移动
		free(destroy); //前一个结点被销毁
	}
} 
//销毁操作，将链表在内存中所占用的存储空间全部释放

四 自选操作游戏

将上述函数略作改进（增加了对未定义头结点的非法情形的处理），最终可由用户操作的程序如下。

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

typedef struct LNode {
	double Data; //数据域
	struct LNode* next; //指针域
}LNode, *LinkList;
//定义单链表的结点

void InitList(LinkList* list); //初始化链表
int ListLength(LinkList head); //求链表的表长

bool ListInsert(LinkList head, double value, int Loc); 
//结点插入操作

bool ListDelete(LinkList head, int Loc, double* deleted); 
//结点删除操作

bool GetElem(LinkList head, int Loc, double* Elem); 
//按位查找操作

bool LocateElem(LinkList head, double value, int* result);
//按值查找操作，得到目标值第一次出现时的位序

bool PrintList(LinkList head); //屏幕输出线性表

bool Empty(LinkList head); //判空操作，若为空表则返回true，反之则返回false

void DestroyList(LinkList* list); //销毁操作，将链表在内存中所占用的存储空间全部释放

void ClearBuffer(void); //清除缓冲区操作








int main(void) {

	LinkList Head = NULL; //声明头指针
	char ch; //用于识别对线性表的操作类型的字符变量
	int loc, selectResult; //用于传参的位序，及按值查找操作所返回的位序

	double element, elementDeleted, elementDetected;
	//用于传参的元素值，删除操作返回的元素值，及按位查找操作所返回的元素值

	printf("There are 8 operations for the list:\n"
		"s: InitList\n"
		"i: ListInsert\n"
		"d: ListDelete\n"
		"l: GetElem\n"
		"v: LocateElem\n"
		"p: PrintList\n"
		"e: Empty\n"
		"h: DestroyList\n"
		"Please input the codes to choose different operations.\n");
	//操作指南

	while (1) {
		printf("Input an operation code: ");
		ch = getchar(); //输入操作所对应的字符

		if (ch == 's') {
			getchar(); //吞掉换行符
			InitList(&Head);
			printf("The sequence list has been successfully initialized.\n");
			//输出提示初始化成功
		}
		//初始化线性表

		else if (ch == 'i') {
			getchar(); //吞掉换行符
			printf("Input the inserted element: ");
			while (scanf("%lf", &element) != 1) {
				printf("Input valid data!\n");
				ClearBuffer(); //吞掉非法输入字符，清除stdin输入缓冲区
			} //排除非法输入
			printf("Input the location: ");
			while (scanf("%d", &loc) != 1) {
				printf("Input valid data!\n");
				ClearBuffer(); //吞掉非法输入字符，清除stdin输入缓冲区
			} //排除非法输入
			getchar(); //吞掉换行符
			if (ListInsert(Head, element, loc)) {
				PrintList(Head);
			}
		}
		//插入操作

		else if (ch == 'd') {
			getchar(); //吞掉换行符
			printf("Input the location of the deleted element: ");
			while (scanf("%d", &loc) != 1) {
				printf("Input valid data!\n");
				ClearBuffer(); //吞掉非法输入字符，清除stdin输入缓冲区
			} //排除非法输入
			getchar(); //吞掉换行符
			if (ListDelete(Head, loc, &elementDeleted)) {
				printf("%.3lf, the No.%d element of the list, has been deleted.\n", elementDeleted, loc);
				PrintList(Head);
			}
		}
		//删除操作

		else if (ch == 'l') {
			getchar(); //吞掉换行符
			printf("Input the location which will be detected: ");
			while (scanf("%d", &loc) != 1) {
				printf("Input valid data!\n");
				ClearBuffer(); //吞掉非法输入字符，清除stdin输入缓冲区
			} //排除非法输入
			getchar(); //吞掉换行符
			if (GetElem(Head, loc, &elementDetected)) {
				printf("The element detected on the location %d is %.3lf!\n", loc, elementDetected);
			}
		}
		//按位查找

		else if (ch == 'v') {
			getchar(); //吞掉换行符
			printf("Input the value which will be selected: ");
			while (scanf("%lf", &element) != 1) {
				printf("Input valid data!\n");
				ClearBuffer(); //吞掉非法输入字符，清除stdin输入缓冲区
			} //排除非法输入
			getchar(); //吞掉换行符
			if (LocateElem(Head, element, &selectResult)) {
				printf("The element %.3lf firstly appeared on the location %d!\n", element, selectResult);
			}
		}
		//按值查找

		else if (ch == 'p') {
			getchar(); //吞掉换行符
			PrintList(Head);
		}
		//输出线性表

		else if (ch == 'e') {
			getchar(); //吞掉换行符
			if (Empty(Head)) {
				printf("The list is null!\n");
			}
			else {
				printf("The list is not null.\n");
			}
		}
		//线性表判空

		else if (ch == 'h') {
			getchar(); //吞掉换行符
			DestroyList(&Head);
			printf("The list has been destroyed!\n");
		}
		//销毁线性表

		else if (ch == '\n') {
		}
		//若从输入缓冲区读取到'\n'，则什么也不执行

		else {
			printf("Input valid code!\n");
			ClearBuffer(); //清除stdin输入缓冲区
		}
		//排除非法输入的字符

		printf("\n");
		//为了在格式上区分每一步操作，每一步循环的末尾都要换行
	}

	return 0;
}








void InitList(LinkList* list) {
	if (*list) {
		free(*list);
		printf("The last list has been destroyed!\n");
	} //若原表还未被销毁，则先将原表销毁，以防内存泄漏

	*list = (LinkList)malloc(sizeof(LNode)); 
	//动态分配头结点，并将指向头结点的指针的值赋给头指针
	
	if (!*list) {
		printf("Allocation Failure!\n"); //输出提示分配错误
		exit(EXIT_FAILURE);
	} //若存放头结点的存储空间分配失败，则退出程序

	(*list)->next = NULL; //头结点指针域置空
} 
//初始化链表

int ListLength(LinkList head) {
	LinkList mover = head; 
	//声明在计算表长过程中往前移动的指针
	
	int Counter = 0;
	//表长的计数器，初始值置为0

	if (!mover) {
		printf("Head is NULL!\n");
		return Counter;
	} //头指针为空的处理，此时默认表的长度为0
	
	while (mover->next) {
		mover = mover->next; //向下一个结点的指针域移动
		Counter++; //表长计数器加1
	} //表长计数
	return Counter;
}
//求链表的表长

bool ListInsert(LinkList head, double value, int Loc) {
	LinkList mover = head, insert; 
	//用于在寻找相应位序的结点时移动的指针，及接收新插入的结点的指针

	if (!mover) {
		printf("Head is NULL!\n");
		return false;
	} //头指针为空的处理
	
	int length = ListLength(head); 
	//声明并计算操作对象链表的长度
	
	if (Loc<1 || Loc>length + 1) {
		printf("Input valid location!\n"); //提示位序非有效位序
		return false;
	} //检查位序参数Loc是否在有效位序范围1~length+1之间
	
	for (int count = 1; count <= Loc - 1; count++) {
		mover = mover->next;
	} //移动到相应的位序处进行操作
	
	insert = (LinkList)malloc(sizeof(LNode)); 
	//为新插入的结点分配内存空间

	if (!insert) {
		printf("Allocation Failure!\n"); //输出提示分配错误
		exit(EXIT_FAILURE);
	} //若存放新插入的结点的存储空间分配失败，则退出程序
	
	insert->Data = value; //为新结点的数据域赋值
	insert->next = mover->next; //新结点指针域指向原先的第Loc个结点
	mover->next = insert; //第Loc-1个结点指针域指向新结点
	return true;
} 
//结点插入操作

bool ListDelete(LinkList head, int Loc, double* deleted) {
	LinkList mover = head, reduce; //声明移动的指针，及指向被删除的结点的指针
	if (!mover) {
		printf("Head is NULL!\n");
		return false;
	} //头指针为空的处理

	int length = ListLength(head); //声明并计算操作对象链表的长度
	if (Loc<1 || Loc>length) {
		printf("Input valid location!\n"); //提示位序非有效位序
		return false;
	} //检查位序参数Loc是否在有效位序范围1~length之间

	for (int count = 1; count <= Loc-1; count++) {
		mover = mover->next;
	} //移动到相应的位序处进行操作

	reduce = mover->next; //将指向即将被删除的结点的指针赋给指针变量reduce
	mover->next = reduce->next; //指针移动，指向后一个结点
	*deleted = reduce->Data; //将被删除的结点的数据域的值返回给*deleted
	free(reduce); //释放被删除的结点所占内存空间
	return true;
} 
//结点删除操作

bool GetElem(LinkList head, int Loc, double* Elem) {
	LinkList mover = head; //声明移动的指针
	if (!mover) {
		printf("Head is NULL!\n");
		return false;
	} //头指针为空的处理

	int length = ListLength(head); //声明并计算操作对象链表的长度
	if (Loc<1 || Loc>length) {
		printf("Input valid location!\n"); //提示位序非有效位序
		return false;
	} //检查位序参数Loc是否在有效位序范围1~length之间

	for (int count = 1; count <= Loc; count++) {
		mover = mover->next;
	} //移动到相应的位序处进行操作

	*Elem = mover->Data; //将第Loc个结点数据域的值赋给*Elem
	return true;
}
//按位查找操作

bool LocateElem(LinkList head, double value, int* result) {
	LinkList mover = head; //声明移动的指针

	if (!mover) {
		printf("Head is NULL!\n");
		return false;
	} //头指针为空的处理

	int Counter = 0; 
	//计数器初值为0，搜索目标值的过程中，指针mover每往前移动一步，计数器Counter便加1，直到寻找到目标值

	*result = Counter; //结果值*result首先被赋值为初始无效位序0
	
	while (mover->next) {
		mover = mover->next; //若指针域不为空，则指针mover向下一个结点移动
		Counter++; //指针mover每往前移动一步，计数器加1
		if (mover->Data == value) {
			*result = Counter; //查找成功，将目标值第一次出现的位序返回给*result
			return true;
		}
	} //查找操作

	printf("Selection Failure!\n"); //查找失败，屏幕输出失败提示
	return false;
}
//按值查找操作，得到目标值第一次出现时的位序

bool PrintList(LinkList head) {
	if (!head) {
		printf("Head is NULL!\n");
		return false;
	} //头指针为空的处理

	LinkList mover = head->next;
	//声明在计算表长过程中往前移动的指针

	while (mover) {
		printf("%.3lf", mover->Data); //指针mover不为空则输出其指向的结点的数据域中存储的值
		if (mover->next) {
			printf(",  "); //格式设定，除最后一个元素外每一个元素输出后都要在后面打个逗号
		}
		mover = mover->next; //向下一个结点的指针域移动
	} //按顺序输出链表各元素
	
	return true;
}
//屏幕输出线性表

bool Empty(LinkList head) {
	if (!head) {
		return true;
	}
	else if (!head->next) {
		return true;
	} //是空表则返回true（只有头结点，或连头指针都为空）

	return false; //非空表则返回false
}
//判空操作，若为空表则返回true，反之则返回false

void DestroyList(LinkList* list) {
	LinkList mover = *list, destroy = *list;
	//声明用于移动的指针mover，及用于销毁的指针destroy

	while (mover) {
		destroy = mover; //将前一个结点交付给destroy
		mover = mover->next; //指针向后移动
		free(destroy); //前一个结点被销毁
	}

	*list = NULL; //注意将头指针置零，否则头指针将成为野指针
} 
//销毁操作，将链表在内存中所占用的存储空间全部释放

void ClearBuffer(void) {
	char ch;
	while ((ch = getchar())!='\n' && ch!=EOF) {
	}
} //清除缓冲区操作
子弦菌
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言丨线性表（二）：线性链表（单链表）
weixin_60921752的博客
12-26 3756
本文在介绍线性表的基本概念的基础上，重点介绍线性链表（单链表）及相应的算法。
线性表---单链表（头结点与头指针）
爱橙子的OK绷的专栏
10-18 1769
当链表的每个结点只包含一个指针域时，我们称此链表为单链表。关于单链表的存取，有时候我们在单链表的第一个结点（有效元素）之前附设一个结点，称之为头结点；指向头结点的指针，称之为头指针；对单链表的存取必须从头指针开始进行，由于单链表的最后一个数据元素没有直接后继，则指针为NULL。 对于头结点，数据域可以不存储任何信息，也可存储如链表长度等附加信息。下面是带头结点的单链表与空表的比较图。 头指针与头
【数据结构】线性表--list（详解建议收藏）
最新发布
DreamSun的博客
03-24 1751
零个或多个数据元素的有限序列。线性表的数据集合为{a1,a2,…,an}，假设每个元素的类型均为DataType。其中，除第一个元素a1外，每一个元素有且只有一个直接前驱元素，除了最后一个元素an外，每一个元素有且只有一个直接后继元素。数据元素之间的关系是一对一的关系。在较复杂的线性表中，一个数据元素可以由若干个数据项组成。在这种情况下，常把数据元素称为记录，含有大量记录的线性表又称为文件顺序表可以顺序存取,也可以随机存取,链表只能从表头顺序存取元素。
数据结构--List(线性表)
weixin_47230102的博客
04-05 864
数据结构--List（线性表）认识线性表(List) 认识线性表(List) 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑(代码概念上)上是线性结构，也就说是连续的一条直线。 在物理结构(内存的布局)上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 顺序表: 元素与元素之间是一个 “线性” 的关系 注意： 顺序表中一定要区分两个概念 容量(capa
PTA 6-4 查找元素(*)
wcd278212784的博客
03-31 2046
6-4 查找元素(*)添加链接描述 已知顺序表的结构定义如下： typedef struct { int size, length; int *element; } ALIST; 说明：element 为存储数据元素的动态数组的起始地址，size 为动态数组的尺寸，length 为顺序表的长度。 请编写函数，在顺序表中查找数据元素。 函数原型 int AListFind(const ALIST *list, int element); 说明：参数 list 为指示线性表(顺序表)的指针，element 为待
数据结构与算法之线性表基础——单链表（C与C++双人打） 定义线性表节点的结构.pdf
04-18
"数据结构与算法之线性表基础——单链表（C与C++双人打）定义线性表节点的结构.pdf" 数据结构与算法之线性表基础——单链表（C与C++双人打）定义线性表节点的结构是数据结构与算法的重要基础。单链表是一种链式存储...
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
代码包含顺序表和单链表的基本操作（增删改查等，详见注释），并展示了两个具体使用例子，包括对基本操作的验证和合并两个有序线性表为一个有序表。代码均已通过Dev-C++5.4.0，为了防止误修改，文档已限制编辑，密码...
数据结构——单链表（C语言版）.zip
11-02
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储...
数据结构---线性表之单链表（C语言）
03-28
单链表是数据结构中的一种基础类型，尤其在C语言编程中经常被使用。它是一种线性的、非连续的数据组织形式，每个元素称为节点，每个节点包含数据和一个指向下一个节点的指针。本篇文章将深入探讨单链表的创建、插入...
数据结构——线性表
02-06
另外还实现了简单单链表、简单顺序线性表、从A链表中删除B和C链表共有的元素、单链表逆置（以整数为例）、将链表中元素按递增排序并删除所选定范围内的元素、求一个新的集合A为A和B的交集（采用单链表作为存储结构）...
PTA单链表 - 20. 单值化(去重)
Celia_ahhh的博客
10-19 1211
所指线性表进行单值化处理：每个数据元素只保留第 1 个，后面与之重复的数据元素都被删去。请编写函数，对线性表进行单值化处理：删除表中重复的数据元素。是指示线性表(单链表)的指针，函数将对。修改主函数，对以上函数进行测试。
PTA 6-2 单链表逆置(*) (10分)
qq_40468936的博客
10-11 6153
6-2 单链表逆置(*) (10分) 已知单链表结点结构定义如下： typedef struct _NODE_ { int data; struct _NODE_ *next; } NODE; 说明：data 为数据域，next 为指针域。 单链表的结构定义如下： typedef struct { int length; NODE *head; } LLIST; 说明：length 为单链表的长度，head 为头指针。 请编写函数，将带头结点的单链表逆置。 函数原型 vo
数据结构（C语言）——第二章、线性表（1）顺序表
m0_43416592的博客
08-22 139
目录一、顺序表（静态分配）二、顺序表（动态分配） 一、顺序表（静态分配） #include<stdio.h> #include <stdlib.h> //静态分配 #define Maxsize 10 typedef struct { int data[Maxsize]; int length; }SqList; //基本操作 //1.初始化一个顺序表---静态表 void InitList(SqList &L); //2.插入操作---在第i个位
2.线性表—顺序表
weixin_37656263的博客
06-21 356
引言（重点）： 1.线性表的概述 2.线性表的抽象数据类型描述 3.线性表的实现方式 4.线性表的具体实现 5.每种具体实现的分析 1、什么是线性表？ 线性表（Linear List）：由同类型元素构成有序序列的线性结构。 特征： 1.表中元素个数称为线性表的长度 2.线性表没有元素时，称为空表 3.表起始位置称表头，表结束位置称为表尾 4.在一个元素的前面的元
【数据结构基础笔记】第二章线性表之单链表
水亦心的博客
01-04 3423
目录 一、简要 1、涵盖内容 2、学习要求 二、导入 三、线性链表 1、链式存储结构 2、注意点 四、单链表 1、单链表优点 2、单链表缺点 3、结点类型描述 4、注意点 五、单链表的实现 1、链表的创立 2、链表的操作 3、代码应用 一、简要 好久没有写基础笔记了，当时为了写基础笔记是为了能重新巩固数据结构，后来因为考研，就改成了数据结构周周练，但是很多同学看...
线性表-第2章-《数据结构习题集》答案解析-严蔚敏吴伟民版
热门推荐
StrayedKing-245176013
12-26 8万+
严蔚敏吴伟民版《数据结构习题集》第2章线性表部分答案+习题解析。
List (单链表17个函数讲解)
染尘
05-10 5122
链表时一种常用的数据结构，是通过“链”来建立起数据元素之间的逻辑关系，这种用链接方式储存的线性表简称链表（Link List）。一，链表与顺序表的对比 在接触链表之前大家想必已经了解过了顺序表的储存结构方式，顺序表与链表的不同之处如下： 1.顺序表是物理位置上相邻来表示数据元素之间的逻辑关系；但链表不是，物理地址不相连，通过指针来链接。 2.顺序表储存密度高，且能够随机的存取数据(
数据结构编程笔记三：第二章 线性表 顺序表的实现
u014576141的博客
08-13 1514
这次主要是介绍线性顺序表的实现代码。程序在码云上可以下载。 地址：https://git.oschina.net/601345138/DataStructureCLanguage.git各种操作的原理不再赘述，如果还不清楚的，请看这个PPT，里面有一些动态演示： https://wenku.baidu.com/view/86874936657d27284b73f242336c1eb91a373
数据结构实验说明书2021.doc
09-30
数据结构实验说明书2021.doc

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值