数据结构笔记（三）-- 链式实现顺序表

最新推荐文章于 2023-05-26 03:45:00 发布
最新推荐文章于 2023-05-26 03:45:00 发布
阅读量753 收藏 8
点赞数
文章标签： 数据结构 指针 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_43609475/article/details/106313723
版权

带有头结点的单链表的实现

一、链表概述

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
在这里插入图片描述
在这里插入图片描述

二、线性表的单链表存储数据

以存储数据为整型为例

typedef int ElemType; /* 定义抽象数据类型ElemType为整型 */

三、线性表的单链表存储结构

线性表的单链表存储结构图示
在这里插入图片描述
代码示

//线性表的单链表存储结构
typedef struct Node
{
	ElemType data;		 //代表数据域
	struct Node * next; //代表指针域，指向直接后继元素;定义指向Node类型的指针
}Node, *pNode;

四、线性表的单链表操作定义13个

//1、创建头结点返回头指针
pNode InitList();
//2、判断链表是否为空
bool ListEmpty(pNode L);
//3、向链表中追加元素
bool ListAddElem(pNode L, ElemType e);
//4、向链表pos位置前插入元素
bool ListInsert(pNode L, int pos, ElemType e);
//5、遍历链表
void ListTraverse(pNode L);
//6、删除指定位置的元素
bool ListDelete(pNode L, int i, ElemType &e);
//7、获取链表的长度
int ListLength(pNode L);
//8、获取第i个结点的值
bool GetElem(pNode L, int i, ElemType &e);
//9、若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱
bool PriorElem(pNode L, ElemType cur_e, ElemType &pre_e);
//10、若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继
bool NextElem(pNode L, ElemType cur_e, ElemType &next_e);
//11、查询满足相应条件的结点元素，并返回序位
int LocateElem(pNode L, ElemType e, bool(*compare)(ElemType, ElemType));
//11.1比较俩个元素是否相等
bool compare(ElemType e1, ElemType e2);
//12、将链表清空
void ClearList(pNode L); // 不改变L
//13、销毁链表
void DestroyList(pNode &L);

1、创建头结点返回头指针

在这里插入图片描述

pNode InitList()
{
	pNode pHead = (pNode)malloc(sizeof(Node));//申请一个结点空间作为头结点，头指针指向头结点
	if (!pHead) //pHead为空 存储分配失败
		exit(-1);
	//pHead->data 因为是头结点所以头结点的数据域可以不用管，是一个垃圾直值
	pHead->next = NULL; // 头结点指针域初始化为空
	return pHead;
}

2、判断链表是否为空

当头指针的指针域为空时，链表为空
在这里插入图片描述

bool ListEmpty(pNode L)
{ // 初始条件：线性表L已存在。
  //操作结果：若L为空表，则返回true，否则返回false
	if (L->next) // 非空
		return false;
	else
		return true;
}

3、向链表中追加元素

在这里插入图片描述

bool ListAddElem(pNode L, ElemType e)
{
// 初始条件：线性表L已存在。
  //操作结果：在链表最后一个结点后追加一个结点
	pNode pEnd = L, pNew, pProEnd = NULL;

	while (pEnd != NULL)//让pProEnd指向链表的尾结点
	{
		pProEnd = pEnd;//保存倒数第二个结点的next值，这个值指向尾结点
		pEnd = pEnd->next;
	}
	pNew = (pNode)malloc(sizeof(Node));//生成新节点
	if (pNew == NULL)//为空则节点分配失败，程序终止
	{
		printf("分配失败，程序终止！\n");
		exit(-1);
	}
	pNew->data = e;          //新结点值域赋值
	pNew->next = NULL;       //新结点指针域赋值，由于是尾结点所以赋值为空
	pProEnd->next = pNew;	 //新结点挂载到尾结点
	return true;
}

4、向链表插入结点元素

插入结点图示 pos = 2
在这里插入图片描述

