03_线性表_链表

已于 2022-12-23 14:37:38 修改
阅读量222 收藏
点赞数 2
分类专栏： # 数据结构 文章标签： 链表 数据结构 c++
于 2022-06-19 12:10:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48083892/article/details/125356386
版权
本文深入探讨了链表的各种类型，包括单链表、循环链表、双向链表和静态链表。详细阐述了它们的初始化、插入、删除、查找等基本操作，并提供了C语言实现的示例代码。同时，分析了不同链表结构的优缺点，如静态链表在内存管理和效率上的优势。
摘要由CSDN通过智能技术生成

链表：适合插入

链表：逻辑相邻，物理不相邻

头节点:不用于存放数据，只起标记作用
单链表的尾节点next域为空

1 不带头节点的单链表

不带头节点的单链表： 实现时修改指针（ plist)的指向需要传该指针的地址，故需要使用二级指针
在这里插入图片描述

2 带头节点的单链表

带头节点的单链表： 实现时不带二级指针，相比不带头节点的单链表操作起来非常简单
在这里插入图片描述

在这里插入图片描述
优点：带头节点不用判空，因为头节点一直都在。
注意：头节点不用删除，因为用malloc申请的才需要 free
插入操作可分为2大类：
在这里插入图片描述
例如：对链表的结构不需要改变：输出操作，查找操作，获取长度…

在这里插入图片描述

在这里插入图片描述

//判断两条链表是否相交，若相交返回第一个相交节点
Node* intersect(List plist1, List plist2)
{
	if (plist1 == nullptr && plist2 == nullptr)return nullptr;
	int len1 = GetLength(plist1);
	int len2 = GetLength(plist2);

	Node* p = len1 > len2 ? plist1 : plist2;
	Node* q = len1 > len2 ? plist2 : plist1;

	for (int i = 0;i < abs(len1 - len2);i++)//abs ：求绝对值的函数
	{
		p = p->next;//长的向后跑|len1-len2|步
	}
	while (p != nullptr)
	{
		if (p == q)
		{
			return p;
		}
		p = p->next;
		q = q->next;
	}
	return nullptr;
}

#pragma once

typedef struct Node
{
	int data;//数据域
	struct Node* next;//后继指针
}Node, * List;//List==Node *,但是不能将Node *p写成List p;虽然二者本质一样，但是代表的意思不一样
			// Node *p:代表一个节点的指针
			// List p:代表一个链表

//初始化
void InitList(List plist);

//头插
bool Insert_head(List plist, int val);

//尾插
bool Insert_tail(List plist, int val);


//在plist链表的pos位置标插入数据val
bool Insert(List plist, int pos, int val);

//判空
bool IsEmpty(List plist);

//获取数据节点个数
int GetLength(List plist);

//在plist中查找第一个key,找到了返回地址，没有找到返回NULL
Node* Search(List plist, int key);

//删除pos位置的值
bool DelPos(List plist, int pos);

//删除一个节点
bool DelVal(List plist, Node* p);

//删除第一个val值
bool DelVal(List plist, int val);

//判断单链表是否存在环
Node* IsLoop(List plist);

//返回key的前驱地址，如果不存在返回NULL；
Node* GetPrio(List plist, int key);

//返回key的后继地址，如果不存在返回NULL；
Node* GetNext(List plist, int key);

//输出顺序表
void Show(List plist);

//清空数据
void Clear(List plist);

//销毁整个内存
void Destory(List plist);

#include<stdio.h>
#include"list.h"
#include<stdlib.h>
#include<assert.h>

//初始化
void InitList(List plist)
{
	assert(plist != NULL);
	if (plist == NULL)
		return;
	//ps->data;头节点的data域不使用
	plist->next = NULL;//因为初始化时头就是尾，所有单链表的尾节点next域为空
}

//头插
bool Insert_head(List plist, int val)
{
    //动态申请一个新节点
	Node* p = (Node*)malloc(sizeof(Node));
	assert(p != NULL);
	//将val放到新节点
	p->data = val;
	//插入新节点
	p->next = plist->next;
	plist->next = p;
	return true;
}

//尾插
bool Insert_tail(List plist, int val)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return false;//不能用exit(1)，因为直接退出了进程:工作中不允许使用
	}
	Node* p = (Node*)malloc(sizeof(Node));
	p->data = val;

	//找尾部
	Node* q;
	for (q = plist;q->next != NULL;q=q->next)
	{
		;
	}
	//插入新节点
	p->next = q->next;
	q->next = p;
	return true;
}

