没有指针和对象引用怎么实现单链表？一次性搞懂静态链表的原理与实现

最新推荐文章于 2023-05-14 22:22:38 发布
最新推荐文章于 2023-05-14 22:22:38 发布
阅读量883 收藏 2
点赞数 4
分类专栏： 初级数据结构 文章标签： 链表 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CS_COPy/article/details/120695323
版权

文章目录

✨一、静态链表的提出背景

  C语言的指针是个好东西，它可以让我们轻松的操纵内存，所以我们可以比较轻松的实现链表这一数据结构，后来的一些面向对象编程的高级语言，由于存在对象引用机制，从某种角度上也间接的实现了指针的某些作用。但对于一些语言，如Basic、Fortran等早期高级编程语言，没有指针功能，那他们是怎么实现链表的呢？

  这里就不得不感叹前人的智慧，居然想出了用数组代替指针描述单链表，我们来看看他们是怎么实现的。

✨二、静态链表的原理

🔥2.1 静态链表的数据类型

  首先，我们定义一个结构体类型Node作为节点，为了后续方便，我们把元素个数有MAXSIZE个的Node结构体数组这种类型重定义为StaticLinklist。

#define MAXSIZE 1000//定义最大长度
typedef struct {
	int data;
	int next;//next代表下一成员的下标
}Node,StaticLinklist[MAXSIZE];

🔥2.2 静态链表所在的空间的初始化

我们利用一个初始化函数把这个结构体数组初始化成下图

在这里插入图片描述

  数组的最后一个元素我们计划作为头结点一样的东西，此时他的next放0表明头结点还没有建立。

  数组的0下标元素作为一个提示域，它的next值代表目前第一个还没被申请的节点的下标。

int InitLinklist(StaticLinklist space)
{
	if (MAXSIZE - 1 <= 0)
	{
		return -1;
	}
	for (int i = 0; i < MAXSIZE - 1; i++)
	{
		space[i].next = i + 1;
	}
	space[MAXSIZE - 1].next = 0;
	return 0;
}

🔥2.3 创建静态链表——创建头结点并按顺序输入n个元素

  接下来要输入元素了，首先我们要创建头结点，也就是让最后一个元素的next值为1（其实不为1也行，不过这样很麻烦），然后顺序输入n个元素，最后把最后一个元素的next值赋成0表示当前链表到达结尾了。

//顺序输入链表的n个元素
int inputlist(StaticLinklist L, int n)
{
	if (n >= MAXSIZE - 1)
		return -1;
	L[MAXSIZE - 1].next = 1;
	int i = 1;
	for (i = 1; i <= n; i++)
	{
		printf("请输入链表的第%d个元素\n", i);
		scanf("%d", &L[i].data);
	}
	L[i - 1].next = 0;
	L[0].next = i;
	return 0;
}

输入完成后我们的链表状态如图：

在这里插入图片描述

🔥2.4 在链表的第i个位置插入元素

  与在链表中一样，我们要插入元素必须向空间申请一个空闲的节点给我们来用，所以需要一个static_malloc函数，我们向这个函数传入我们的静态链表，它向我们返回一个开辟好的待使用的位置的下标，并且把0位置的next下标更新为下一个空闲的节点的下标。

//为实现像链表一样的插入元素 我们也需要一个malloc函数 传入我们的静态表 返回一个它为我们开辟好的待用的位置的下标
//返回-1表示没有空间了 插入失败
int static_malloc(StaticLinklist space)
{
	int i = space[0].next;
	if (i != 0 && i!=MAXSIZE-1)
	{
		space[0].next = space[i].next;
		return i;
	}
	else
	{
		return -1;
	}
}

  接下来就是要插入元素了，这里和链表中很像，我们先找到第i-1个元素，让我们申请的节点的next等于它的next，让第i-1个节点的next值等于我们申请的节点的下标，然后让我们申请的这个节点的值输入进去，不过，这里找第i-1个元素的方法和链表中看起来有所不同，其实是相似的，都是从头结点走i-1步，只不过有指针的情况下我们可以用指针直接实现，没有指针的情况下我们要用下标的next值（这个代替了指针功能的东西）来走到第i-1个元素，先从MAXSIZE-1开始走，k=MAXSIZE-1,k=L[k].next—走一步走到第一个节点的位置，k=L[k].next走两步走到第二个节点的位置，走i-1次，走到第i-1个节点。

