数据结构—动态顺序表

最新推荐文章于 2022-11-05 18:38:01 发布
最新推荐文章于 2022-11-05 18:38:01 发布
阅读量879 收藏 14
点赞数 10
文章标签： 数据结构 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HysteriaD/article/details/127290384
版权

动态顺序表的实现

一、顺序表的概念

*（1）*顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上实现各种功能

*（2）*这里我们注意顺序表之所以有顺序二字就是因为它和数组最大的区别就是要依次存储数据元素（也就是说）要按顺序存储。
而顺序表又可以分成静态顺序表和动态顺序表。

二、静态顺序表（可跳过）

我们首先来创建一个数组，利用几个接口函数来完成对顺序表的完善。而与以往不同的是，接口函数的命名风格是跟着STL走的，代码如下

#define MAX 100
typedef int SLDataType;
typedef struct Seqlist
{
SLDataType a[MAX];
Int size
}SL;

这就是静态数组开始的创建，通过typedef（重定义）将原本复杂的名词Seqlist写成SL。 同时，SLDataType更好的实现以后替换其他类型变量的麻烦。而今天，我们讲的重点是动态顺序表的实现。

三、动态顺序表的动态思路

动态顺序表与静态顺序表在开始建立的时候，由于需要满足满了再扩容的需要，我们会创建一个指针a指向这个数组，在创建一个capacity用来表示数组实际能存储的空间容量是多大。

这里是引用

代码如下

typedef struct Seqlist
{
	SLDataType* a;
	int size;// 表示数组中存储了多少”个“数据
	int capacity; // 数组实际能存储数据的空间容量是多大
}SL;

四、初始化顺序表

在使用顺序表时我们一般先将其初始化，避免后面不必要的麻烦。代码如下

void SeqlistInit(SL* ps)
{
	ps->a = NULL;
	ps->size = ps->capacity = 0;// 初始化
}

五、检查扩容

（1）这是一个动态的顺序表，因此在其数据满的时候我们要将其扩容，这个程序在后面其他的接口函数中也会使用到，因此我们将它单独写出来。此时注意，由于我们第一次已经将capacity初始化为0了，再次进行扩容时，newcapacity不能直接*0 。代码如下

void SeqlistCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;// 扩容
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));// realloc算的是字节数
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);// 这里return是不行的exit直接终止程序了
		}

		ps->a = tmp;
		ps->capacity = newcapacity;
	}
}

（2）在这个代码中我们先判断了capacity是否为0，为0则赋给它一个值，我们这里给它赋了4。扩容我们选择乘2倍（这个无所谓乘多少1.5倍也行，只是2倍是个怎么说嘞，非常合适的这样的一个值，扩小了扩容就会频繁，扩大了，就会造成空间浪费）。
有人会说ps->a为NULL有问题啊。实际上没关系，不用担心，realloc函数的第一个参数如果是空，realloc作用和malloc一样。
（3）在这里面如果开辟失败我们用exit(-1)来结尾，很多时候我们写代码习惯用return-1来终止。而在这里，假如开辟失败，剩下的内容我们就无法进行下去，所以在这里我们用的是exit而不是return。

六、各种功能的实现

6.1 尾插（删）顺序表

1.尾插函数：我们第一步要做的事情就是检查空间是否已满，如果满了就要扩容，这里我们先引用前面增容函数。
将我们要插入的X插入到数组中。由于size是袁旭的个数，同时也是尾部最后一个元素后一个元素的位置。因此可以直接++,代码如下：

void SeqlistPushBack(SL* ps, SLDataType x) // 尾插
{
	 SeqlistCheckCapacity(ps);
	     ps->a[ps->size] = x;
	     ps->size++; 
}

2.尾删函数：，尾插函数成功实现后我们就可以实现尾删函数。尾删函数我们可以将最后一个数改为0，然后再size减减，减减在前或者在后都不影响实际结果。而这里面就有两种方法，代码如下：

