数据结构——顺序表专题

最新推荐文章于 2024-09-13 19:36:07 发布
最新推荐文章于 2024-09-13 19:36:07 发布
阅读量1.2k 收藏 31
点赞数 45
文章标签： 数据结构 c语言 编辑器 笔记 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/optimistic_chen/article/details/138441169
版权


乐观学习，乐观生活，才能不断前进啊！！！

我的主页：optimistic_chen
我的专栏：c语言
点击主页：optimistic_chen和专栏：c语言，
创作不易，大佬们点赞鼓励下吧~

前言

什么是数据结构呢?
· 数据结构是由“数据”和“结构”两词组合⽽来。
· 概念：数据结构是计算机存储、组织数据的⽅式。
· 数据结构是指相互之间存在⼀种或多种特定关系的数据元素的集合。数据结构反映数据的内部构成，即数据由那部分构成，以什么⽅式构成，以及数据元素之间呈现的结构。
总结：
1）能够存储数据（如顺序表、链表等结构）
2）存储的数据能够⽅便查找

文章目录

顺序表概念

线性表（ linear list ）是n个具有相同特性的数据元素的有限序列。线性表是⼀种在实际中⼴泛使⽤的数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串…
线性表在逻辑上是线性结构，也就说是连续的⼀条直线。但是在物理结构上并不⼀定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

顺序表的分类

顺序表的底层结构是数组，对数组的封装，实现了常⽤的增删改查等接⼝

静态顺序表

struct SeqList
{
	int arr[100];//开少了不够，开多了浪费
	int size;//有效数据个数
};

typedef int SLDataType;

静态顺序表是一种在数据结构中常见的线性表实现方式，它使用定长数组来存储数据元素。这种数据结构在初始化时就确定了存储空间的大小，并在运行期间保持不变。

动态顺序表

typedef struct SeqList
{
	SLDataType* arr;//按需申请空间
	int size;//有效数据个数
	int capacity;//空间大小
}SL;

动态顺序表是一种可以动态调整其大小的顺序表，它克服了静态顺序表在大小固定方面的限制。

对比

分类静态顺序表动态顺序表
空间分配创建时就分配了固定的内存空间，这避免了在运行时频繁地申请或释放内存根据数据的实际需求动态地扩展或缩小存储空间，从而避免了静态顺序表在存储空间分配上可能出现的浪费或不足的问题
灵活性不灵活灵活性强
效率由于数据元素在内存中是连续存放的，因此可以通过下标直接计算出元素在内存中的位置，实现快速存取尽管动态顺序表能够动态调整大小，但在插入或删除元素时，仍可能需要移动其他元素以保持数据的连续性。这尤其在元素数量较大或需要频繁进行插入/删除操作时可能导致效率降低
管理静态顺序表的实现相对简单，因为数组的操作是基础的编程技能，所以理解和使用都比较容易动态顺序表需要维护额外的元数据（如当前大小、最大容量等），并需要实现相应的内存管理操作（如分配、释放等）。这增加了实现的复杂性和出错的可能性

总结：
静态顺序表在数据规模确定且不需要频繁改变的情况下表现良好，但在面对动态变化的数据规模时，其缺点就显得尤为突出。动态顺序表在处理动态变化的数据规模时具有较大的优势，但也需要考虑其带来的额外开销和实现的复杂性。在选择使用顺序表时，需要根据具体的应用场景和需求进行权衡。

顺序表的实现

我们以动态顺序表为例，完成顺序表的实现：

我们首先将顺序表的所有需求定义在一个头文件SeqList.h中。

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int SLDataType
#define INIT_CAPACITY 4
/动态顺序表
typedef struct SeqList
{
	SLDataType* arr;
	int size;
	int capacity;//空间大小
}SL;

//顺序表初始化
void SLInit(SL* ps);

//顺序表的销毁
void SLDestroy(SL* ps);

//顺序表的扩容
void SLCheckCapacity(SL* ps);

//顺序表的打印  
void SLPrintf(SL* ps);