//插入静态表的第i个元素
int Insertlist(StaticLinklist space, int i, int e)
{
	if (i <= 0 || i > MAXSIZE - 1)
		return -1;
	int k = MAXSIZE - 1;
	//要插入第i个元素，首先要走到第i-1个元素的位置
	for (int j = 1; j <= i - 1; j++)
	{
		k = space[k].next;
		//循环一次，走到第一个链表第一个元素，两次，走到链表第一个元素
		//循环i-1次，走到链表的第i-1个元素
	}
	int m = static_malloc(space);
	//先把i-1号元素（也就是下标为j的元素）的next赋给m的next
	space[m].next = space[k].next;
	//然后再让i-1的next是m 就连上了链表
	space[k].next = m;
	space[m].data = e;
	return 0;
}

  插入操作的时间复杂度是O(N)，N是链表当前长度。

🔥2.5 静态链表长度函数与静态链表打印函数

  为了查看我们的静态链表的实现情况，我们可以设计一个静态链表打印函数来看我们的链表的状态，为了打印链表，我们需要知道链表的长度（其实也可以不用，有个求链表长度的函数方便一点）。

  实现求静态链表长度的函数和打印静态链表的函数是类似的，都是从头结点开始走一直走到next为0的节点为止，利用计数器统计自己走了几步静态链表就是多长。

//链表长度函数
int listlen(StaticLinklist L)
{
	int j = L[MAXSIZE-1].next;
	int i = 0;
	while (j)
	{
		j = L[j].next;
		i++;
	}
	return i;
}

//打印链表的函数
void print(StaticLinklist L)
{
	
	int len = listlen(L);
	if (len == 0)
	{
		printf("链表中没有元素空空如也\n");
		return;
	}
	int k = MAXSIZE - 1;
	for (int i = 1; i <= len; i++)
	{
		k = L[k].next;
		printf("静态链表的第%d个元素是%d\n", i, L[k].data);
	}
}

🔥2.6 删除链表中的第i个节点

  与用指针实现的单链表类似，我们需要一个static_free函数去把删除节点归还给空间，与静态链表不同的是，我们归还给空间后要让我们换的这个元素和原本的第一个空闲元素先连上，然后让空间的指示域的next值变成我们还的这个元素的下标。

//释放下标为i的节点，把他放回待使用的节点中
void static_free(StaticLinklist L, int i)
{
	//把当前0下标的next指向的可用的元素的下标赋给L[i].next
	L[i].next = L[0].next;
	//让0下标的next指向i下标 这样吧i连到了原本的待用元素的前面
	L[0].next = i;
}

  删除第i个节点的函数的实现原理和用指针实现的单链表类似，都是先把第i个元素的next值赋给第i-1个元素的next值，然后static_free第i个元素就可以了。

//删除第i个元素
int listdelete_bynumber(StaticLinklist L, int i)
{
	if (i<1 || i>listlen(L))
		return -1;
	int k = MAXSIZE - 1;
	int j = 1;
	for (j = 1; j <= i - 1; j++)
	{
		k = L[k].next;
	}
	j = L[k].next;
	int m = L[j].next;
	L[k].next = m;
	static_free(L, j);
	return 0;
}

  删除操作的时间复杂度是O(N),N是链表当前长度。

🔥2.7 在链表中查找元素c与在链表中删除元素c

  查找函数的实现也是通过k=MAXSIZE-1 k=L[k].next遍历静态链表实现的。

//查找元素c
//若查找成功，返回查找到的元素在链表中的次序位置
//若查找失败 返回0
int listsearch(StaticLinklist L, int c)
{
	int k = MAXSIZE - 1;
	int ret = 0;
	for (int i = 1; i <= listlen(L); i++)
	{
		k = L[k].next;
		if (L[k].data == c)
		{
			ret = i;
			break;
		}
	}
	return ret;
}

  查找函数的时间复杂度也是O(N),N是当前链表长度。

  删除元素c的节点的操作是这样实现的，首先利用查找函数判断c元素是否在链表中，如果在的话，利用查找函数返回的元素在链表中的次序m，利用2.6解中的删除链表中的第m个节点，这样就实现了这个函数。

//删除c元素
//删除失败返回-1
//删除成功返回0
int listdelete_byvalue(StaticLinklist L, int value)
{
	int m = listsearch(L, value);
	if (m == 0)
	{
		printf("删除元素不存在\n");
		return -1;
	}
	listdelete_bynumber(L, m);
	return 0;
}

  删除指定元素的时间复杂度也是O(N).N是当前链表长度。

🔥2.8 静态链表排序（待实现）