void SeqlistPopBack(SL* ps)
{
	
	/*  if (ps->size > 0)
	  {
		//ps->a[ps->size - 1] = 0; 这个不要也没有问题
		ps->size--;
	   }
	*/  // 方法一

	assert(ps->size > 0); //为真继续，为假即<=0就会终止程序，并说明断言失败
	ps->size--;
}

6.2 头插（删）函数

1.头插函数：如图所示，我们要将数组中的元素依次往后诺一个位置，如图（见谅。画图有点抽象）

这里是引用

这里end指向的是size-1的位置，size是数组元素的个数，减一就是指向最后的位置，代码实现如下

void SeqlistPushFront(SL* ps, SLDataType x)
{
	   SeqlistCheckCapacity(ps);
	    // 挪动数据
	     int end = ps->size - 1;
	     while (end >= 0)
	     {
		    ps->a[end + 1] = ps->a[end];
		    --end; // 前置后置都可以
	     }
	     ps->a[0] = x;
	     ps->size++;
    }

2.头删函数：将后一个数据向前挪动，代码如下：

void SeqlistPopFront(SL* ps)
{
	assert(ps->size > 0);
	int begin = 1;               //begin = 0
	while (begin < ps->size)     // size - 1
	{
		ps->a[begin - 1] = ps->a[begin];  // begin begin + 1
		++begin;
	}
	ps->size--;
	// 挪动数据
}

6.3 插入数据

插入数据首先我们应该考虑的是数组空间是否已满以及越界的问题，这里与上文一样有两种方法，我们还是采用断言的方法， 如图所示

这里是引用

代码如下：

void SeqlistInsert(SL* ps, int pos, SLDataType x)
{
	/*   if (pos > ps->size || pos < 0)  越界
	    {
		   printf("pos invalid\n");
		   return;
	    }
	*/      //两种方法
	assert(pos >= 0 && pos <= ps -> size);

	SeqlistCheckCapacity(ps); // 插入考虑扩容
	int end = ps->size - 1;
	// 挪动数据
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[pos] = x;
	ps->size++;
}

事实上，我们在完成插入实现后可以将其应用在气脉你的数组的头插为尾插上面，这样我们就可以将代码改成这样：

void SeqlistPushFront(SL* ps, SLDataType x)
{
	/*    SeqlistCheckCapacity(ps);
	    // 挪动数据
	     int end = ps->size - 1;
	     while (end >= 0)
	     {
		    ps->a[end + 1] = ps->a[end];
		    --end; // 前置后置都可以
	     }
	     ps->a[0] = x;
	     ps->size++;
	*/
	SeqlistInsert(ps, 0, x);
}

像这样，对，没错的。

6.4 删除

删除思路与前面类似，如图

这里是引用

代码的实现如下