//在plist链表的pos位置标插入数据val
bool Insert(List plist, int pos, int val)
{
	if (pos<0 || pos>GetLength(plist))
	{
		return false;
	}
	Node* p = (Node*)malloc(sizeof(Node));
	p->data = val;
	//找位置
	Node* q;
	int i;
	for (q = plist, i = 0;i < pos;i++, q = q->next);
	//p插入在q的后面
	p->next = q->next;
	q->next = p;
	return true;
}

//判空
bool IsEmpty(List plist)
{
	return plist->next == NULL;
}

//获取数据节点个数
int GetLength(List plist)
{
	int count = 0;
	for (Node* p = plist->next;p != NULL;p->next)
	{
		count++;
	}
	return count;
}

//在plist中查找第一个key,找到了返回节点地址，没有找到返回NULL
Node* Search(List plist, int key)
{
   for(Node*p=plist->next;p!=NULL;p=p->next)
   {
	   if (p->data == key)
	   {
		   return p;
	   }
   }
   return NULL;
}

//删除pos位置的值
bool DelPos(List plist, int pos)
{
	if (pos<0 || pos>=GetLength(plist))
	{
		return false;
	}
	Node* p;
	int i;
	for (p = plist, i = 0;i < pos;i++, p= p->next);
    //删除p后面的节点
	Node* q = p->next;
	p->next = q->next;
	free(q);
	return true;

}

//删除第一个val值
bool DelVal(List plist, int val)
{
	Node* p = GetPrio(plist, val);
	if (p == NULL)
	{
		return false;
	}
	Node* q = p->next;//把将要删除的节点地址保存
	//将q从链表中剔除
	p->next = q->next;//p->next=p->next->next;
	//释放q的内存
	free(q);
	return true;
}

//删除一个节点时间复杂度为O（1）
bool DelVal(List plist, Node* p)
{
	if (plist == nullptr && p == nullptr)return false;
	if (p->next == nullptr)//尾节点
	{
		return DelPos(plist, GetLength(plist)-1);
	}

	Node* q = p->next;
	p->data = q->data;
	p->next = q->next;
	free(q);
	q = nullptr;
	
	return true;

}

//返回key的前驱地址，如果不存在返回NULL；
Node* GetPrio(List plist, int key)
{
	for (Node* p = plist;p->next != NULL;p = p->next)
	{
		if (p->next->data == key)//p是前驱地址
		{
			return p;
		}
	}
	return NULL;
}

//返回key的后继地址，如果不存在返回NULL；
Node* GetNext(List plist, int key)
{
	Node* p = Search(plist, key);
	if (p == NULL)
		return NULL;
	return p->next;
}

//输出链表
void Show(List plist)
{
	//通过节点指针，遍历所有的数据节点（注意头节点不能访问数据域）
	for (Node* p = plist->next;p != NULL;p = p->next)
	{
		printf("%d ", p->data);
	}
	printf("\n");
}

//清空数据:删除所有节点
void Clear(List plist)
{
	Destory(plist);
}

//销毁整个内存：释放所有的数据节点，头节点不用释放
void Destory1(List plist)//太复杂
{
	if (plist == NULL || plist->next == NULL)
	{
		return;
	}
	Node* p = plist->next;
	Node* q;
	plist->next = NULL;
	while (p != NULL)
	{
		q = p->next;
		free(p);
		p = q;
	}

}
void Destory2(List plist)//总是删除第一个数据节点
{
	Node* p;
	while (plist->next != NULL)
	{
		p = plist->next;
		plist->next = p->next;
		free(p);
	}
}
3 循环链表

循环链表：
1.尾部节点的 next 指向头节点，形成循环
2.带头节点

初始化头节点：
在这里插入图片描述

在这里插入图片描述

typedef struct CNode
{
	int data;
	struct CNode* next;
}CNode,*CList;

//初始化
void InitCList(CList plist);

//头插
bool Insert_head(CList plist, int val);

//尾插
bool Insert_tail(CList plist, int val);


//在plist链表的pos位置标插入数据val
bool Insert(CList plist, int pos, int val);

//判空
bool IsEmpty(CList plist);

//获取数据节点个数
int GetLength(CList plist);

//在plist中查找第一个key,找到了返回地址，没有找到返回NULL
CNode* Search(CList plist, int key);

//删除pos位置的值
bool DelPos(CList plist, int pos);

//删除第一个val值
bool DelVal(CList plist, int val);