bool ListInsert(pNode L, int pos, ElemType e)
{   // 初始条件：线性表L已存在。
	// 在带头结点的单链线性表L中第pos个位置之前插入元素e
	int i = 0;
	pNode p = L;


	while (p != NULL && i < pos - 1)//用p指向第pos-1个结点，将指针移动到插入元素位置之前。pos<=1，则不执行while
	{
		p = p->next;  //p指向头结点，此语句执行第一次后p指向首结点，第二次p指向第二个结点....
		i++;          //计数直到pos-1位置处的结点
	}

	if (p == NULL || i > pos - 1) //如果p指向的结点为空则p指向了尾结点或者链表没有元素 pos小于1或者大于表长
		return false;
	pNode Pnew = (pNode)malloc(sizeof(Node)); // 生成新结点
	Pnew->data = e; //  将值赋给要插入的结点
	Pnew->next = p->next;//新结点指针域指向下一个结点
	p->next = Pnew;//第pos-1个结点指向新节点
	return true;
}

5、遍历链表

在这里插入图片描述

void ListTraverse(pNode L)
{// 初始条件：线性表L已存在。
//操作结果：依次对L的每个结点值进行输出
	if (L == NULL)
	{ 
		printf("链表不存在\n");
		exit(-1);
	}
	pNode p = L->next;
	while (p != NULL)
	{
		printf("%d  ", p->data);
		p = p->next;
	}
	printf("\n");
}

6、删除指定位置的元素

在这里插入图片描述

bool ListDelete(pNode L, int i, ElemType &e) // 不改变L
{ // 初始条件：线性表L已存在。
  //操作结果：在带头结点的单链线性表L中，删除第i个元素，并由e返回其值
	int j = 0;
	pNode p = L, q;
	while (p != NULL && j < i - 1) // 链表不为空，用p指向第i-1个结点
	{
		p = p->next;
		j++;
	}

	if (p == NULL || j > i - 1) // p初始指针指向为空或者i为链表长度+1 删除位置不合理
		return false;

	q = p->next; //保存要删除结点指针
	p->next = q->next;//要删除结点的指针域的值赋值给要删除结点前的结点的指针域
	e = q->data;//保存要删除结点的值

	free(q);//释放删除结点的占用的内存空间
	return true;
}

7、获取链表的长度

在这里插入图片描述

int ListLength(pNode L)
{ // 初始条件：线性表L已存在。操作结果：返回L中数据元素个数
	int i = 0;
	pNode p = L->next; // p指向第一个结点
	while (p != NULL) // 没到表尾
	{
		i++;
		p = p->next;
	}
	return i;
}

8、获取第i个结点的值

bool GetElem(pNode L, int i, ElemType &e) 
{ // L为带头结点的单链表的头指针。当第i个元素存在时，其值赋给e并返回true，否则返回false
	int j = 1; // j为计数器
	pNode p = L->next; // p指向第一个结点
	while (p != NULL && j < i) // 顺指针向后查找，直到p指向第i个元素或p为空
	{
		p = p->next;
		j++;
	}
	if (p == NULL || j > i) // 第i个元素不存在
		return false;
	e = p->data; // 取第i个元素
	return true;
}

9、若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱

找到第一个结点值为cur_e的结点，返回其前一个节点值

bool PriorElem(pNode L, ElemType cur_e, ElemType &pre_e)
{
	// 初始条件: 线性表L已存在
   // 操作结果: 若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，
   //           返回true；否则操作失败，pre_e无定义，返回false
	pNode q = NULL, p = L->next;// p指向第一个结点
	if (p->data == cur_e)
	{
		printf("第一个结点没有前驱\n");
		return false;
	}
	while (p != NULL)
	{
		q = p;//q用来保存p的前驱
		p = p->next;
		
		if (p != NULL && p->data == cur_e)//找到与cur_e相等的结点,当p ==NULL时 p是最后一个结点的指针域的值。则p->data是非法的
			break;//终止循环
	}
	if (p == NULL)//防止链表为空
	{ 
		return false;
	}
	pre_e = q->data;//保存前驱结点值
	return true;
}