void SeqlistErase(SL* ps, int pos)
{
	assert(pos >= 0 && pos < ps->size);

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

6.5 查找

这个相对容易，我i们直接上代码：

int SeqlistFind(SL* ps, SLDataType x)
{
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

6.6 打印

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

七、完整代码

这样，所有的代码我们基本已经实现了，下面是完整代码：
test.c

#include "Seqlist.h"

void TestSeqlist1()
{
	SL s1;
	SeqlistInit(&s1);
    SeqlistPushBack(&s1, 1);
	SeqlistPushBack(&s1, 2);
	SeqlistPushBack(&s1, 3);
	SeqlistPushBack(&s1, 4);
	SeqlistPushBack(&s1, 5);
	SeqlistPrint(&s1);

	SeqlistPopBack(&s1);
	SeqlistPopBack(&s1);
	SeqlistPrint(&s1);

	SeqlistDestory(&s1);
}

void TestSeqlist2()
{
	SL s1;
	SeqlistInit(&s1);
	SeqlistPushBack(&s1, 1);
	SeqlistPushBack(&s1, 2);
	SeqlistPushBack(&s1, 3);
	SeqlistPushBack(&s1, 4);
	SeqlistPushBack(&s1, 5);
	SeqlistPrint(&s1);

	SeqlistPushFront(&s1, 10);
	SeqlistPushFront(&s1, 20);
	SeqlistPushFront(&s1, 30);
	SeqlistPrint(&s1);

	SeqlistPopFront(&s1);
	SeqlistPopFront(&s1);
	SeqlistPrint(&s1);

	SeqlistDestory(&s1);
}

void TestSeqlist3()
{
	SL s1;
	SeqlistInit(&s1);
	SeqlistPushBack(&s1, 1);
	SeqlistPushBack(&s1, 2);
	SeqlistPushBack(&s1, 3);
	SeqlistPushBack(&s1, 4);
	SeqlistPushBack(&s1, 5);
	SeqlistPrint(&s1);

	SeqlistInsert(&s1, 2, 30);
	SeqlistPrint(&s1);

	int pos = SeqlistFind(&s1, 4);
	if (pos != -1)
	{
		SeqlistInsert(&s1, pos, 40);
	}
	SeqlistPrint(&s1);

	SeqlistDestory(&s1);
}

void TestSeqlist4()
{
	SL s1;
	SeqlistInit(&s1);
	SeqlistPushBack(&s1, 1);
	SeqlistPushBack(&s1, 2);
	SeqlistPushBack(&s1, 3);
	SeqlistPushBack(&s1, 4);
	SeqlistPushBack(&s1, 5);
	SeqlistPrint(&s1);

	int pos = SeqlistFind(&s1, 3);
	if (pos != -1)
	{
		SeqlistErase(&s1, pos);
	}
	SeqlistPrint(&s1);
	SeqlistDestory(&s1);
}

enum
{
	PushFront = 1,
	PopFront,
	PushBack,
	PopBack,
	Insert,
	Erase,
	Find,
	Print
};

// 菜单
void Menu()
{
	printf("*********************************\n");
	printf("*****    请选择你的操作:>   *****\n");
	printf("*****  1、头插    2、头删   *****\n");
	printf("*****  3、尾插    4、尾删   *****\n");
	printf("*****  5、插入    6、删除   *****\n");
	printf("*****  7、查找    8、打印   *****\n");
	printf("*****      -1、退出         *****\n");
	printf("*********************************\n");
}

int main()
{
	//TestSeqlist1();
	//TestSeqlist2();
	//TestSeqlist3();
	SL s1;
	SeqlistInit(&s1); // 初始化
	int input = 0;
	int x;
	int pos = 0;
	while (input != -1)
	{
		Menu();
		scanf("%d", &input);
		switch (input)
		{
		case PushFront:
			printf("请选择你要插入的数据，-1结束\n");
			do
			{
				scanf("%d", &x);
				if (x != -1)
				{
					SeqlistPushFront(&s1, x);
				}
			} while (x != -1);
			break;

		case PopFront:
			SeqlistPopFront(&s1);
			break;

		case PushBack:
			printf("请选择你要插入的数据，-1结束\n");
			do
			{
				scanf("%d", &x);
				if (x != -1)
				{
					SeqlistPushBack(&s1, x);
				}
			} while (x != -1);
			break;

		case PopBack:
			SeqlistPopBack(&s1);
			break;

		case Insert:
			printf("请选择你要插入的数据以及插入的位置，-1结束\n");
			do
			{
				scanf("%d %d", &pos, &x);
				if (x != -1)
				{
					SeqlistInsert(&s1, pos, x);
				}
			} while (x != -1);
			break;

		case Erase:
			printf("请选择你要删除的数据，-1结束\n");
			do
			{
				scanf("%d", &x);
				if (x != -1)
				{
					SeqlistErase(&s1, x);
				}
			} while (x != -1);
			break;

		case Find:
			printf("请选择你要查找的数据，-1结束\n");
			do
			{
				scanf("%d", &x);
				if (x != -1)
				{
					printf("找到了，下标为%d\n", SeqlistFind(&s1, x));
				}
				else
				{
					printf("没找到\n");
				}
			} while (x != -1);
			break;

		case Print:
			SeqlistPrint(&s1);
			break;
		default:
			printf("无此选项，请重新选择\n");
			break;
		}
	}
	SeqlistDestory(&s1);
	TestSeqlist4();
	return 0;
}

SeqList.c

#include "Seqlist.h"

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

void SeqlistInit(SL* ps)
{
	ps->a = NULL;
	ps->size = ps->capacity = 0;// 初始化
}

void SeqlistDestory(SL* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}

void SeqlistCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;// 扩容
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));// realloc算的是字节数
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);// 这里return是不行的exit直接终止程序了
		}

		ps->a = tmp;
		ps->capacity = newcapacity;
	}
}