//头部插入 / 尾部插入
void SLPushBack(SL* ps, SLDataType x);
void SLPushPront(SL* ps, SLDataType x);

//头部删除 / 尾部删除
void SLPopBack(SL* ps);
void SLPopPront(SL* ps);

//在指定位置之前插入/删除数据
void SLInsert(SL* ps, int pos, SLDataType x);
void SLFrase(SL* ps, int pos);

//查找数据
int SLFind(SL* ps, SLDataType x);

我们后期的一系列操作都是根据头文件中的需求实现的。

一、顺序表的初始化

void SLInit(SL* ps)
{
	assert(ps);
 
	ps->arr = (SLDataType*)malloc(sizeof(SLDataType)* INIT_CAPACITY);
	if (ps->arr == NULL)
	{
		perror("malloc fail");
		return;
	}
 
	ps->size =0; 
	ps->capacity = INIT_CAPACITY;
}

代码分析：

断言（assert）：

assert(ps);

断言用于检查传入的指针 ps 是否为 NULL。如果 ps 是 NULL，程序会在调试模式下终止执行，并显示一条错误消息。提前检查错误，确保ps 指向了一个有效的内存地址。
开辟内存空间

ps->arr = (SLDataType*)malloc(sizeof(SLDataType)* INIT_CAPACITY);

malloc 函数分配了 INIT_CAPACITY 个 SLDataType 大小的内存块，并将其地址赋值给 ps->arr。
这里SLDataType 是顺序表中存储的数据类型，而 INIT_CAPACITY 是一个常量，表示顺序表初始的容量
内存开辟失败：

if (ps->arr == NULL)  
 {  
 perror("malloc fail");  
 return;  
 }

如果malloc函数没有顺利开辟内存，那么就会打印错误信息，不执行后面的代码。
初始化顺序表：

    ps->size =0; 
	ps->capacity = INIT_CAPACITY;

size 表示顺序表中当前存储的元素数量，初始化为0，表示顺序表是空的。
capacity 表示顺序表的容量，即它可以存储的最大元素数量，初始化为 INIT_CAPACITY。

二、顺序表的销毁

void SLDestroy(SL* ps)//销毁
{
	if (ps->arr)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

代码分析：

释放内存：

if (ps->arr)
	{
		free(ps->arr);
	}

if 的判断条件为ps->arr不为NULL则释放arr所占用的空间
这是一个非常重要的步骤，因为如果不释放已分配的内存，会导致内存泄漏
重置指针和属性

ps->arr = NULL;
ps->size = ps->capacity = 0;

释放内存之后，将 ps->a 设置为 NULL 是一个好习惯，这可以避免在之后的代码中意外地使用已释放的内存。，避免野指针的出现。
此外，将 ps->capacity 和 ps->size 重置为0，确保顺序表的状态正确地反映了它已经被销毁。

三、顺序表的打印

void SLPrintf(SL* ps)//打印
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}

代码分析：

for 循环，用于遍历顺序表中的每一个元素。
循环变量 i 从0开始，一直到 ps->size - 1（即顺序表中最后一个元素的索引）。
ps->size 表示顺序表中当前存储的元素数量

四、顺序表容量的检查

void SLCheckCapacity(SL* ps)//申请空间单独成一个函数
{
	if (ps->capacity == ps->size)
	{
		//申请空间(多大？一般2倍增容)
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, newCapacity * 2 * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		//申请空间成功
		ps->arr = tmp;
		ps->capacity = newCapacity;
	}
}

SLCheckCapacity 函数用于检查顺序表的当前容量是否足够。如果顺序表已满（即 ps->size 等于 ps->capacity），则该函数会尝试扩大顺序表的容量

代码分析

检查容量：

if (ps->capacity == ps->size)

如果 ps->capacity==ps->size 说明顺序表已经没有额外的空间来存储新的元素了。

扩大容量：

SLDataType* tmp = (SLDataType*)realloc(ps->arr, newCapacity * 2 * sizeof(SLDataType));

使用realloc函数重新分配内存，我们将顺序表的容量扩大两倍（ps->capacity*2）。
realloc 函数尝试在内存中找到足够大的连续空间来容纳扩大后的顺序表，如果成功，它返回指向新内存块的指针；如果失败，它返回 NULL。