🔥2.9 销毁静态链表

  与销毁单链表相似，我们使用两个指针作用的整形p q来实现销毁链表，首先，让p存第一个节点的下标，让q存p的下一个节点的下标（也就是L[p].next），然后static_free§,然后把q赋值给p，把p的下一个节点的下标赋值给q，如此循环往复，直到p走过链表的结尾来到指示域结束循环，然后让头结点的next值赋为0表示链表已被销毁，回到初始化后的状态了。

  有人会说，哎呀，你怎么不直接只用一个p不断static_free§ p=L[p].next就行了，这是新手常犯的错误，再好好思考一下，static_free§以后原本p的next的信息会丢失，因为你已经还给链表空间了，你还了以后p的next值是下一个空闲的节点的下标，所以这样并不能一路销毁我们的静态链表。

//销毁链表
void destroylist(StaticLinklist L)
{
	int p, q;
	p = L[MAXSIZE - 1].next;
	q = L[p].next;
	while (p != 0)
	{
		static_free(L, p);
		p = q;
		q = L[q].next;
	}
	L[MAXSIZE - 1].next = 0;
}

  销毁链表函数的时间复杂度也是O(N)，N为链表长度。

✨三、静态链表的优缺点

😂优点：

  • 相较于顺序表，在插入和删除的操作时，只需要变化next值，不需要移动元素，从而改进了顺序存储结构中插入和删除操作需要大量移动元素的缺点。

🎃缺点：

  • 没有解决连续分配导致的明明有足够的空间却扩容失败的问题。
  • 失去了链式存储结构随机读取的特性。

✨四、汇总与测试函数

//"staticlinklist.h"
#ifndef __STATICLINKLIST__H__
#define __STATICLINKLIST__H__
#include<stdio.h>
#include <Windows.h>
#define MAXSIZE 1000//定义最大长度
typedef struct {
	int data;
	int next;
}Node,StaticLinklist[MAXSIZE];

int InitLinklist(StaticLinklist space);//初始化静态链表所在的结构体数组空间

int static_malloc(StaticLinklist space);
//为实现像链表一样的插入元素 我们也需要一个malloc函数 传入我们的静态表 返回一个它为我们开辟好的待用的位置的下标

int inputlist(StaticLinklist L, int n);//创建链表并按顺序向链表输入n个元素

int Insertlist(StaticLinklist space, int i, int e);//在链表的第i个节点的位置插入元素

int listlen(StaticLinklist L);//链表长度函数

void print(StaticLinklist L);//打印链表的函数

void static_free(StaticLinklist L, int i);//释放下标为i的节点，把他放回待使用的节点中

int listdelete_bynumber(StaticLinklist L, int i);//删除第i个元素

int listsearch(StaticLinklist L, int c);//查找元素c

int listdelete_byvalue(StaticLinklist L, int value);//删除c元素

void sortlist(StaticLinklist L);//链表排序（待实现）

void destroylist(StaticLinklist L);//销毁链表


#endif

//"staticlinklist.c"
#include "staticlinklist.h"
int InitLinklist(StaticLinklist space)
{
	if (MAXSIZE - 1 <= 0)
	{
		return -1;
	}
	for (int i = 0; i < MAXSIZE - 1; i++)
	{
		space[i].next = i + 1;
	}
	space[MAXSIZE - 1].next = 0;
	return 0;
}

//为实现像链表一样的插入元素 我们也需要一个malloc函数 传入我们的静态表 返回一个它为我们开辟好的待用的位置的下标
//返回-1表示没有空间了 插入失败
int static_malloc(StaticLinklist space)
{
	int i = space[0].next;
	if (i != 0 && i!=MAXSIZE-1)
	{
		space[0].next = space[i].next;
		return i;
	}
	else
	{
		return -1;
	}

}

//顺序输入链表的n个元素
int inputlist(StaticLinklist L, int n)
{
	if (n >= MAXSIZE - 1)
		return -1;
	L[MAXSIZE - 1].next = 1;
	int i = 1;
	for (i = 1; i <= n; i++)
	{
		printf("请输入链表的第%d个元素\n", i);
		scanf("%d", &L[i].data);
	}
	L[i - 1].next = 0;
	L[0].next = i;
	return 0;
}