//返回key的前驱地址，如果不存在返回NULL；
CNode* GetPrio(CList plist, int key);

//返回key的后继地址，如果不存在返回NULL；
CNode* GetNext(CList plist, int key);

//输出顺序表
void Show(CList plist);

//清空数据
void Clear(CList plist);

//销毁整个内存
void Destory(CList plist);
4 双向链表

在这里插入图片描述

双向链表：
带头节点的双向链表，不循环，尾节点的后继为空，头节点的前驱为空
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
使用联合体可以让头节点的数据域不浪费，从而用来记录链表节点的个数

typedef struct DNode
{ 
	union
	{ 
		int data;
		int length;
	};
	struct DNode* next;//后继指针
	struct DNode* prio;//前驱指针
}DNode,*DList;


typedef struct DNode
{
	int data;
	struct DNode* next;//后继指针
	struct DNode* prio;//前驱指针
}DNode,*DList;

//初始化
void InitDList(DList plist);

//头插
bool Insert_head(DList plist, int val);

//尾插
bool Insert_tail(DList plist, int val);


//在plist链表的pos位置标插入数据val
bool Insert(DList plist, int pos, int val);

//判空
bool IsEmpty(DList plist);

//获取数据节点个数
int GetLength(DList plist);

//在plist中查找第一个key,找到了返回地址，没有找到返回NULL
DNode* Search(DList plist, int key);

//删除pos位置的值
bool DelPos(DList plist, int pos);

//删除第一个val值
bool DelVal(DList plist, int val);

//返回key的前驱地址，如果不存在返回NULL；
DNode* GetPrio(DList plist, int key);

//返回key的后继地址，如果不存在返回NULL；
DNode* GetNext(DList plist, int key);

//输出顺序表
void Show(DList plist);

//清空数据
void Clear(DList plist);

//销毁整个内存
void Destory(DList plist);
5 双向循环链表

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
代码实现：

//循环链表可执行的操作：（增删改查）
//初始化
void Init_dclist(PDClist pl)
{
	assert(pl != NULL);
	if(NULL == pl)
		return;

	//pl->data; 头结点的数据域不使用 浪费掉
	pl->next = pl;
	pl->prior = pl;
}

DCList * BuyNode(int val)
{
	DCList *pnewnode = (DCList *)malloc(sizeof(DCList) * 1);
	assert(pnewnode != NULL);
	pnewnode->data = val;
	pnewnode->next = NULL;
	pnewnode->prior = NULL;

	return pnewnode;
}
//头插
bool Insert_head(PDClist pl, int val)
{
	//1.assert
	assert(pl != NULL);
	if(pl == NULL)
		return false;
	//2.申请新节点
	DCList *pnewnode = BuyNode(val);
	assert(pnewnode != NULL);

	//3.插入
	pnewnode->next = pl->next;
	pnewnode->prior = pl;

	if(pl->next != pl)//证明在头插之前，就至少存在一个有效节点
	{
		pl->next->prior = pnewnode;
	}

	pl->next = pnewnode;

	//下面的代码是对比双向链表新加入的代码
	if(pl->prior == pl)//（1.如果插入之前就有有效节点，则这个指针不需要修改 2.如果是个空的链表，则这个指针需要做修改）
	{
		pl->prior = pnewnode;//是让pl->prior 永远指向最后一个节点
	}
	
	return true;
}

//尾插
bool Insert_tail(PDClist pl, int val)
{
	//1.assert
	//2.创建新节点
	DCList *pnewnode = BuyNode(val);
	assert(pnewnode != NULL);

	//3.找到合适的插入位置
	DCList *p = pl;
	for(pl; p->next!=pl; p=p->next);
	//此时 for循环执行结束，代表指针p此时指向最后一个节点

	//4.插入节点
	pnewnode->next = p->next;//pnewnode->next = pl;
	pnewnode->prior = p;

	p->next = pnewnode;

	//下面的代码是对比双向链表新加入的代码
	pl->prior = pnewnode;//因为是尾插函数，所以每次都得让pl->prior重新指向最后一个有效节点（新插入的节点）

	return true;
}