void SeqlistPushBack(SL* ps, SLDataType x) // 尾插
{
	/*   SeqlistCheckCapacity(ps);
	     ps->a[ps->size] = x;
	     ps->size++; 
	*/
	SeqlistInsert(ps, ps->size, x);
}

void SeqlistPopBack(SL* ps)
{
	
	/*  if (ps->size > 0)
	  {
		//ps->a[ps->size - 1] = 0; 这个不要也没有问题
		ps->size--;
	   }
	*/  // 方法一

	assert(ps->size > 0); //为真继续，为假即<=0就会终止程序，并说明断言失败
	ps->size--;
}

void SeqlistPushFront(SL* ps, SLDataType x)
{
	/*    SeqlistCheckCapacity(ps);
	    // 挪动数据
	     int end = ps->size - 1;
	     while (end >= 0)
	     {
		    ps->a[end + 1] = ps->a[end];
		    --end; // 前置后置都可以
	     }
	     ps->a[0] = x;
	     ps->size++;
	*/
	SeqlistInsert(ps, 0, x);
}

void SeqlistPopFront(SL* ps)
{
	assert(ps->size > 0);
	int begin = 1;               //begin = 0
	while (begin < ps->size)     // size - 1
	{
		ps->a[begin - 1] = ps->a[begin];  // begin begin + 1
		++begin;
	}
	ps->size--;
	// 挪动数据
}