内存分配失败：

if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}

分配失败，返回值为NULL，满足 if 条件，我们使用 perror 函数打印一个错误消息（“realloc fail”），然后函数返回，不执行后续的代码。

更新指针和容量：

ps->arr = tmp;
ps->capacity = newCapacity;

分配内存成功，我们将 ps->arr 更新为指向新的内存块，并将 ps->capacity 更新为新的容量（newCapacity）。这样，顺序表就有了更多的空间来存储新的元素。

五、顺序表的头插

void SLPushPront(SL* ps, SLDataType x)//头插
{
	assert(ps);
	void SLCheckCapacity(SL * ps);
	//先让顺序表的数据统一往后移动
	for (int i = ps->size; i > 0 ; i--)
	{
		ps->arr[i] = ps->arr[i - 1];//arr[1]=arr[0]
	}
	ps->arr[0] = x;
	ps->size++;
}

代码分析

assert(断言)：

assert(ps);

断言用于检查传入的指针 ps 是否为 NULL。如果 ps 是 NULL，程序会在调试模式下终止执行，并显示一条错误消息。提前检查错误，确保ps 指向了一个有效的内存地址。

开辟插入节点的空间

void SLCheckCapacity(SL * ps);

调用SLCheckCapacity函数开辟空间

顺序表中原有的所有元素向后移动一位：

for (int i = ps->size; i > 0 ; i--)
	{
		ps->arr[i] = ps->arr[i - 1];//arr[1]=arr[0]
	}

将顺序表的原有元素在原来位置统一向后移动一位，以便在开头为新元素腾出空间。

加入元素，更新链表大小

ps->arr[0] = x;
ps->size++;

将元素插入第一个（头部）位置，链表大小加一。

六、顺序表的尾插

void SLPushBack(SL* ps, SLDataType x)//顺序表的尾插
{
	assert(ps);
	//插入数据之前先判断空间够不够
    void SLCheckCapacity(SL * ps);
	//ps->arr[ps->size] = x;
	//++ps->size;
	ps->arr[ps->size++] = x;
}

代码分析

（断言与开辟新内存和前面的情况一样，接下来不进行阐述。）
尾部插入元素

ps->arr[ps->size] = x;
++ps->size;
或者
ps->arr[ps->size++] = x;

二者代码没有区别，只是第一种代码可读性较好，第二种更加体现逻辑性
我们以第一种为例：
新元素 x 被添加到顺序表的末尾，并更新顺序表的大小。

七、 顺序表的头删

void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size》0);
 
	int pos = 1;
	while (pos < ps->size)
	{
		ps->arr[pos - 1] = ps->arr[pos];
		++pos;
	}
 
	ps->size--;
}

代码分析

前移元素

while (pos < ps->size)
	{
		ps->arr[pos - 1] = ps->arr[pos];
		++pos;
	}

它使用一个 while 循环将顺序表中从第二个元素开始的所有元素向前移动一位，以便删除第一个元素。

更新顺序表大小

ps->size--;

八、顺序表的尾删

void SLPopBack(SL* ps)//尾删
{
	assert(ps);
	assert(ps -> size);//顺序表不为空
	//ps->arr[ps->size - 1] = -1;
	--ps->size;//直接减去空间
}

代码分析

删去数据，直接减去空间，最后记得更新顺序表大小

九、顺序表指定位置之前插入数据

void SLInsert(SL* ps, int pos, SLDataType x) 
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	//插入数据：空间够不够
	void SLCeckCapacityCapacity(ps);
	//让pos之后的数据整体往后移动一位
	for (int i = ps->size; i>pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];//arr[pos+1]=arr[pos]
	}
	ps->arr[pos] = x;
	ps->size++;
}

代码示例：

assert(断言)

assert(ps);
assert(pos >= 0 && pos <= ps->size);

确保pos的位置在顺序表中

检查容量

void SLCeckCapacityCapacity(ps);

调用SLCeckCapacityCapacity函数开辟内存空间。