//按位置插入
bool Insert_pos(PDClist pl, int pos, int val)
{
	//1.assert  pl pos
	//2.申请新的节点
	DCList *pnewnode = BuyNode(val);
	assert(pnewnode != NULL);

	//3.找到合适的插入位置
	DCList *p = pl;
	for(int i=0; i<pos; i++)
	{
		p = p->next;
	}

	//4.插入
	pnewnode->next = p->next;
	pnewnode->prior = p;
	if(p->next != pl)
	{
		p->next->prior = pnewnode;
	}
	else///else的代码是对比双向链表新加入的代码
	{
		pl->prior = pnewnode;
	}

	p->next = pnewnode;
	
	return true;
}

//头删
bool Del_head(PDClist pl)
{
	//1.assert
	assert(pl!=NULL && pl->next!=pl);
	if(pl==NULL || pl->next==pl)
	{
		return false;
	}

	//2.找到删除的位置
	//3.删除
	DCList *p = pl->next;
	if(p->next == pl)//删除的节点就是仅存的节点
	{
		pl->next = pl->prior = pl;
		free(p);
		p = NULL;
	}
	else//删除的节点不是仅存的节点
	{
		pl->next = p->next;
		p->next->prior = pl;
		free(p);
		p = NULL;
	}

	return true;
}

//尾删
bool Del_tail(PDClist pl)
{
	//1.assert
	//2.找到删除的位置
	DCList *p = pl;
	for(p; p->next!=pl; p=p->next);
	//此时 for循环执行结束，代表指针p此时指向最后一个节点

	//3.删除
	if(pl->next == p)//if(p->prior == pl)//删除的节点就是仅存的节点//
	{
		pl->next = pl;
		pl->prior = pl;
	}
	else//删除的节点不是仅存的节点
	{
		p->prior->next = pl;//删除节点的上一个节点的next域指向头结点
		pl->prior = p->prior;//让头节点的前驱指针指向新的最后一个节点（删除节点的上一个节点）
	}

	free(p);
	p = NULL;
	return true;
}


//按位置删除
bool Del_pos(PDClist pl, int pos)
{
	//assert pl pos

	if(pos == 0)
		return Del_head(pl);
	if(pos == Get_length(pl)-1)
		return Del_tail(pl);

	//此时 剩下的情况都是中间节点删除
	DCList *p = pl;
	for(int i=0; i<pos; i++)
	{
		p = p->next;
	}

	DCList *q = p->next;//q 指向的就是删除的节点本身
	p->next = q->next;
	q->next->prior = p;
	free(q);
	q = NULL;

	return true;
}

//按值删除，删除遇到的第一个值为val的节点 如果值为val的节点不存在，则返回false
bool Del_val(PDClist pl, int val)
{
	//assert
	DCList *p = Search(pl, val);
	if(p == NULL)
	{
		return false;
	}

	//这两行代码  兼容任何情况 
	p->prior->next = p->next;
	p->next->prior = p->prior;
	free(p);
	p = NULL;

	return true;
}

//查找  查找值为val的第一个节点，找到则返回其节点地址，否则返回NULL
PDClist Search(PDClist pl, int val)
{
	//assert
	DCList *p = pl->next;
	for(p; p!=pl; p=p->next)
	{
		if(p->data == val)
		{
			return p;
		}
	}

	return NULL;
}

//判空
bool IsEmpty(PDClist pl)
{
	return pl->next == pl;
}

//获取循环链表有效元素个数
int Get_length(PDClist pl)
{
	int count = 0;
	DCList *p = pl->next;
	for(p; p!=pl; p=p->next)
	{
		count++;
	}

	return count;
}

//打印
void Show(PDClist pl)
{
	DCList *p = pl->next;
	for(p; p!=pl; p=p->next)
	{
		printf("%d ", p->data);
	}
	printf("\n");
}

//清空
void Clear(PDClist pl)
{
	Destroy(pl);
}

//销毁1 一直头删的方式释放内存
void Destroy(PDClist pl)
{
	while(pl->next != pl)
	{
		DCList *p = pl->next;
		pl->next = p->next;
		free(p);
		p = NULL;
	}

	pl->prior = pl;
}

//销毁2
void Destroy2(PDClist pl)
{
	DCList *p = pl->next;
	DCList *q;

	while(p != pl)
	{
		q = p->next;
		free(p);
		p = q;
	}

	pl->next = pl;
	pl->prior = pl;
}

//寻找值为val的节点的前驱
PDClist Get_prior(PDClist pl, int val)
{
	DCList *p = Search(pl, val);
	if(p == NULL)
	{
		return NULL;
	}

	return p->prior;
}

//寻找值为val的节点的后继
PDClist Get_next(PDClist pl, int val)
{
	DCList *p = Search(pl, val);
	if(p == NULL)
	{
		return NULL;
	}

	return p->next;
}
6 静态链表