//插入静态表的第i个元素
int Insertlist(StaticLinklist space, int i, int e)
{
	if (i <= 0 || i > MAXSIZE - 1)
		return -1;
	int k = MAXSIZE - 1;
	//要插入第i个元素，首先要走到第i-1个元素的位置
	for (int j = 1; j <= i - 1; j++)
	{
		k = space[k].next;
		//循环一次，走到第一个链表第一个元素，两次，走到链表第一个元素
		//循环i-1次，走到链表的第i-1个元素
	}
	int m = static_malloc(space);
	//先把i-1号元素（也就是下标为j的元素）的next赋给m的next
	space[m].next = space[k].next;
	//然后再让i-1的next是m 就连上了链表
	space[k].next = m;
	space[m].data = e;
	return 0;
}

//链表长度函数
int listlen(StaticLinklist L)
{
	int j = L[MAXSIZE-1].next;
	int i = 0;
	while (j)
	{
		j = L[j].next;
		i++;
	}
	return i;
}

//打印链表的函数
void print(StaticLinklist L)
{
	
	int len = listlen(L);
	if (len == 0)
	{
		printf("链表中没有元素空空如也\n");
		return;
	}
	int k = MAXSIZE - 1;
	for (int i = 1; i <= len; i++)
	{
		k = L[k].next;
		printf("静态链表的第%d个元素是%d\n", i, L[k].data);
	}
}


//释放下标为i的节点，把他放回待使用的节点中
void static_free(StaticLinklist L, int i)
{
	//把当前0下标的next指向的可用的元素的下标赋给L[i].next
	L[i].next = L[0].next;
	//让0下标的next指向i下标 这样吧i连到了原本的待用元素的前面
	L[0].next = i;
}

//删除第i个元素
int listdelete_bynumber(StaticLinklist L, int i)
{
	if (i<1 || i>listlen(L))
		return -1;
	int k = MAXSIZE - 1;
	int j = 1;
	for (j = 1; j <= i - 1; j++)
	{
		k = L[k].next;
	}
	j = L[k].next;
	int m = L[j].next;
	L[k].next = m;
	static_free(L, j);
	return 0;
}

//查找元素c
//若查找成功，返回查找到的元素在链表中的次序位置
//若查找失败 返回0
int listsearch(StaticLinklist L, int c)
{
	int k = MAXSIZE - 1;
	int ret = 0;
	for (int i = 1; i <= listlen(L); i++)
	{
		k = L[k].next;
		if (L[k].data == c)
		{
			ret = i;
			break;
		}
	}
	return ret;
}

//删除c元素
//删除失败返回-1
//删除成功返回0
int listdelete_byvalue(StaticLinklist L, int value)
{
	int m = listsearch(L, value);
	if (m == 0)
	{
		printf("删除元素不存在\n");
		return -1;
	}
	listdelete_bynumber(L, m);
	///*int k = MAXSIZE - 1;
	//int i = 1;
	//for (i = 1; i <= m - 1; i++)
	//{
	//	k = L[k].next;
	//}
	//i = L[k].next;
	//L[k].next = L[i].next;
	//static_free(L, i);*/
	return 0;
}

//销毁链表
void destroylist(StaticLinklist L)
{
	int p, q;
	p = L[MAXSIZE - 1].next;
	q = L[p].next;
	while (p != 0)
	{
		static_free(L, p);
		p = q;
		q = L[q].next;
	}
	L[MAXSIZE - 1].next = 0;
}

//test.c
#include "staticlinklist.h"
int main()
{
    //测试创建静态链表
	StaticLinklist L;
	InitLinklist(L);
	printf("请输入要创建链表的元素个数\n");
	int n;
	scanf("%d", &n);
	inputlist(L, n);
	print(L);
    
    //测试插入函数
	printf("请输入要插入的位置i和插入元素c\n");
	printf("i=");
	int i = 0;
	scanf("%d", &i);
	printf("c=");
	int c = 0;
	scanf("%d", &c);
	Insertlist(L, i, c);
	print(L);
    
    //测试删除函数
	printf("请输入你要删除第几个元素\n");
	int k = 0;
	printf("k=");
	scanf("%d", &k);
	listdelete_bynumber(L, k);
	print(L);
    
    //测试查找函数和按值删除函数
	printf("请输入你要查找的元素:\n");
	int m = 0;
	scanf("%d", &m);
	if (listsearch(L, m) == 0)
	{
		printf("找不到\n");
	}
	else
	{
		printf("找到了，是链表的第%d个元素\n", listsearch(L, m));
	}
	printf("请输入你要删除的元素\n");
	int w = 0;
	scanf("%d", &w);
    
    //测试销毁链表函数
	listdelete_byvalue(L, w);
	print(L);
	printf("即将销毁链表\n");
	Sleep(5000);
	destroylist(L);
	print(L);
	return 0;
}