移动元素

for (int i = ps->size; i>pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];//arr[pos+1]=arr[pos]
	}

这一部分代码负责将位置 pos 及之后的元素向后移动一位，以便为新元素腾出空间。

插入新元素

ps->arr[pos] = x;

在移动完元素后，将新元素 x 插入到位置 pos。

更新链表大小

ps->size++;

需要注意的是，由于顺序表在内存中是连续存储的，插入操作的时间复杂度是 O(n)，其中 n 是顺序表的大小。如果频繁进行插入操作，可能会影响程序的性能

十、顺序表指定位置之前删除数据

void SLFrase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size );
	for (int i = pos; i < ps->size-1; i++)
	{
		ps->arr[i] = ps -> arr[i + 1];
	}
	ps->size--;
}

代码示例：

移动元素

for (int i = pos; i < ps->size-1; i++)
	{
		ps->arr[i] = ps -> arr[i + 1];
	}

这一部分代码负责将位置 pos + 1 及之后的元素向前移动一位，以覆盖掉位置 pos 的元素

更新链表大小

ps->size--;

需要注意的是，SLFrase 函数并没有真正地释放被删除元素所占用的内存空间。它只是通过移动后续元素来覆盖掉被删除的元素，并将顺序表的大小减1

十一、顺序表的数据查找

//查找数据
int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			//找到了
			return i;
		}
	}
	//没找到
	return -1;
}

代码示例：

遍历顺序表

for (int i = 0; i < ps->size; i++)

使用一个 for 循环遍历顺序表中的每一个元素。
循环变量 i 从0开始，直到 ps->size-1 （顺序表中最后一个元素的索引）

查找元素

if (ps->arr[i] == x)
		{
			//找到了
			return i;
		}

在循环体内部，检查当前元素 ps->arr[i] 是否等于要查找的元素 x。
如果相等，说明找到了元素 x，函数立即返回该元素在顺序表中的位置 i。

没有找到

//没找到
return -1;

如果循环结束后都没有找到元素 x，函数返回 -1，表示在顺序表中未找到该元素。

完整代码

SeqList.h

//动态顺序表
typedef struct SeqList
{
	SLDataType* arr;
	int size;
	int capacity;//空间大小
}SL;

//typedef struct SeqList SL;

//顺序表初始化
void SLInit(SL* ps);
//顺序表的销毁
void SLDestroy(SL* ps);
  
void SLPrintf(SL s);
//头部插入 / 尾部插入
void SLPushBack(SL* ps, SLDataType x);
void SLPushPront(SL* ps, SLDataType x);

//头部删除 / 尾部删除
void SLPopBack(SL* ps);
void SLPopPront(SL* ps);

//在指定位置之前插入/删除数据
void SLInsert(SL* ps, int pos, SLDataType x);
void SLFrase(SL* ps, int pos);

//查找数据
int SLFind(SL* ps, SLDataType x);

SeqList.c