10、若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继

bool NextElem(pNode L, ElemType cur_e, ElemType &next_e)
{ // 初始条件：线性表L已存在
  // 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，
  //           返回true;否则操作失败，next_e无定义，返回false

	pNode p = L, q = L;
	if (q == NULL)
		return false;
	int i = 0;
	while (p != NULL && i<ListLength(L))//将指针指向最后一个结点
	{
		p = p->next;
		i++;
	}
	while (q != NULL && q != p) // p所指结点有后继,即q最多只会指向最后一个结点之前的结点
	{
		
		if (q->data == cur_e)
		{
			next_e = q->next->data;//保存后驱结点值
			return true;
		}
		q = q->next;
	}
	return false;
}

11、查询满足相应条件的结点元素，并返回序位

int LocateElem(pNode L, ElemType e, bool(*compare)(ElemType, ElemType))
{ // 初始条件: 线性表L已存在，compare()是数据元素判定函数(满足为ture，否则为false)
  // 操作结果: 返回L中第1个与e满足关系compare()的数据元素的位序。
  //           若这样的数据元素不存在，则返回值为0
	int i = 0;
	pNode p = L->next;//p指向首节点
	while (p)
	{
		i++;
		if (compare(p->data, e)) // 找到这样的数据元素
			return i;
		p = p->next;
	}
	return 0;
}

11.1比较俩个元素是否相等

bool compare(ElemType e1, ElemType e2)
{
	if (e1 == e2)
		return true;
	else
		return false;
}

12、将链表清空

在这里插入图片描述

void ClearList(pNode L) // 不改变L
{ // 初始条件：线性表L已存在。
  //操作结果：将L重置为空表,从第首节点开始释放
	pNode p = NULL, q = NULL;
	p = L->next;//p指向首节点
	while (p)
	{
		q = p->next;//q保存下一个结点的地址
		free(p);//释放当前结点内存
		p = q;//将下一节点的地址给p，保证循环
	}
	L->next = NULL; //头结点指针域重置为空
}

13、销毁链表

在这里插入图片描述

void DestroyList(pNode &L)
{ // 初始条件：线性表L已存在。
  //操作结果：销毁线性表L，从头结点开始释放(free(L)释放L指向的内存地址)
	pNode q;
	while (L)
	{
		q = L->next;
		free(L);
		L = q;
	}
}

最后给出完整代码

/*带有头结点的单链表*/
# include<stdio.h>
# include<stdlib.h>
# include<malloc.h>

typedef int ElemType; /* 定义抽象数据类型ElemType为整型 */

//线性表的单链表存储结构
typedef struct Node
{
	ElemType data;		 //代表数据域
	struct Node * next; //代表指针域，指向直接后继元素;定义指向Node类型的指针
}Node, *pNode;

//1、创建头结点返回头指针
pNode InitList();
//2、判断链表是否为空
bool ListEmpty(pNode L);
//3、向链表中追加元素
bool ListAddElem(pNode L, ElemType e);
//4、向链表pos位置前插入元素
bool ListInsert(pNode L, int pos, ElemType e);
//5、遍历链表
void ListTraverse(pNode L);
//6、删除指定位置的元素
bool ListDelete(pNode L, int i, ElemType &e);
//7、获取链表的长度
int ListLength(pNode L);
//8、获取第i个结点的值
bool GetElem(pNode L, int i, ElemType &e);
//9、若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱
bool PriorElem(pNode L, ElemType cur_e, ElemType &pre_e);
//10、若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继
bool NextElem(pNode L, ElemType cur_e, ElemType &next_e);
//11、查询满足相应条件的结点元素，并返回序位
int LocateElem(pNode L, ElemType e, bool(*compare)(ElemType, ElemType));
//11.1比较俩个元素是否相等
bool compare(ElemType e1, ElemType e2);
//12、将链表清空
void ClearList(pNode L); // 不改变L
//13、销毁链表
void DestroyList(pNode &L);