✨五、参考文献

1.《大话数据结构》 程杰 清华大学出版社

魔术师的徒弟
关注
  • 4
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
如何不使用指针实现单链表
toytoytelecar的博客
04-06 937
在数据结构中，链表的插入和删除要比数组方便许多，但通常我们接触到的单链表都是使用指针实现的单链表。 然而在算法竞赛中，指针很容易导致出错，所以下面我们来介绍一组非指针方法实现的单链表。 我们知道，链表的原理即为：每一个子节点都存储了下一个节点的地址，所以我们使用数组实现链表时，可以使用两个数组： char s[] 此数组为存放数据的数组 int next[] 此数组对应ch[]的下标，存储的是下一个节点的下标。 这样，链表就通过另一个数组next[]相互串起来了。 链表功...
不借助指针实现链表——利用多数组实现
sinat_32092165的博客
04-02 1011
有些语言不提供指针，这时候我们怎么实现链表？可以借助数组来实现。 基本思路如下：在链表中，之所以利用指针，主要是用来存储后继节点和前驱节点的位置。如果不用指针，使用数组下标也可以表示一个节点的位置。比如我们可以定义三个数组：key，next和prev，key[i]用来存放i号节点的值，next[i]用来存放i号节点的后继节点的下标，prev[i]用来存放i号节点的前驱节点的下标。这样借助于数组的...
无指针的静态链表的实现
weixin_34315485的博客
06-06 161
早期语言没有c，更不用说java等一些高级语言。那么是怎么描述链表这种实现呢？这次以单链表的模拟为例，深究一下 静态链表 的实现。 静态链表结构 按照之前单链表的性质，我们需要游标和数据。当然，每个元素都有下标（类似数组） 游标的含义 静态链表中，首节点和尾结点都没有数据（数据为空） 首节点的游标指向第一个含有数据为空的元素的下标。 最后一个节点的游标指向第一个含有数据（不为空）的元素的下...
python没有指针如何实现链表_Python单链表原理与实现方法详解
weixin_39625008的博客
11-24 348
一个单向链表的节点由数据字段和指针组成，指针指向下一个元素所在内存地址定义一个链表节点类,self.value实例属性表示节点数据字段；self.next表示指针；初始化值为Noneclass Node(object):def __init__(self, value=None, next=None):self.value = valueself.next = next在单链表中第一个节点为头(h...
c语言不用指针实现链表,静态链表（C语言, 数组，模拟无指针编程语言数组实现单链表）...
weixin_28914903的博客
05-18 432
说明：数据元素为结构体(复合数据类型)：存放游标和实际数据数据的第1个元素和末尾元素存放元数据**第1个元素**游标：存放(指向)备用下标，供下次使用,初始化为1数据：链表tail标识，(尾节点下标)**末尾元素：**游标：存放链表第1个有效节点下标, head标识，初始化为1(根据len特殊处理)数据：链表当前有效节点个数(长度len)#include #include #include #in...
链表演示工具设计说明1
08-03
为了防止图像闪烁，采用了双缓冲技术，先在位图上完成图像更新，然后一次性绘制到显示区域。 逻辑结构上，软件遵循线性表的逻辑组织，每个结点只有一个直接前驱和直接后继。物理结构则采用双向循环链表，每个结点...
二叉排序树与平衡二叉树的实现
12-26
如果是LR型或LR型，则需应用扁担原理旋转两次，第一次最小不平衡子树的根结点先不动，调整插入结点所在子树，第二次再调整最小不平衡子树，在旋转过程中，如果出现冲突，应用旋转优先原则调整冲突； (5)计算调整后的...
数据结构中c，c++各种方法实现约瑟夫环问题的代码
11-06
1. 使用链表：创建一个单链表，每个节点代表一个人，节点包含值（报数）和指向下一个节点的指针。遍历链表，每次遇到报数为特定值的节点，就将其删除并连接前后节点。 2. 使用数组：数组的索引代表人的位置，数组...
2.1 线性表1
08-03
链表支持动态分配空间，即需要新节点时才分配，不需一次性分配所有空间。链表又可细分为单链表、双链表、循环单链表和循环双链表。 单链表每个节点只有一个指针域指向后继节点，带头结点的单链表头指针`head`指向不...
adv_ds_algo:高级数据结构和算法项目
06-29
《高级数据结构与算法项目详解》 在计算机科学领域，数据结构和算法是核心部分，...对于Java程序员来说，这是一次绝佳的学习和提升机会，不仅可以巩固理论知识，还能提高实际编程技能，为解决实际问题打下坚实基础。
没有指针的静态链表
Darlingrex的博客
03-20 384
为什么没有指针？ 其实，C语言的强大和优雅毋庸置疑，但是，你必须相信，在与其相仿的那个年代，还有很多其他的思想占据着科学家们的脑子，他们的想法和其他人并不相同，所以没有指针的语言也是有的。 没有指针可用的语言，在读者看来也有很多，比如Java，Python等高级语言，但他们真的没有指针么？想想他们的参数传递，想想他们的数据结构的实现，是不是都有引用的意思？这就是指针对他们的影响，当然，他们也乐于认同并推广指针的威力，只不过，他们需要我们在更加安全的环境下工作，所以对指针和相关的数据结构进行了更高层次的抽象。
不用指针和对象数据类型来实现链表
weixin_30675967的博客
12-09 246
当没有指针和对象时，应该怎么实现链表呢？参考算法导论，给出两种实现方式： 1、多重数组表示 对于双向链表而言，由三个长度一样的数组来表示，分别为Prev[n],Next[n],Value[n]。下标相同的三个数组元素组成一个链表元素。Value[n]里存放的是链表元素的值，Prev[n]和Next[n]里存放的是数组的索引，表示该链表元素的前面和后面分别是什么。链表中的第一个元素的前缀为空，因...
python没有指针如何实现链表_Java，Python中没有指针，怎么实现链表，图等数据结构...
weixin_39989949的博客
11-20 94
展开全部package com.list;public class Node {private Node next;private T data;public Node(){this(null, null);}public Node(Node next, T data){this.next = next;this.data = data;}public Node getNext() {return...
C语言不用指针，还能写链表吗
最新发布
qq_44103902的博客
05-14 139
【代码】C语言不用指针，还能写链表吗。
python没有指针如何实现链表_[转]为什么python标准库没有实现链表
weixin_39932692的博客
11-24 121
实际上刚开始学习一些高级语言的时候我也有同样的疑问，而且即使有链表对应物的语言，链表常常也很少被实际使用。如果是在国外听数据结构的课，老师一般会警告你这只是一个理论概念，实际应用应该实际考察，在通常情况下链表不是一个很好的结构。通常链表会作为一个很好的反例，告诉大家脱离实际硬件环境来谈论所谓算法复杂度是没有任何意义的。这是因为，链表已经不适合当今的计算机硬件发展。当今的计算机硬件对内存是否连续更为...
java没有指针怎么处理链表_Java，Python中没有指针，怎么实现链表，图等数据结构...
weixin_36272416的博客
02-24 256
packagecom.list;publicclassNode{privateNodenext;privateTdata;publicNode(){this(null,null);}publicNode(Nodenext,Tdata){this.next=next;this.data=data;}publicNodegetNext(){returnnex...
不使用指针实现双向链表
qq_45860423的博客
10-27 268
java中将指针封装之后，也可以实现双向链表，创建对象时产生栈，使用内存空间 参考代码 package Test; class Link{ //存放的数据 public int data; //左节点 public Link prior; //右节点 public Link next; public Link(int data) { this.data = data; } public void print() { System.out.print(data +" ");
静态链表学习代码-不能用指针时在数组中的单链表实现
Lucien的博客
07-15 280
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;stddef.h&gt; #define ArrayMaxSize 1102//足够大的数组空间 //线性表-静态链表 //顺序存储的优点 （随机存取快O(1)）缺点（删除插入操作效率低时间复杂度为O(n) 大小无法随意更改） //非连续内存链式结构的优点（插入删除时间复杂度...
C语言 链表 没有头指针,C语言链表头结点指针域不赋值出现错误？
weixin_35545782的博客
05-20 253
用单链表实现多项式的加法和乘法很基础的一道数据结构题目，用C语言实现了主要的函数和main函数如下#include #include //多项式结构体typedef struct PolyNode *Polynomial;struct PolyNode{int coef;//系数int expon;//指数Polynomial link;//指向后一个节点的指针域};Polynomial Read...
约瑟夫环问题解决：双向循环链表与静态链表实现
4. **静态链表**：静态链表是一种节省内存空间的方法，它在内存中连续分配一组节点，每个节点内包含数据和指针。在约瑟夫环问题中，静态链表可以有效地管理所有参赛者的状态，而无需动态内存分配。 在程序设计上，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值