静态链表：
利用顺序表模拟链表的操作
静态链表包含2条链表：

  • 一条为有效数据链表：带头节点的循环链表，且头节点在0下标
  • 一条为空闲数据链表：带头节点的循环链表，且头节点在1下标
    注意：插入一条空闲节点链表的目的是让插入数据时找空闲节点的速度变为O（1）

好处：不用频繁的申请以及释放内存
对外表现是链表，但是内部存储是顺序表
链表的特点：

  • 插入和删除操作快，插入和删除时不需要移动数据
    时间复杂度O（1）
    和链表相比不需要频繁的创建和删除节点
    但是和顺序表对比需要增加一个 next
    静态链表可以动态增长，满后扩容，只是需要将扩容的内存添加到空闲链表中

顺序表特点：插入和删除操作慢，适用于查找频繁的操作

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

typedef struct SNode
{
	int data;//数据
	int next;//后继指针（下标）
}SNode,SLinkList[MAXSIZE];

//SLinkList s;//s为长度为MAXSIZE的结构体数组
//
//typedef SNode Arr[MAXSIZE];//长度为MAXSIZE的结构体数组类型
//Arr a;// a 是长度为MAXSIZE的结构体数组



//初始化
void InitSList(SNode* ps);

//头插
bool Insert_head(SNode* ps, int val);

//尾插
bool Insert_tail(SNode* ps, int val);


//判空
bool IsEmpty(SNode* ps);

//获取数据节点个数
int GetLength(SNode* ps);

//在plist中查找第一个key,找到了返回地址(地址），没有找到返回-1
int  Search(SNode* ps, int key);

//删除第一个val值
bool DelVal(SNode* ps, int val);


//输出顺序表
void Show(SNode* ps);