int main(void)
{

	pNode L = NULL;	//创建头指针L,空指向
	L = InitList();//创建一个链表头结点，L指向头结点
	if (ListEmpty(L))
		printf("链表为空\n");
	else
		printf("链表不为空\n");


	if (ListAddElem(L, 22))
		printf("追加成功\n");
	int i = 0;
	while (i < 5)
	{
		ListAddElem(L, 2 * i);
		i++;
	}
	ListTraverse(L);
	ListInsert(L, 1, 100);
	ListTraverse(L);
	ElemType e = 0;
	ListDelete(L, 5, e);
	ListTraverse(L);
	printf("删除的元素是  %d\n", e);
	printf("链表的长度为 %d\n", ListLength(L));
	if (GetElem(L, 5, e))
		printf("第5个结点值为 %d\n", e);
	else
		printf("获取第5个结点失败\n");

	ElemType pre_e, cur_e = 2, next_e;
	if (PriorElem(L, cur_e, pre_e))
		printf("第一个值 %d 的结点的前驱结点值为 %d \n", cur_e, pre_e);
	else
		printf("前驱获取失败\n");
	

	if (NextElem(L, cur_e, next_e))
		printf("第一个值 %d 的结点的后继结点值为 %d \n", cur_e, next_e);
	else
		printf("后继获取失败\n");

	printf("链表中与值%d 相等的值的序位为 %d\n", cur_e, LocateElem(L, cur_e, compare));

	ClearList(L);
	ListTraverse(L);
	DestroyList(L);
	ListTraverse(L);

	return 0;

}


//1、创建头结点返回头指针
pNode InitList()
{
	pNode pHead = (pNode)malloc(sizeof(Node));//申请一个结点空间作为头结点，头指针指向头结点
	if (!pHead) //pHead为空 存储分配失败
		exit(-1);
	//pHead->data 因为是头结点所以头结点的数据域可以不用管，是一个垃圾直值
	pHead->next = NULL; // 头结点指针域初始化为空
	return pHead;
}


//2、判断链表是否为空
//当头指针的指针域为空时，链表为空
bool ListEmpty(pNode L)
{ // 初始条件：线性表L已存在。
  //操作结果：若L为空表，则返回true，否则返回false
	if (L->next) // 非空
		return false;
	else
		return true;
}


// 3、向链表中追加元素
bool ListAddElem(pNode L, ElemType e)
{

	pNode pEnd = L, pNew, pProEnd = NULL;

	while (pEnd != NULL)//让pProEnd指向链表的尾结点
	{
		pProEnd = pEnd;//保存倒数第二个结点的next值，这个值指向尾结点
		pEnd = pEnd->next;
	}


	pNew = (pNode)malloc(sizeof(Node));//生成新节点
	if (pNew == NULL)//为空则节点分配失败，程序终止
	{
		printf("分配失败，程序终止！\n");
		exit(-1);
	}

	pNew->data = e;          //新结点值域赋值
	pNew->next = NULL;       //新结点指针域赋值，由于是尾结点所以赋值为空
	pProEnd->next = pNew;	 //新结点挂载到尾结点
	return true;
}


//4、向链表插入元素
bool ListInsert(pNode L, int pos, ElemType e)
{
	// 在带头结点的单链线性表L中第pos个位置之前插入元素e
	int i = 0;
	pNode p = L;


	while (p != NULL && i < pos - 1)//用p指向第pos-1个结点，将指针移动到插入元素位置之前。pos<=1，则不执行while
	{
		p = p->next;  //p指向头结点，此语句执行第一次后p指向首结点，第二次p指向第二个结点....
		i++;          //计数直到pos-1位置处的结点
	}

	if (p == NULL || i > pos - 1) //如果p指向的结点为空则p指向了尾结点或者链表没有元素 pos小于1或者大于表长
		return false;
	pNode Pnew = (pNode)malloc(sizeof(Node)); // 生成新结点
	Pnew->data = e; //  将值赋给要插入的结点
	Pnew->next = p->next;//新结点指针域指向下一个结点
	p->next = Pnew;//第pos-1个结点指向新节点
	return true;
}

