数据结构之顺序表（动态数组）

最新推荐文章于 2025-07-09 22:22:24 发布
原创 最新推荐文章于 2025-07-09 22:22:24 发布 · 2.6k 阅读 · 15 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了线性表的顺序存储结构——顺序表，包括其定义、算法实现，如初始化、判断是否满、追加、判断是否为空、输出数组、求容量和长度、插入、删除、查找、排序等操作，并提供了相应的代码实现和应用说明。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

线性表

  • 线性表的顺序存储(顺序表)
  • 线性表的链式存储（链表）
    线性表的定义：
  • 1、线性表(List)是零个或多个数据元素的集合
  • 2、线性表中的数据元素之间是有顺序的
  • 3 、线性表中的数据元素的类型必须相同
  • 4、线性表中的数据元素个数是有限的

1、顺序表（动态数组）

1.1、定义：

这里写图片描述

1.2、算法

  • 1、效果数组变量pBase指向一些后，数组里面不再是垃圾值
    void InitArray(struct Array pArr,int capacity);*

  • 2、判断是否为满
    bool IsFull(struct Array pArr);*

  • 3、追加不满时追加
    void AppendArray(struct Array pArr,int val);*

  • 4、判断数组是否为空
    bool IsEmpty(struct Array pArr);*

  • 5、输出数组的中的数据
    void ShowArray(struct Array pArr);*

  • 6、计算数组的容量
    int CapacityArray(struct Array pArr);*

  • 7、计算素组的长度有效元素的个数
    int LengthArray(struct Array pArr);*

  • 8、插入 pos的值是从1开始即下标为0时是第一个元素
    bool InsertArray(struct Array pArr,int pos,int val);*

  • 9、删除通过元素的位置
    *bool DeleteByPosArray(struct Array pArr,int pos,int *val); **

  • 10、查找返回元素的下标
    int FindPosArray(struct Array pArr,int val);*

  • 11、删除通过值
    bool DeleteByvalueArray(struct Array pArr,int val);*

  • 12、翻转
    void InversionArray(struct Array pArr);*

  • 13、升序
    void SortArray(struct Array pArr);*

  • 14、清空数组
    void ClearArray(struct Array pArr);*

  • 15、释放
    void DestoryArray(struct Array pArr);*

1.3实现

1.3.0定义数据类型
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
struct Array
{
   
   
	int* pBase;
	int len;//当前数组有效元素的个数
	int capacity;//数组的容量capacity
};
void test()//测试函数
{
   
   
    return 0;
}


int main()
{
   
   
    test();
	return 0;
}
1.3.1初始化
1.3.1.0思想
  • 1、申请一块内存空间
  • 2、使pArr->pBase指向那块内存空间
  • 3、数组的长度置为零，容量由用户决定
1.3.1.1 功能代码：
void InitArray(struct Array* pArr,int capacity)//效果数组变量pBase指向一数据些后，数组里面不再是垃圾值，并且设定数组的长度
{
   
   
    pArr->pBase = (int*)malloc(sizeof(int)*capacity);
	if(NULL == pArr->pBase)//判断内存是否分配成功
	{
   
   
		printf("内存分配失败");
		exit(-1);
	}
	pArr->capacity = capacity;
	pArr->len = 0;
    return ;//终止此函数
}
1.3.1.2 代码实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
void InitArray(struct Array* pArr,int capacity);//效果数组变量pBase指向一些后，数组里面不再是垃圾值
struct Array
{
   
   
	int* pBase;
	int len;//当前数组有效元素的个数
	int capacity;//数组的容量capacity
};
void test()//测试函数
{
   
   
    return 0;
}


int main()
{
   
   
    test();
	return 0;
}
//数组的初始化
void InitArray(struct Array* pArr,int capacity)//效果数组变量pBase指向一数据些后，数组里面不再是垃圾值，并且设定数组的长度
{
   
   
    pArr->pBase = (int*)malloc(sizeof(int)*capacity);
	if(NULL == pArr->pBase)//判断内存是否分配成功
	{
   
   
		printf("内存分配失败");
		exit(-1);
	}
	pArr->capacity = capacity;
	pArr->len = 0;
    return ;//终止此函数
}
1.3.2判断是否满
1.3.2.0思想
  • 数组有效元素的个数是否等于数组的容量
    pArr->capacity == pArr->len