#include"SeqList.h"
void SLInit(SL* ps)//初始化
{
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

void SLDestroy(SL* ps)//销毁
{
	if (ps->arr)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

void SLPushBack(SL* ps, SLDataType x)//顺序表的尾插
{
	assert(ps);
	//插入数据之前先判断空间够不够
	if (ps->capacity == ps->size)
	{
		//申请空间(多大？一般2倍增容)
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDataType*tmp = (SLDataType*)realloc(ps->arr,newCapacity * 2 * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		//申请空间成功
		ps->arr = tmp;
		ps->capacity = newCapacity;
	}
	//ps->arr[ps->size] = x;
	//++ps->size;
	ps->arr[ps->size++] = x;
}

void SLCheckCapacity(SL* ps)//申请空间单独成一个函数
{
	if (ps->capacity == ps->size)
	{
		//申请空间(多大？一般2倍增容)
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, newCapacity * 2 * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		//申请空间成功
		ps->arr = tmp;
		ps->capacity = newCapacity;
	}
}

void SLPushPront(SL* ps, SLDataType x)//头插
{
	assert(ps);
	void SLCheckCapacity(SL * ps);
	//先让顺序表的数据统一往后移动
	for (int i = ps->size; i > 0 ; i--)
	{
		ps->arr[i] = ps->arr[i - 1];//arr[1]=arr[0]
	}
	ps->arr[0] = x;
	ps->size++;
}

void SLPrintf(SL s)//打印
{
	for (int i = 0; i < s.size; i++)
	{
		printf("%d ", s.arr[i]);
	}
	printf("\n");
}

void SLPopBack(SL* ps)//尾删
{
	assert(ps);
	assert(ps -> size);//顺序表不为空
	//ps->arr[ps->size - 1] = -1;
	--ps->size;//直接减去空间
}

void SLPopPront(SL* ps)
{
	assert(ps);
	assert(ps->size);
	
	//数据整体往前一位
	for (int i = 0; i < ps->size-1;i++)
	{
		ps->arr[i] = ps->arr[i + 1];//arr[size-2]=arr[size-1]
	}
	ps->size--;
}

//在指定位置之前插入数据
void SLInsert(SL* ps, int pos, SLDataType x) 
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	//插入数据：空间够不够
	void SLCeckCapacityCapacity(ps);
	//让pos之后的数据整体往后移动一位
	for (int i = ps->size; i>pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];//arr[pos+1]=arr[pos]
	}
	ps->arr[pos] = x;
	ps->size++;
}

//在指定位置之前删除数据
void SLFrase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size );
	for (int i = pos; i < ps->size-1; i++)
	{
		ps->arr[i] = ps -> arr[i + 1];
	}
	ps->size--;
}

//查找数据
int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			//找到了
			return i;
		}
	}
	//没找到
	return -1;
}

test.c

void TestSeqList1()
{
	SL s;
	SLInit(&s);
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPrint(&s);
 
	SLPopBack(&s);
	SLPopBack(&s);
	SLPrint(&s);
 
	SLPopBack(&s);
	SLPopBack(&s);
	SLPopBack(&s);
	SLPopBack(&s);

	//SLPopBack(&s);
	SLPrint(&s);
 
	SLPushBack(&s, 10);
	SLPushBack(&s, 20);
	SLPrint(&s);
 
	SLDestroy(&s);
}
 
int main()
{
	TestSeqList1();
 
	return 0;
}

完结

本次博客到此结束
祝开心每一天~~~
最后觉得博客有帮助，可以点点关注，支持一下，期待下次博客~~~