//清空数据
void Clear(SNode* ps);
听*雨声
关注
专栏目录
静态链表的插入，增添和删除
lmxinei的博客
04-06 475
【代码】静态链表的插入，增添和删除。
线性表文档之静态链表
二木成林
04-05 1150
线性表文档之静态链表
粗识静态链表
斜阳雨陌
07-09 333
为了弥补链表在内存分配上的不足，出现了静态链表这么一个折中的办法。静态链表比较类似于内存池，它会预先分配一个足够长的数组，之后链表节点都会保存在这个数组里，这样就不需要频繁的进行内存分配了。 当然，这个方法的缺点是需要预先分配一个足够长的数组，肯定会导致内存的浪费。数组不够长到不是什么大不了的，使用第一节的动态扩容方法就是了。 静态链表一般是由两个链表组成，一个保存数据的链表，一个空闲
LinkedList详解
qq_23960265的博客
02-05 446
有一个更加详细的讲解： http://www.cnblogs.com/skywang12345/p/3308807.html 先对LinkedList的特性进行一个概述：  （1）LinkedList底层实现为双向循环链表。链表的特点就是插入删除数据快，而查询数据慢。 （2）因为使用链表的原因，所以不存在容量不足的问题，没有扩容机制。 （3）从后面的源码分析中我们也可以看出，L
静态链表相关说明
ccxcuixia
07-31 3262
参考链接 定义： 用数组描述的链表，即称为静态链表。 在C语言中，静态链表的表现形式即为结构体数组，结构体变量包括数据域data和游标CUR。 优点： 这种存储结构，仍需要预先分配一个较大的空间，但在 作为线性表的插入和删除操作时不需移动元素，仅需修改指针，故仍具有链式存储结构的主要优点。 特点： 静态链表中指针表示数组下标或下一个元素的下标。 (1)静态链表既有顺序存储的优点，又有动态链表的优点，因为其用游标cur来指示下一个数据元素的存储位置，所以存取数据时静态链表同线性链表(单链表)是相似的。也就是说
xianxingbiao.rar_线性表_线性表实习
09-19
2. **链式线性表的插入操作**：在链表中插入一个新元素时，需要创建一个新的节点，将新节点的数据部分设置为要插入的值，然后修改相邻节点的指针以连接新节点。如果插入位置在表头，那么新节点将成为首节点；如果...
xianxingbiao.rar_初始化线性表_线性表
09-22
同时，考虑到性能优化，有时也会使用链式存储结构来实现线性表，比如链表，这样插入和删除操作可以在常数时间内完成，但查找和修改操作可能会变得更复杂。 总之，线性表是数据结构的基础，掌握它的操作和实现对于...
线性表综合题_C语言_线性表_
09-29
首先，我们需要理解线性表的两种主要存储方式：顺序表和链表。顺序表是用一维数组来存储的，它的优点是访问速度快，因为数组支持随机访问；缺点是插入和删除操作效率较低，需要移动大量元素。链表则通过指针链接各个...
xianxingbiao.rar_visual c_增删_线性表
09-20
常见的线性表实现方式有顺序表和链表。 2. **顺序表**： 在顺序表中，元素存储在一块连续的内存空间中。由于内存地址连续，所以访问速度快，但插入和删除操作可能涉及到大量元素的移动。在Visual C++中，可以使用...
线性表_线性表_
10-03
1. **查找**：在线性表中查找特定元素，顺序表的平均时间复杂度为O(n)，链表的查找速度取决于查找的位置。 2. **排序**：线性表可以进行各种排序操作，如冒泡排序、选择排序、插入排序、快速排序等。 3. **合并**：...
C语言实现静态链表
08-18
主要为大家详细介绍了C语言实现静态链表，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
笔记题
u012507032的博客
05-17 2333
1.以下属于逻辑结构的是（） A.顺序表     B.哈希表     C.有序表     D.单链表 答案：C. 数据结构是反映数据的一种形式，它具体分为逻辑结构和物理结构， 1，逻辑结构：它是表现数据之间的一种关系的结构，分为线性结构和非线性结构； 2，物理结构：它是表现数据的是如何存储的结构，计算机内部是如何安排该数据的存储，通常分为顺序结构，链式结构，索引结构，哈希结构；
数据结构第2章线性表习题（一）——选择题
热门推荐
＃两个西柚
07-21 1万+
第2章 线性表 一 选择题 1．下述哪一条是顺序存储结构的优点？（ A ） A．存储密度大 B．插入运算方便 C．删除运算方便 D．可方便地用于各种逻辑结构的存储表示 2．下面关于线性表的叙述中，错误的是哪一个？（B ） A．线性表采用顺序存储，必须占用一片连续的存储单元。 B．线性表采用顺序存储，便于进行插入和删除操作。 C．线性表采用链接存储，不必占用一片连续的存储单元。 D．线性表采用链接存储，便于插入和删除操作。 3．线性表是具有n个（ C ）的有限序列...
复习——线性表习题
FFengJay的博客
06-07 5510
针对客观题进行了摘选 1.顺序存储方式插入和删除时效率太低，因此它不如链式存储方式好。( X ) 二者各有优缺点（取元素和插入删除），应看具体场景 2.链表中的头结点仅起到标识的作用。( X ) 头结点还有简化操作的作用 3.静态链表中指针表示的是（ 下一元素的数组下标 ） 4.设一个链表最常用的操作是在末尾插入结点和删除尾结点，则选用( D )最节省时间。 A.单链表 B. 单循环链表 C.带尾指针的单循环链表 D.带头结点的双循环链表 首先分析A ：对于单链表，每次插入和删除都要遍
静态链表
qq_42779344的博客
11-03 155
明确一个定义：静态链表是解决没有指针和引用时，用结构体数组来实现链表的功能； 方法：采用游标的方式来代替指针，头游标代表第一个空闲空间的下标，尾游标代表第一个有值的下标，也就是第一个结点的值； 遍历：指针是p=p->next，p是前一个结点的地址，结束条件是p->next不为NULL,那么静态链表差不多一样,k=list[k].cur，k为前一个结点的下标，结束条件list[k]....
静态链表详解
hibugs
07-18 9128
静态链表是分配一整片连续的内存空间，各个结点集中安置，而不是像单链表那样，每个结点在内存中分散存储。如上如的存储方式，优点类似于顺序表，但是在这一整片连续的内存空间中，元素不是按照顺序存储的。而是可以打乱顺序存储，这时候就需要将结点分为两个部分，一个部分存储数据元素，另一个部分存储下一个结点所在的下标(称其为游标)，比如头结点存放的下标(游标)为2，代表在2的位置上是静态链表的第一个真正存放数据的结点。addr+8*2（这里假设数据元素和游标的大小都为4B）。//数组a作为静态链表}}...
线性表详解与双链表实现
"这篇文章除了简单介绍线性表的概念和分类，还重点讨论了数组、单向链表和双向链表，并提供了双向链表的C、C++和Java三种语言的实现示例。线性表是数据结构的基础，包括数组、单向链表和双向链表等组成部分。数组...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值