1.3.2.1 功能代码：
bool IsFull(struct Array* pArr)//判断是否为满
{
   
   
	if(pArr->capacity ==pArr->len)//数组长度和有效个数相同
		return true;
	else
		return false;
}
1.3.2.2代码实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
void InitArray(struct Array* pArr,int capacity);//效果数组变量pBase指向一些后，数组里面不再是垃圾值
bool IsFull(struct Array* pArr);//判断是否为满
struct Array
{
	int* pBase;
	int len;//当前数组有效元素的个数
	int capacity;//数组的容量capacity
};
void test()//测试函数
{
    return ;
}


int main()
{
    test();
	return 0;
}
//数组的初始化
void InitArray(struct Array* pArr,int capacity)//效果数组变量pBase指向一数据些后，数组里面不再是垃圾值，并且设定数组的长度
{
    pArr->pBase = (int*)malloc(sizeof(int)*capacity);
	if(NULL == pArr->pBase)//判断内存是否分配成功
	{
		printf("内存分配失败");
		exit(-1);
	}
	pArr->capacity = capacity;
	pArr->len = 0;
    return ;//终止此函数
}
//判断是否为满
bool IsFull(struct Array* pArr)//判断是否为满
{
	if(pArr->capacity ==pArr->len)//数组长度和有效个数相同
		return true;
	else
		return false;
}
1.3.3追加
1.3.3.0思想
1.3.3.1 功能代码：
void AppendArray(struct Array* pArr,int val)//追加  条件不满时追加
{
   
   
	if(IsFull(pArr))//满了就返回一个false程序运行结束
	{
   
   
		printf("数组已经满了没法追加");
		return ;
	}
	pArr->pBase[pArr->len] = val;
	(pArr->len)++;
	return ;
	/*有个难点len再初始函数中是零*/
}
1.3.3.2代码实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
void InitArray(struct Array* pArr,int capacity);//效果数组变量pBase指向一些后，数组里面不再是垃圾值
bool IsFull(struct Array* pArr);//判断是否为满
void AppendArray(struct Array* pArr,int val);//追加不满时追加
struct Array
{
   
   
	int* pBase;
	int len;//当前数组有效元素的个数
	int capacity;//数组的容量capacity
};
void test()//测试函数
{
   
   
    return ;
}


int main()
{
   
   
    test();
	return 0;
}
//数组的初始化
void InitArray(struct Array* pArr,int capacity)//效果数组变量pBase指向一数据些后，数组里面不再是垃圾值，并且设定数组的长度
{
   
   
    pArr->pBase = (int*)malloc(sizeof(int)*capacity);
	if(NULL == pArr->pBase)//判断内存是否分配成功
	{
   
   
		printf("内存分配失败");
		exit(-1);
	}
	pArr->capacity = capacity;
	pArr->len = 0;
    return ;//终止此函数
}
//判断是否为满
bool IsFull(struct Array* pArr)//判断是否为满
{
   
   
	if(pArr->capacity ==pArr->len)//数组长度和有效个数相同
		return true;
	else
		return false;
}
//追加
void AppendArray(struct Array* pArr,int val)//追加  条件不满时追加
{
   
   
	if(IsFull(pArr))//满了就返回一个false程序运行结束
	{
   
   
		printf("数组已经满了没法追加");
		return ;
	}
	pArr->pBase[pArr->len] = val;
	(pArr->len)++;
	return ;
	/*有个难点len再初始函数中是零*/
}
1.3.4判断是否为空
1.3.4.0思想
  • 判断数组的长度是否等于零
    0 == pArr->len
1.3.2.1功能代码：
bool IsEmpty(struct Array* pArr)//判断有效元素个数是否为0
{
   
   
	if(0 == pArr->len)
		return true;
	else
		return false;
}
1.3.4.2代码实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
void InitArray(struct Array* pArr,int capacity);//效果数组变量pBase指向一些后，数组里面不再是垃圾值
bool IsFull(struct Array* pArr);//判断是否为满
void AppendArray(struct Array* pArr,int val);//追加不满时追加
bool IsEmpty(struct Array* pArr);//判断数组是否为空
struct Array
{
	int* pBase;
	int len;//当前数组有效元素的个数
	int capacity;//数组的容量capacity
};
void test()//测试函数
{
    return ;
}