optimistic_chen
关注
C/C++数据结构练习题[2023-05-08]
code helper
05-08 1万+
目的：字符串是一种基础且广泛使用的数据结构，与字符串相关的题目既可 以考察基本程序设计能力和技巧，也可以考查算法设计能力。 题目：求字符串之间距离 要求：设有字符串 X，称在 X 的头尾及中间插入任意多个空格后构成的新 字符串为 X 的扩展串，如字符串 X 为“abcbcd”，则字符串“abcb□cd”，“□a□bcbcd□” 和“abcb□cd□”都是 X 的扩展串，这里“□”代表空格字符。如果 A1 是字符串 A 的 扩展串，B1 是字符串 B 的扩展串，A1 与 B1 具有相同的长度，那么定义字符串
链表的相关操作（2）
江东小熊熊
11-10 936
/* 给定两个数组A1和B1： 1）将A1和B1中的数据导入链表中，形成链表A2和B2，并打印各自链表元素； 2）将链表A2和B2中的元素各自排序（从大到小），形成链表A3和B3，并打印各自链表元素。 3）合并链表A3，B3，合并后的链表C的元素从大到小排列，并打印链表C。*/ //-----------------------LinkedList.h------------
数据结构初阶——顺序表专题
2302_81486993的博客
05-10 1369
这么做是为了我们后面方便修改代码，如果我们需要把int改为char，那么我们只需要把第一行的int改为char，这样后面的代码中的int就统一改成了char，实现了“一劳永逸”的效果。
初阶数据结构——链表专题——单链表详解
2302_80023639的博客
03-01 909
我们设想一个场景：假如现在有一排连在一起的房间，而我们现在在第一个房间里，每个房间都有一扇通往下一个房间的门，但是上了锁，每个锁都不一样，如下：问：我们如何从第一间房间走到最后一间房间呢？答：在每一间房间里都放上通往下一间房间的钥匙就可以了链表的核心原理就是如此我们的链表里面不仅存着其应该带的数值，还存放着指向下一个节点的地址，地址连着地址，就像一根链子一样把数据都串起来，所以才叫链表至此，我们单链表的相关知识就讲完啦！！接下来为各位带来的是双链表的相关知识。
数据结构——单链表专题
2302_81486993的博客
07-07 1088
这里大家可以看到，我们声明了一个结构体，结构体中的内容就是前面我们所说的节点的组成元素，包括节点自身存储的数据，以及指向下一个节点的指针(这是一个结构体指针)，因为下一个节点依然是一个结构体。这里大家发现，头插代码是比较简单的，上来还是先断言，然后为新插入的节点申请空间，然后我们要让原本的首节点成为新节点中指向下一个位置的节点，最后再让新节点成为新的首节点，这样就完成了头插的任务。这里大家可能发现了它们之间的关系了，我们定义链表实际上就是在定义链表节点的结构，那么下面我们就要来讨论节点的定义方法了。
线性结构——顺序表
yzstudying的博客
05-24 260
顺序表专题 文章目录顺序表专题前言一、遍历顺序表二、移动线性表元素（一）赋值式移动（二）交换式移动1.通过不断的两两交换，让首节点挪到尾节点。从两边向中间渐进式（逆置）移动总结 前言 在这一专题完成顺序表的遍历，移动线性表元素以及增删改查 一、遍历顺序表 示例：有顺序表a={3，2，5，8，4，7，6，9}，遍历三遍。 #include<stdio.h> void printArray(int a[],int n,int k){ for(int i = 0;i<k;++i){
Java数据结构专题——链表（上）
sikuanglan的博客
08-18 755
当下一个结点不为空就继续才往下找，因为是找删除结点的前一个结点位置，这里的判断条件是cur.next.val==key，所以循环条件是cur.next不为空，否则会引发空指针异常，如果能找到返回这个结点，循环结束就代表未找到，出了循环返回null即可。removeallkey的思路和remove很相似，只不过removeallkey要删除所有的key就需要多一层循环，既然要删除所有的key，就需要遍历整个链表找到相应值后删除结点，所以循环结束的条件还是和遍历相同，当cur=null就停下。
数据结构：线性表————单链表专题
2302_76674204的博客
04-12 943
教你一步一步写代码
《数据结构》实验报告（一）——顺序表存储结构及实现
热门推荐
weixin_44197749的博客
11-17 2万+
顺序表存储结构及实现——学生信息管理 一、实验目的 (1) 掌握顺序表的概念及实现方式。 (2) 掌握顺序表的存储结构及主要运算：建立、查找、插入、删除等。 二、实验环境 Windows 10，Microsoft Visual C++ 2010 Express 三、实验内容 1、内容描述 定义一个包含学生信息（学号，姓名，成绩）的顺序表，使其具有如下功能： (1) 逐个输入学生信息，建立信息表； (2) 显示信息表中所有学生的相关信息； (3) 根据姓名进行查找，返回此学生的学号和成绩； (4) 给定一个学
数据结构——图
12-11
通过学习和实践“数据结构——图”这一主题，你可以提高对复杂问题建模的能力，为解决实际问题如网络路由、社交网络分析等打下坚实基础。同时，掌握好图的理论和实现将有助于提升你的编程技能，特别是在算法设计和...
漫话数据结构-双向链表及基本操作.pptx
11-03
本讲座主要探讨了一种特殊的数据结构——双向链表。双向链表是一种线性数据结构，它允许我们在列表中的节点之间进行双向移动，而不仅仅像单链表那样只能从前往后或从后往前。 双向链表的定义： 双向链表是由一系列...
SDUT专题整理——顺序表
BlessingXRY的博客
09-20 599
顺序表应用1：多余元素删除之移位算法 Time Limit: 1000MS Memory Limit: 650KBProblem Description 一个长度不超过10000数据的顺序表，可能存在着一些值相同的“多余”数据元素（类型为整型），编写一个程序将“多余”的数据元素从顺序表中删除，使该表由一个“非纯表”（值相同的元素在表中可能有多个）变成一个“纯表”（值相同的元素在表中只保留第一个）
数据结构（C语言版）——2.1、顺序表实现
weixin_41600504的博客
10-06 974
2.1、顺序表实现 2.1.1、顺序表说明 （1）顺序表（SeqList）即线性表的顺序表示，用一组连续的存储单元依次存储线性表的数据元素。 2.1.2、顺序表的优缺点及适用场合 优点： 方法简单、基于数组、易于实现； 不用为表示结点间的逻辑关系而增加额外的开销； 支持随机存取，可按下标随机访问元素。 缺点： 插入、删除操作时大约移动平均一半的元素，效率较低； 需预先分配足够大的空间，估计过大会浪费，过小会溢出； 存储空间连续，已造成存储空间的“碎片”现象。 适用场合： 适合“较稳定”的线性表，
【数据结构】线段树复杂应用
最新发布
2302_80811345的博客
09-13 1067
随着星际网络的进一步建设和规模的增大，一个新的问题出现在网络工程师面前——地址空间不够用了！原来，星际网络采用了传统的 IPv6 协议，虽然有2128级别的可用地址数量，但面对广袤无垠的宇宙和爆炸式增长的网络用户数，如此庞大的地址空间也面临了用尽的那一天。新的通信协议的研发工作交给了著名的网络科技圣地——西西艾弗星。最终，经过2333年的不懈努力，西西艾弗星的工程师们设计出了一种新的协议——“西西艾弗IP协议”，又称 IPxxaf。在 IPxxaf 协议中，一个地址由n位二进制位组成，其中。
数据结构---非线性--树
2301_80434764的博客
09-13 794
本文将详细介绍树及其变体在计算机科学中的应用及实现。首先，将概述树的基本概念、结构及其实际应用，包括树的表示方法及在各种应用场景中的重要性。接着，深入探讨二叉树的基本概念、特殊类型及其性质，并比较顺序存储和链式存储这两种主要存储结构。 在探讨二叉树的顺序结构及实现时，重点讲解堆的概念与结构，涵盖堆的向上和向下调整算法、建堆的时间复杂度以及堆的插入和删除操作，并讨论堆在排序和Top-K问题中的应用。最后，讨论二叉树的链式结构实现，包括各种遍历方式（如前序、中序、后序和层序遍历）和常见接口。
【数据结构】顺序表的定义和实现
m0_74209563的博客
09-13 577
顺序表是指用的方式实现线性表顺序存储：把的元素存储在的存储单元中，元素之间的关系由存储单元的邻接关系来体现【看到这是否会和我有同样的疑问：顺序表和数组是一样的吗？这个问题可以参考这篇文章的解释】
重头开始嵌入式第三十九天（数据结构 栈）
qq_64792908的博客
09-13 754
栈是一种数据结构，它具有以下特点：1. 只能在一端进行插入和删除操作，这一端被称为栈顶。2. 遵循“后进先出”（Last In First Out，LIFO）的原则。也就是说，最后进入栈的元素最先被弹出。3. 可以用数组或链表来实现。例如，把书一本一本叠放在桌子上，只能从最上面取书或放书，这就类似栈的操作。后放上去的书先被拿走，符合“后进先出”原则。
C语言-数据结构 弗洛伊德算法(Floyd)邻接矩阵存储
BamBoo_Bean的博客
09-13 654
C语言-数据结构 弗洛伊德算法(Floyd)邻接矩阵存储
大学软件工程课堂：数据结构实验——顺序表与链表应用
具体任务是用这两种数据结构实现课本算法2.2——合并两个非递减有序序列，同时分析其时间性能。这不仅锻炼了他们的编程技能，还提升了对算法效率的评估能力。 每个实验报告会由指导教师评阅，评价标准涉及实验目的...
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值