//5、遍历链表
void ListTraverse(pNode L)
{// 初始条件：线性表L已存在。
//操作结果：依次对L的每个结点值进行输出
	if (L == NULL)
	{ 
		printf("链表不存在\n");
		exit(-1);
	}
	pNode p = L->next;
	while (p != NULL)
	{
		printf("%d  ", p->data);
		p = p->next;
	}
	printf("\n");
}

//6、删除指定位置的元素
bool ListDelete(pNode L, int i, ElemType &e) // 不改变L
{ // 在带头结点的单链线性表L中，删除第i个元素，并由e返回其值
	int j = 0;
	pNode p = L, q;
	while (p != NULL && j < i - 1) // 链表不为空，用p指向第i-1个结点
	{
		p = p->next;
		j++;
	}

	if (p == NULL || j > i - 1) // p初始指针指向为空或者i为链表长度+1 删除位置不合理
		return false;

	q = p->next; //保存要删除结点指针
	p->next = q->next;//要删除结点的指针域的值赋值给要删除结点前的结点的指针域
	e = q->data;//保存要删除结点的值

	free(q);//释放删除结点的占用的内存空间
	return true;
}

//7、获取链表的长度
int ListLength(pNode L)
{ // 初始条件：线性表L已存在。操作结果：返回L中数据元素个数
	int i = 0;
	pNode p = L->next; // p指向第一个结点
	while (p != NULL) // 没到表尾
	{
		i++;
		p = p->next;
	}
	return i;
}

//8、获取第i个结点的值
bool GetElem(pNode L, int i, ElemType &e) // 算法2.8
{ // L为带头结点的单链表的头指针。当第i个元素存在时，其值赋给e并返回true，否则返回false
	int j = 1; // j为计数器
	pNode p = L->next; // p指向第一个结点
	while (p != NULL && j < i) // 顺指针向后查找，直到p指向第i个元素或p为空
	{
		p = p->next;
		j++;
	}
	if (p == NULL || j > i) // 第i个元素不存在
		return false;
	e = p->data; // 取第i个元素
	return true;
}

//9、若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱
bool PriorElem(pNode L, ElemType cur_e, ElemType &pre_e)
{
	// 初始条件: 线性表L已存在
   // 操作结果: 若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，
   //           返回true；否则操作失败，pre_e无定义，返回false
	pNode q = NULL, p = L->next;// p指向第一个结点
	if (p->data == cur_e)
	{
		printf("第一个结点没有前驱\n");
		return false;
	}
	while (p != NULL)
	{
		q = p;//q用来保存p的前驱
		p = p->next;
		
		if (p != NULL && p->data == cur_e)//找到与cur_e相等的结点,当p ==NULL时 p是最后一个结点的指针域的值。则p->data是非法的
			break;//终止循环
	}
	if (p == NULL)//防止链表为空
	{ 
		return false;
	}
	pre_e = q->data;//保存前驱结点值
	return true;
}
//10、若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继
bool NextElem(pNode L, ElemType cur_e, ElemType &next_e)
{ // 初始条件：线性表L已存在
  // 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，
  //           返回true;否则操作失败，next_e无定义，返回false

	pNode p = L, q = L;
	if (q == NULL)
		return false;
	int i = 0;
	while (p != NULL && i<ListLength(L))//将指针指向最后一个结点
	{
		p = p->next;
		i++;
	}
	while (q != NULL && q != p) // p所指结点有后继,即q最多只会指向最后一个结点之前的结点
	{
		
		if (q->data == cur_e)
		{
			next_e = q->next->data;//保存后驱结点值
			return true;
		}
		q = q->next;
	}
	return false;
}
//11.1比较俩个元素是否相等
bool compare(ElemType e1, ElemType e2)
{
	if (e1 == e2)
		return true;
	else
		return false;
}