int main()
{
    test();
	return 0;
}
//数组的初始化
void InitArray(struct Array* pArr,int capacity)//效果数组变量pBase指向一数据些后，数组里面不再是垃圾值，并且设定数组的长度
{
    pArr->pBase = (int*)malloc(sizeof(int)*capacity);
	if(NULL == pArr->pBase)//判断内存是否分配成功
	{
		printf("内存分配失败");
		exit(-1);
	}
	pArr->capacity = capacity;
	pArr->len = 0;
    return ;//终止此函数
}
//判断是否为满
bool IsFull(struct Array* pArr)//判断是否为满
{
	if(pArr->capacity ==pArr->len)//数组长度和有效个数相同
		return true;
	else
		return false;
}
//追加
void AppendArray(struct Array* pArr,int val)//追加  条件不满时追加
{
	if(IsFull(pArr))//满了就返回一个false程序运行结束
	{
		printf("数组已经满了没法追加");
		return ;
	}
	pArr->pBase[pArr->len] = val;
	(pArr->len)++;
	return ;
	/*有个难点len再初始函数中是零*/
}
//判断数组是否为空
bool IsEmpty(struct Array* pArr)//判断有效元素个数是否为0
{
	if(0 == pArr->len)
		return true;
	else
		return false;
}
1.3.5输出数组
1.3.5.0思想
  • 1、判断数组是否为空，空则返回
  • 2、遍历数组知道循环变量小于数组的有效元素的个数(len-1为数组最后一个值的下标)
    i = 0;i < pArr->len; i++