int SeqlistFind(SL* ps, SLDataType x)
{
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

void SeqlistInsert(SL* ps, int pos, SLDataType x)
{
	/*   if (pos > ps->size || pos < 0)  越界
	    {
		   printf("pos invalid\n");
		   return;
	    }
	*/      //两种方法
	assert(pos >= 0 && pos <= ps -> size);

	SeqlistCheckCapacity(ps); // 插入考虑扩容
	int end = ps->size - 1;
	// 挪动数据
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[pos] = x;
	ps->size++;
}

void SeqlistErase(SL* ps, int pos)
{
	assert(pos >= 0 && pos < ps->size);

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

SeqList.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
//  #define N 1000
typedef int SLDataType; 

// 动态顺序表
typedef struct Seqlist
{
	SLDataType* a;
	int size;// 表示数组中存储了多少”个“数据
	int capacity; // 数组实际能存储数据的空间容量是多大
}SL;

// 静态特点：如果满了就不让插入 缺点：无法确定多少合适
// N给小了不够用， N给打了浪费
// 
//接口函数 -- 命名风格是跟着STL走的

void SeqlistPrint(SL* ps);// 打印顺序表
void SeqlistInit(SL* ps);// 初始化顺序表
void SeqlistDestory(SL* ps);// 将顺序表销毁
void SeqlistCheckCapacity(SL* ps);// 检查数据增容
void SeqlistPushBack(SL* ps, SLDataType x); //尾插
void SeqlistPopBack(SL* ps); //尾删
void SeqlistPushFront(SL* ps, SLDataType x); // 头插
void SeqlistPopFront(SL* ps); // 头删 
int SeqlistFind(SL* ps, SLDataType x);// 查找这个值的位置，找到了返回X下标位置，没有返回-1
void SeqlistInsert(SL* ps, int pos, SLDataType x);//在指定pos下标位置插入
void SeqlistErase(SL* ps, int pos);//删除pos位置的数据

八、总结

关于顺序表的介绍就到这里了。可以说顺序表虽然按照顺序存储有它自己的优势，但这种特性又给它带来了麻烦，例如说O（N） 啥的，在增删过程中效率的不高等等。

在今后的文章中我也给大家准备了很多我个人原创的文章以及见解（有很多我不理解的地方欢迎大家在评论区告诉我） 。期待的话请多多为我投票吧（bushi) ，搞错了，期待的话请给我一键三连吧。

这里是引用

HysteriaD
关注
  • 10
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
动态顺序表(C语言)
学代码的咸鱼的博客
03-28 2858
轻松带你搞定顺序表！
数据结构之动态顺序表（附带完整程序）
2301_77203593的博客
07-26 763
int age;int height;} Student;//Student类型的数组 int length;//元素的有效个数 int listsize;//最多容纳多少个元素 } SqList;5int age;int height;} Student;//Student类型的数组 int length;//元素的有效个数 int listsize;//最多容纳多少个元素 } SqList;2int age;int height;} Student;
【数据结构】动态顺序表
Dooo_yh的博客
11-27 640
目录一、数据结构前言1. 数据结构：==数据和数据间的组织方式==2. 程序（数据和函数组成） = 数据结构 + 算法3. 时间复杂度4. 空间复杂度二、顺序表1.顺序表的两种开辟方式 一、数据结构前言 1. 数据结构：数据和数据间的组织方式 2. 程序（数据和函数组成） = 数据结构 + 算法 3. 时间复杂度 概念：一个算法程序的某一语句的执行次数（而不是该算法的运行时间）； 时间复杂度是一个函数 T (n) ，为方便一般使用大O表示法标准：渐进时间复杂度 O (f (n))； 常见算法时间复
数据结构-动态顺序表的实现（含全部代码）
qq_45967533的博客
03-07 1727
本篇的内容是使用C语言实现一个动态顺序表 文章目录顺序表的概念及结构动态顺序表的接口实现初始化接口销毁接口打印接口检查是否增容接口尾插接口头插接口尾删接口头删接口查找接口在指定位置插入元素接口删除指定位置数据接口修改指定位置元素接口动态顺序表代码 顺序表的概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 我们可以把顺序表理解为一个数组 顺序表一般可以分为： 静态顺序表：使用定长数组存储。 动态顺序表：使用动态开辟的数组存储。
数据结构动态顺序表.zip
02-04
数据结构动态顺序表是计算机科学中的一个重要概念，它在编程中有着广泛的应用。动态顺序表是一种灵活的数组，它的大小可以在运行时动态地改变。在C语言中实现动态顺序表，通常涉及到内存管理、数组的增长策略以及...
数据结构实验 顺序表和链表
10-08
数据结构实验 顺序表和链表中，我们可以学习到顺序表和链表的基本操作，包括创建、初始化、销毁、求长、判空、输出、获取元素、插入元素和删除元素等操作。下面是对顺序表和链表的详细介绍： 顺序表是一种线性表，...
数据结构C++顺序表
03-04
本主题聚焦于一种基础且重要的数据结构——顺序表，尤其关注如何在C++中实现这一概念。 顺序表是一种线性数据结构，其中元素在内存中按顺序存储。在C++中，我们可以使用数组来实现顺序表。这种结构的优点是访问速度...
数据结构顺序表操作示例
09-04
数据结构中的顺序表是一种基本的线性数据结构，它的特点是所有元素存储在一块连续的内存空间中，元素之间的逻辑顺序与物理顺序一致。在顺序表上进行操作时，主要有插入和删除等基本操作。 1. **插入操作**： 在...
PTA—C语言数据结构：顺序表.ppt
10-11
本文件"PTA—C语言数据结构：顺序表.ppt"是针对PTA（Programming Training Assistant）平台上数据结构课程的一个教学资源，专门探讨了顺序表这一基本数据结构，并提供了相关练习题的解答。下面我们将详细讨论顺序表...
数据结构动画演示完整版
08-29
数据结构动画演示完整版，用动画看起来简单明了，更容易理解数据结构。
动态顺序表
xuruhua的博客
04-18 565
PseqlistD.htypedef int DataType;typedef unsigned int size_t;typedef struct SeqListD{ DataType* _array; size_t _capacity; // 底层空间的大小  size_t _size; // 有效元素的个数 }SeqListD, *PSeqListD void SeqListDInit(PS...
数据结构之顺序表（动态数组）
boy_of_god的博客
08-22 1483
线性表 线性表的顺序存储(顺序表) 线性表的链式存储（链表） 线性表的定义： 1、线性表(List)是零个或多个数据元素的集合 2、线性表中的数据元素之间是有顺序的 3 、线性表中的数据元素的类型必须相同 4、线性表中的数据元素个数是有限的 1、顺序表（动态数组） 1.1、定义： ...
C/C++数据结构之动态数组篇
qq_63883017的博客
11-05 8817
手把手带你从初识动态数组到手写简单版本的c++vector容器
买什么数据结构与算法，这里有：动态图解十大经典排序算法（含JAVA代码实现）
勇往直前的专栏
11-25 479
上篇的动图数据结构反响不错，这次来个动图排序算法大全。数据结构与算法，齐了。 几张动态图捋清Java常用数据结构及其设计原理 本文将采取动态图+文字描述+正确的java代码实现来讲解以下十大排序算法： 冒泡排序 选择排序 插入排序 希尔排序 归并排序 快速排序 堆排序 计数排序 桶排序 基数排序   0、排序算法说明 0.1 排序的定义 对一序列对象根据某个关...
数据结构——顺序表（动态）
z_freedom的博客
03-14 1031
本文是对静态顺序表的理解 （这只是在下的粗浅理解，不足的地方还请谅解，欢迎留言提出，后期理解深入后会加以改进） 上一篇对静态顺序表的理解，这一篇是对动态顺序表的理解，相对于静态属性表，动态的顺序表就是能够开辟内存， 静态的是一开始就开辟一个固定容量的数组，满了就不能在装了，而动态的在满了之后还可以进行扩容。 静态顺序表链接： http://blog.csdn.net/
顺序表（动态）
L_R
09-13 365
上篇博客介绍了静态顺序表的增删查改以及排序，我们知道了: 静态顺序表的长度是固定的，但是如果我们在使用顺序表是并不知道顺序表的长度，或者在使用过程中，顺序表的长度不够了，难道我们要重新再创建一个新的顺序表吗？这样显然是很麻烦的。所以本篇博客将讨论动态顺序表。 那么动态顺序表和静态顺序表又有什么区别呢？ 上面我们提到了静态顺序表的局限性，那么动态顺序表很有效的解决了静态的不足之处，当在使用顺序...
顺序表的存储结构采用动态数组的方式实现（数据结构C语言版）
luo_si_yuan的博客
11-05 1542
①顺序表的动态数组实现 首先先要创建一个顺序表给它分配预先定义好的“#define LIST_INIT_SIZE 100”空间长度并且将内容置为空。 ②输入输出数据，这部分功能的实现就要用到 前面结构中定义的“ElemType *elem”指针 来实现动态数组的遍历 输入或输出 输入：scanf("%d",L.elem+i);注意：要确定输入长度 输出：printf("%d\n",*(L.el...
动态顺序表构建——增、删、查、改、自动扩容、功能的实现
qq_63943454的博客
03-27 768
在数据结构的学习中，顺序表是我们见到的第一个新的数据结构。是我们必须掌握的数据结构之一，下面我们来学习一下顺序表。 1.动态顺序表的主要结构 （1）顺序表它是类似于数组的可以存储数据的，他是具有n个相同的数据元素的有限序列，物理结构是连续的，逻辑结构也是连续的，这里的物理结构连续主要体现在内存中是连续，在内存中一个接着一个。而在物理结构上连续在，逻辑结构上一定也是连续的。而且功能上我们可以让他实现自定扩容；这也是顺序表和数组的最大区别。我们在实现顺序表的时候也是紧挨着这两个特点来实现的。 #defi
数据结构动态顺序表的初始化
最新发布
03-13
动态顺序表是一种数据结构，它可以根需要动态地调整存储空间的大小。初始化一个动态顺序表过程如下： 1. 首先，需要定义一个结构体来表示动态顺序表，该结构体包含两个成员变量：data（用于存储数据元素的数组）和...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值