//11、查询满足相应条件的结点元素，并返回序位
int LocateElem(pNode L, ElemType e, bool(*compare)(ElemType, ElemType))
{ // 初始条件: 线性表L已存在，compare()是数据元素判定函数(满足为ture，否则为false)
  // 操作结果: 返回L中第1个与e满足关系compare()的数据元素的位序。
  //           若这样的数据元素不存在，则返回值为0
	int i = 0;
	pNode p = L->next;//p指向首节点
	while (p)
	{
		i++;
		if (compare(p->data, e)) // 找到这样的数据元素
			return i;
		p = p->next;
	}
	return 0;
}


//12、将链表清空
void ClearList(pNode L) // 不改变L
{ // 初始条件：线性表L已存在。
  //操作结果：将L重置为空表,从第首节点开始释放
	pNode p = NULL, q = NULL;
	p = L->next;//p指向首节点
	while (p)
	{
		q = p->next;//q保存下一个结点的地址
		free(p);//释放当前结点内存
		p = q;//将下一节点的地址给p，保证循环
	}
	L->next = NULL; //头结点指针域重置为空
}

//13、销毁链表
void DestroyList(pNode &L)
{ // 初始条件：线性表L已存在。
  //操作结果：销毁线性表L，从头结点开始释放(free(L)释放L指向的内存地址)
	pNode q;
	while (L)
	{
		q = L->next;
		free(L);
		L = q;
	}
}
淡定的炮仗
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构——顺序表/单链表实现
Luria
08-20 634
一、顺序表 // 静态存储 typedef struct SeqList_1 { DataType array[N]; size_t size; }SeqList_1; //动态存储 typedef struct SeqList { DataType *base; size_t size; // 有效数据个数 size_t capacity; //容量大小 }SeqList; 部分接口实现 //初始化 void SeqListInit(SeqList* psl, size_t c.
用链表实现有序表
qq_43477550的博客
04-23 647
有序表就是表中的元素是按一定的逻辑顺序排列的，如按照数字大小排列，或字符的大小排列等等。 使用链表进行一个构造由小到大排列的有序表。当加入新的数据时，需要对当前表中的数据进行比较，找到第一个比自己大的值，然后再插入。当进行搜索时，只要当前值比要搜索值大，则无需进行后面部分的遍历，直接返回False。 class Node: def __init__(self,item): ...
顺序表--链表实现
qq_43710269的博客
03-24 526
链表 链表是一种在物理存储上无规则的存储结构，由指针将每个数据元素来串联起来。 链表可以从单向双向、带头不带头、循环非循环来进行分类，最常用的是无头单向非循环链表和带头双向链表。 无头单向链表：结构简单实现容易，但是一般不会用来存储数据，更多的是用来实现一些其他数据结构的子结构，如哈希桶、邻接表等。 ​ 带头双向循环链表：结构复杂，一般用来存储数据，其数据结构带来许多操作的优势。 单向链表结构定义： typedef int SLTypeData; typedef struct SListNode {
链式顺序表实现(C语言描述)
ShiXiAoLaNga的博客
10-12 300
链式顺序表实现(C语言描述)
链表实现队列
qq_35803412的博客
08-09 288
代码】链表实现顺序表。
考研复习知识笔记-数据结构
04-16
数据结构笔记-考研复习 数据结构是计算机科学中的一门重要学科，研究如何组织、存储和使用数据。下面是考研复习笔记中的一些重要知识点： 1. 数据结构定义：数据结构是指数据元素之间的逻辑关系、数据的运算和存储...
数据结构笔记-《考研王道笔记知识点整理》
05-23
《考研王道笔记知识点整理》中的内容涵盖了数据结构的基础概念、数据结构的三要素、算法的基本概念以及线性表的定义。 1. **数据结构的基本概念**： - 数据是描述客观事物属性的符号集合，数据元素是数据的基本...
数据结构笔记.docx
12-19
数据结构笔记 数据结构是计算机科学中的一门重要学科，涉及到数据的存储、表示和操作等方面。本笔记涵盖了数据结构的基本概念、线性表、栈和队列、树、图、排序和查找等重要知识点。 一、数据结构的基本概念 数据...
数据结构学习笔记.docx
11-26
本笔记将探讨几个关键的数据结构类型及其特性。 首先，我们关注算法的时间复杂度和空间复杂度。时间复杂度描述了算法执行时间与问题规模的关系，通常用大O符号表示，例如T(n) = O(f(n))，表示随着n的增加，算法运行...
数据结构顺序表的顺序和链式结构实验报告代码
04-24
简单易懂，大二学生编写的，作为指导自己操作的代码是十分好的~ 实验1为顺序结构 实验2为链式结构
顺序表：链表实现
ysg.name
09-10 423
顺序表：链表实现
C++数据结构：线性顺序表（链表）
最新发布
攻城狮的博客
05-26 2496
前一篇文章介绍用数组实现的顺序表时已经提到链表这种结构，在STL中的 list 就是以链表实现的顺序表。这种结构与数组相比最大好处就是可以很方便的在头部和中部插入数据，而数组比较麻烦，需要移动之后的所有数据。链表也可以实现顺序表的功能。链表是一种动态数据结构，它可以根据需要自动调整大小，存储不连续的元素。
线性表的链式实现——单链表
melodyzhan的博客
10-05 267
顺序表的链式实现无参构造判空遍历求单链表长度按位查找按值查找插入操作建立单链表头插法尾插法删除操作析构函数完整代码 template<typename DataType> class LinkList{ public: LinkList(); LinkList(DataType a[],int n); ~LinkList(); int Length(); DataType Get(int i); int Locate(DataType x); void Insert(int i,D
数据结构--顺序表与单链表的实现
xiaoyiyaonuli的博客
11-10 469
现在给大家介绍线性表中两个常见的结构顺序表和链表，其中链表又包括单链表和带头双向循环链表,都是用来存储数据的一种结构。
顺序表和链表的实现
gemgod的博客
08-08 301
顺序表和链表的实现
线性表 基于顺序表的链表实现
m0_51317663的博客
04-10 167
线性表 线性表的定义：由成为元素的数据项组成的一种有限且有序的序列。 这里的有序是指每一个元素都有自己的位置，而非元素按其值大小排序，当线性表不包含任何元素时，称为空表，元组的数目称为线性表的长度，开始节点称为表头，结尾节点称为表尾，表中的元素的值和它的位置可以有联系也可以无联系。 线性表c++的抽象类声明： template <typename E> class List { private: void operator =(const List&){}//赋值运算符重
C++实现顺序表（数组和链表）
weixin_40417029的博客
04-21 1694
    在C++中，引入了类的概念，要用类来实现顺序表，一定要注意代码的复用，这样会使实现更加容易。数组实现顺序表：        定义三个指针，_first指向数组开始位置，_finish指向最后一个元素的下一个位置，_endofstorage指向数组末尾的下一个位置。如图所示，假设数组中有元素1234567：构造函数：让三个指针指向空；typedef int DataType; class ...
数据结构:链表和顺序表的实现
weixin_51654781的博客
03-26 1015
线性表 ​ 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结 构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物 理上存储时，通常以数组和链式结构的形式存储。 文章目录顺序表静态顺序表(使用定长数组存储数组元素)动态顺序表(使用动态开辟存储数组元素)头文件源文件链表无头单向非循环链表头文件源代码带头双向循环链表头文件源代码总结链表和顺序表的对比 顺
数据结构1
08-03
- 广义表：用于表示复杂的数据结构，不同于简单的一维数组。 6. **树** - 树的定义：一种非线性数据结构，由节点和边组成，具有父节点和子节点的概念。 - 二叉树：每个节点最多有两个子节点的树。 - 操作：如...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值