1.3.5.1功能代码
void ShowArray(struct Array* pArr)//输出数组的中的数据
{
   
   
	int i;
	if(NULL == pArr)
		return ;//健壮性
	if(IsEmpty(pArr))
	{
   
   
		printf("动态数组为空");
		return;//退出函数
	}
	else
	{
   
   
		for(i = 0;i < pArr->len;i++)//有效元素个数为1时它的下标为0
			printf("第%d个元素即下标为%d的元素值为 %d\n",i+1,i,pArr->pBase[i]);
		printf("\n");
	}
1.3.5.2代码实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
void InitArray(struct Array* pArr,int capacity);//效果数组变量pBase指向一些后，数组里面不再是垃圾值
bool IsFull(struct Array* pArr);//判断是否为满
void AppendArray(struct Array* pArr,int val);//追加不满时追加
bool IsEmpty(struct Array* pArr);//判断数组是否为空
void ShowArray(struct Array* pArr);//输出数组的中的数据
struct Array
{
	int* pBase;
	int len;//当前数组有效元素的个数
	int capacity;//数组的容量capacity
};
void test()//测试函数
{
	struct Array arr;
	int i ;
	InitArray(&arr,10);
	for(i = 5;i<10;i++)
	{
		AppendArray(&arr,i);
	}
	printf("======判断数组是否为空======\n\n");
	if(IsEmpty(&arr))
		printf("数组为空\n");
	else
		printf("数组不为空\n");
	printf("======打印数组中的元素======\n\n");
	ShowArray(&arr);
    return ;
}


int main()
{
    test();
	return 0;
}
void InitArray(struct Array* pArr,int capacity)//效果数组变量pBase指向一数据些后，数组里面不再是垃圾值，并且设定数组的长度
{
    pArr->pBase = (int*)malloc(sizeof(int)*capacity);
	if(NULL == pArr->pBase)//判断内存是否分配成功
	{
		printf("内存分配失败");
		exit(-1);
	}
	pArr->capacity = capacity;
	pArr->len = 0;
    return ;//终止此函数
}
//判断是否为满
bool IsFull(struct Array* pArr)//判断是否为满
{
    if(NULL == pArr)
		return false;//健壮性
	if(pArr->capacity ==pArr->len)//数组长度和有效个数相同
	{
		return true;
	}
	else
	{
		return false;
	}
}
//追加
void AppendArray(struct Array* pArr,int val)//追加  条件不满时追加
{   if(NULL == pArr)
	    return ;//健壮性
	if(IsFull(pArr))//满了就返回一个false程序运行结束
	{
		printf("数组已经满了没法追加");
		return ;
	}
	pArr->pBase[pArr->len] = val;
	(pArr->len)++;
	return ;
	/*有个难点len再初始函数中是零*/
}
//判断数组是否为空
bool IsEmpty(struct Array* pArr)//判断有效元素个数是否为0
{    
    if(NULL == pArr)
		return -1;//健壮性
	if(0 == pArr->len)
		return true;
	else
		return false;
}
void ShowArray(struct Array* pArr)//输出数组的中的数据
{
	int i;
	if(NULL == pArr)
		return ;//健壮性
	if(IsEmpty(pArr))
	{
		printf("动态数组为空");
		return;//退出函数
	}
	else
	{
		for(i = 0;i < pArr->len;i++)//有效元素个数为1时它的下标为0
			printf("第%d个元素即下标为%d的元素值为 %d\n",i+1,i,pArr->pBase[i]);
		printf("\n");
	}

}

运行结果：
这里写图片描述

1.3.6求数组的容量
1.3.6.0思想
  • 返回数组的容量
    return pArr->capacity;
1.3.6.1功能代码
int CapacityArray(struct Array* pArr)//计算数组的容量
{
   
   
	if(NULL == pArr)
		return -1;//健壮性
	return pArr->capacity;
}
1.3.6.2代码实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
void InitArray(struct Array* pArr,int capacity);//效果数组变量pBase指向一些后，数组里面不再是垃圾值
bool IsFull(struct Array* pArr);//判断是否为满
void AppendArray(struct Array* pArr,int val);//追加不满时追加
bool IsEmpty(struct Array* pArr);//判断数组是否为空
void ShowArray(struct Array* pArr);//输出数组的中的数据
int CapacityArray(struct Array* pArr);//计算数组的容量
int LengthArray(struct Array* pArr);//计算素组的长度有效元素的个数
struct Array
{
	int* pBase;
	int len;//当前数组有效元素的个数
	int capacity;//数组的容量capacity
};
void test()//测试函数
{
	struct Array arr;
	int i,c;
	InitArray(&arr,10);
	for(i = 5;i<10;i++)
	{
		AppendArray(&arr,i);
	}
	printf("======判断数组是否为空======\n\n");
	if(IsEmpty(&arr))
		printf("数组为空\n");
	else
		printf("数组不为空\n");
	printf("======打印数组中的元素======\n\n");
	ShowArray(&arr);
	printf("======数组的容量======\n\n");
	c = CapacityArray(&arr);
	printf("数组的容量为: %d\n",c);
    return ;
}


int main()
{
    test();
	return 0;
}
void InitArray(struct Array* pArr,int capacity)//效果数组变量pBase指向一数据些后，数组里面不再是垃圾值，并且设定数组的长度
{
    pArr->pBase = (int*)malloc(sizeof(int)*capacity);
	if(NULL == pArr->pBase)//判断内存是否分配成功
	{
		printf("内存分配失败");
		exit(-1);
	}
	pArr->capacity = capacity;
	pArr->len = 0;
    return ;//终止此函数
}
//判断是否为满
bool IsFull(struct Array* pArr)//判断是否为满
{
    if(NULL == pArr)
		return false;//健壮性
	if(pArr->capacity ==pArr->len)//数组长度和有效个数相同
	{
		return true;
	}
	else
	{
		return false;
	}
}
//追加
void AppendArray(struct Array* pArr,int val)//追加  条件不满时追加
{   if(NULL == pArr)
	    return ;//健壮性
	if(IsFull(pArr))//满了就返回一个false程序运行结束
	{
		printf("数组已经满了没法追加");
		return ;
	}
	pArr->pBase[pArr->len] = val;
	(pArr->len)++;
	return ;
	/*有个难点len再初始函数中是零*/
}
//判断数组是否为空
bool IsEmpty(struct Array* pArr)//判断有效元素个数是否为0
{    
    if(NULL == pArr)
		return -1;//健壮性
	if(0 == pArr->len)
		return true;
	else
		return false;
}
void ShowArray(struct Array* pArr)//输出数组的中的数据
{
	int i;
	if(NULL == pArr)
		return ;//健壮性
	if(IsEmpty(pArr))
	{
		printf("动态数组为空");
		return;//退出函数
	}
	else
	{
		for(i = 0;i < pArr->len;i++)//有效元素个数为1时它的下标为0
			printf("第%d个元素即下标为%d的元素值为 %d\n",i+1,i,pArr->pBase[i]);
		printf("\n");
	}

}
int CapacityArray(struct Array* pArr)//计算数组的容量
{
	if(NULL == pArr)
		return -1;//健壮性
	return pArr->capacity;
}

运行结果：
这里写图片描述

1.3.7求数组的长度
1.3.7.0思想
  • 返回数组的长度
    return pArr->len;
1.3.7.1功能代码
int LengthArray(struct Array* pArr)//计算素组的长度有效元素的个数
{
   
   
	if(NULL == pArr)
		return -1;//健壮性
	return pArr->len;
}
1.3.7.2代码实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
void InitArray(struct Array* pArr,int capacity);//效果数组变量pBase指向一些后，数组里面不再是垃圾值
bool IsFull(struct Array* pArr);//判断是否为满
void AppendArray(struct Array* pArr,int val);//追加不满时追加
bool IsEmpty(struct Array* pArr);//判断数组是否为空
void ShowArray(struct Array* pArr);//输出数组的中的数据
int CapacityArray(struct Array* pArr);//计算数组的容量
int LengthArray(struct Array* pArr);//计算素组的长度有效元素的个数
struct Array
{
   
   
	int* pBase;
	int len;//当前数组有效元素的个数
	int capacity;//数组的容量capacity
};
void test()//测试函数
{
   
   
	struct Array arr;
	int i,c;
	InitArray(&arr,10);
	for(i = 5;i<10;i++)
	{
   
   
		AppendArray(&arr,i);
	}
	printf("======判断数组是否为空======\n\n");
	if(IsEmpty(&arr))
		printf("数组为空\n");
	else
		printf("数组不为空\n");
	printf("======打印数组中的元素======\n\n");
	ShowArray(&arr);
	printf("======数组的容量======\n\n");
	c = CapacityArray(&arr);
	printf("数组的容量为: %d\n",c);
	printf("======数组的长度======\n\n");
	printf("数组的长度为: %d\n",LengthArray(&arr));
    return ;
}


int main()
{
   
   
    test();
	return 0;
}
void InitArray(struct Array* pArr,int capacity)//效果数组变量pBase指向一数据些后，数组里面不再是垃圾值，并且设定数组的长度
{
   
   
    pArr->pBase = (int*)malloc(sizeof(int)*capacity);
	if(NULL == pArr->pBase)//判断内存是否分配成功
	{
   
   
		printf("内存分配失败");
		exit(-1);
	}
	pArr->capacity = capacity;
	pArr->len = 0;
    return ;//终止此函数
}
//判断是否为满
bool IsFull(struct Array* pArr)//判断是否为满
{
   
   
    if(NULL == pArr)
		return false;//健壮性
	if(pArr->capacity ==pArr->len)//数组长度和有效个数相同
	{
   
   
		return true;
	}
	else
	{
   
   
		return false;
	}
}
//追加
void AppendArray(struct Array* pArr,int val)//追加  条件不满时追加
{
   
      if(NULL == pArr)
	    return ;//健壮性
	if(IsFull(pArr))//满了就返回一个false程序运行结束
	{
   
   
		printf("数组已经满了没法追加");
		return ;
	}
	pArr->pBase[pArr->len] = val;
	(pArr->len)++;
	return ;
	/*有个难点len再初始函数中是零*/
}
//判断数组是否为空
bool IsEmpty(struct Array* pArr)//判断有效元素个数是否为0
{
最低0.47元/天 解锁文章

200万优质内容无限畅学
【数据结构】动态数组
m0_50987960的博客
11-15 2996
动态数组主要方法的创建以及JVM中ArrayList的使用
【数据结构】顺序表
m0_74091744的博客
04-05 4418
本篇博客我们来总结下线性表中的顺序表有关知识，并通过C语言代码实现出一个顺序表若有问题 评论区见感兴趣就关注一下吧。
动态数组实现顺序表
m0_61925333的博客
04-19 847
Java数据结构入门，使用动态数组实现顺序表
数组 -（动态数组）
最新发布
m0_54467592的博客
07-09 1006
在计算机科学中，数组是由一组元素（值或变量）组成的数据结构，每个元素有至少一个索引或键来标识；因为数组内的元素是的，所以数组中元素的地址，可以通过其索引计算出来。例如：知道了数组的起始地址BaseAddress，就可以由公式BaseAddressi∗size计算出索引i元素的地址isizeint4double8已知 array 的的起始地址是 0x7138f94c8，那么元素 3 的地址是什么？
顺序表（动态数组）
程序员的时光
12-27 809
一、动态数组的框架搭建 1.先添加DynamicAyyar.h头文件，01动态数组.c源文件（有主函数）和DynamicAray.c源文件（没有主函数）； 2.在DynamicAyyar.h添加以下内容： 动态数组的结构体； 对结构体进行操作的一系列函数； #ifndef DYNAMIC_ARRAY_H #define DYNAMIC_ARRAY_H #include&lt;st...
顺序表——动态数组
wlw__的博客
11-06 609
顺序表一.顺序表1.什么是顺序表？2.顺序表的用途二.用代码实现一个顺序表1.打印顺序表2.获取顺序表的长度(有效数据)3.添加元素4.查找元素5.查找元素对应的位置6.通过索引找元素7.修改元素8.通过元素来删除9.清空顺序表三.顺序表完整代码TextMyArrayList 一.顺序表 1.什么是顺序表？ 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数 据的增删查改 顺序表一般可以分为： 静态顺序表：使用定长数组存储。 动态顺序表：使用动态开辟的
顺序链表，动态数组实现
weixin_30736301的博客
09-27 118
//SeqList.h //顺序表类的定义 #ifndef SEQLIST_H#define SEQLIST_H #include <iostream>using namespace std; #define true 1#define false 0 template<class Type> //模板定义class SeqList...
顺序表和数组（易混淆），线性表，链表的区别与联系 数组和链表.pdf
04-18
数据结构基础知识概述 本节内容将对顺序表、数组、线性表、链表的概念和...数据结构的基础知识包括逻辑结构、物理结构、线性表、顺序表、数组、链表等概念。只有牢固掌握这些基础知识，才能更好地理解和应用数据结构。
Java数据结构篇-链表与数组实现栈.pptx.pptx
12-19
在这个话题中，我们将重点关注两种常见的数据结构——链表和数组，并探讨它们如何被用来实现栈这一特定的抽象数据类型。 栈是一种线性数据结构，遵循后进先出（LIFO）的原则，意味着最后进入的元素最先被移出。栈的...
顺序表的数组形式和链表形式 数组和链表.pdf
04-18
顺序表是一种基本的数据结构，它可以用数组或链表来实现。数组形式的顺序表将元素存储在连续的内存空间中，而链表形式的顺序表将元素存储在离散的内存空间中，通过指针来连接各个元素。 数组形式的顺序表： 在数组...
数据结构顺序表、链表和数组是逻辑结构还是物理（存储）结构？ 数组和链表.pdf
04-18
数据结构顺序表、链表和数组是逻辑结构还是物理（存储）结构？ 数据结构是计算机科学中的一门重要学科，它研究的是计算机中数据的组织、存储和处理方式。数据结构可以分为逻辑结构和物理结构两种。 逻辑结构是指...
数据结构--顺序表（数组）
smallEngineer的博客
06-30 415
#include<stdio.h> #include<stdlib.h> #define max 100 typedef int DataType; typedef struct { DataType list[max]; int length; }seqlist; void Initlist(seqlist *L) { L->length=0; } int...
数据结构---动态数组
qq_51647149的博客
05-07 1914
数据结构之动态数组的实现
数据结构：动态数组
soulmate______的博客
04-08 453
数组 数组的定义：数组是具有一定顺序关系的若干对象组成的集合，组成数组的对象称为数组元素 int[,] a = new int[2, 3]; //定义一个两行散列的数组 //静态数组 int[][] b = new int[2][]; //定义行数，列数可变 数组名表示群体的共性，即具有同一种数据类型 下标表示个体的个性，即各自占有独立的单元 数组的存储 n维数组的定义 ...
数据结构——动态数组
Wiki~
11-04 915
数据结构——动态数组 文章目录动态数组Code（扩容）测试Code（缩容）测试 在上一节我们讲述了静态数组的实现过程，下面我们来学习一下动态数组。 动态数组 动态数组，顾名思义使得数组的容量是可伸缩的，大致思路如下，我们就需要创建一个新的数组newData[]来保存原来data[size]数组中的值，但是capacity将变大，size不变，赋值过程采用循环来赋值，完成后，将data[]指向new...
数据结构之动态数组
先锋小牛
05-29 773
简述     动态数组类似普通数组，内存空间都是连续的，可根据下标访问元素，普通数组定义时就会分配好空间，内存大小固定不变了，无法扩容，数据容易越界，但动态内存的大小会随着数据的增长而扩容。     动态数组看似内存空间在原来的基础上增长了，其实它只是申请了一块更大的内存，并把旧内存空间的数据拷贝到新申请的内存空间中，再把旧的空间释放掉，就这样一旦 发现当前内存快满，就会申请一块新的，同理，当
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值