数据结构之——动态数组完备版（C++实现）

最新推荐文章于 2024-07-12 18:43:47 发布
最新推荐文章于 2024-07-12 18:43:47 发布
阅读量470 收藏 1
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GaoXiaoYuan0728/article/details/107773042
版权

动态数组

⚪数组是一种顺序存储的线性表，所有匀速的内存地址都是连续的

在很多编程语言中，数组都有个致命的缺点——无法动态修改容量
因此在实际开发中，我们希望数组的容量是可以动态改变的

⚪ 接口设计

    int sizeOf();		//元素的数量
	bool isEmpty();		//是否为空
	bool contains(E elemnet);		//是否包含某个元素
	E get(int index);		//返回index位置对应的元素
	E set(int index, E element);		//设置index位置的元素
	void add(E element);		//往尾节点添加元素
	void add(int index, E element);		//往index位置添加元素
	E remove(int index);		//删除index位置对应的元素
	int indexOf(E element);		//查看元素的位置
	void clear();		//清除所有元素
	void print();		//显示所有元素

下面是 ArrayList.h文件。

#pragma once
#include <iostream>
using namespace std;
template <class E>

class ArrayList
{
private:
	int size;
	int *elements;

	static const int DEFAULT_CAPACITY = 10;
	static const int ELEMNT_NONE_FOUND = -1;

	void EnsureCapacity(int capacity);		//检查是否需要扩容
public:
	ArrayList() 
	{
		elements = new int[DEFAULT_CAPACITY];
	}
	ArrayList (E a[],int capaticy) 
	{
		int n = capaticy;
		capaticy = (capaticy < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capaticy;
		elements = new int[capaticy];
		for (int i = 0; i < n; i++)
		{
			elements[i] = a[i];
		}
		size = n;
	}

	int sizeOf();		//元素的数量
	bool isEmpty();		//是否为空
	bool contains(E elemnet);		//是否包含某个元素
	E get(int index);		//返回index位置对应的元素
	E set(int index, E element);		//设置index位置的元素
	void add(E element);		//往尾节点添加元素
	void add(int index, E element);		//往index位置添加元素
	E remove(int index);		//删除index位置对应的元素
	int indexOf(E element);		//查看元素的位置  若存在则返回对应位置，若不存在，则返回-1
	void clear();		//清除所有元素
	void print();		//显示所有元素

	~ArrayList() {};
};

⚪易错分析

①删除元素

    删除的元素应当分为2种情况来讨论

1、删除尾部元素

    如果删除的是尾部元素，直接将size–，使用户不可调用尾部元素即可。

2、删除非尾部元素

    假设size=7，index=3时
    因为当初数组申请空间时，是向系统动态分配了capacity个连续的存储空间，所以不存在只删除某个元素，将其内存挖去的下面的这种情况。
在这里插入图片描述
删除错误示例
        正确的删除元素应当是元素的挪动。 根据下方图片的显示，我们能直观的看出来元素挪动了4、5、6位置的元素，将删除的元素后方的值往前挪一个，利用element[i-1]=element[i]语句，从前往后将后方元素的值覆盖前方元素的值。从4-6挪动了三次，而4就是index+1，6是size-1。因此元素的挪动范围就是[index+1,size-1]，利用for(int i=index+1;i<=size-1;i++)循环来使用 ，最后再size–。
删除正确示例
        最后将第一种尾部元素删除的情况带入for循环的语句中发现也符合要求，因此只需要写出for循环的一般情况。
remove(int index)代码：

template <class E>
E ArrayList<E>::remove(int index)		//删除index位置对应的元素
{
	if (index < 1 || index >= size) throw"Index错误";			//检测index是否越界

	int old = elements[index];			//保存被删除元素的值用来返回
	for (int i = index + 1; i < size; i++)
	{
		elements[i - 1] = elements[i];
	}
	elements[size--]=NULL;		//将element[size]=NUL和size-1的语句和的语句合并
	return old;
}

②在某个位置添加元素

对于某个位置应当分3种情况来讨论

1、在头部添加元素
2、在中间添加元素
	假设size=5，index=2
	![原版数组](https://img-blog.csdnimg.cn/20200913110719376.png#pic_center)
	![在中间添加元素](https://img-blog.csdnimg.cn/2020091311032611.png#pic_center)

        这种情况就很类似于删除元素的思想，但是和删除元素的区别在于挪动的顺序，删除元素是从前往后挪，而添加元素是从后往前挪。如果是按照一样的挪动思想会出现下方图片的情况。
挪动错误示例

3、在尾部添加元素
直接在尾部添加元素，size++即可

⚠：此处要注意动态扩容的问题，首先要检查添加元素后是否超过了分配的数组长度。

template <class E>
void ArrayList<E>::EnsureCapacity(int capacity)		//检查是否需要扩容
{
	int oldCapacity = size;
	if (oldCapacity >= capacity)
	{
		return;
	}

	int newCapacity = oldCapacity + (oldCapacity >> 1);
	int* NewElements = new int[newCapacity];
	for (int i = 0; i < size; i++)
	{
		NewElements[i] = elements[i];
	}
	elements = NewElements;
}

add(int index, E element)代码：

template <class E>
void ArrayList<E>::add(int index, E element)		 //往index位置添加元素
{
	EnsureCapacity(size + 1);					     //检查是否需要扩容

	if (index < 0 || index > size) throw"Index错误";  //检测index是否越界 此处是 index > size而不是index >= size 因为有可能是最后面插入元素

	for (int i = size - 1; i >= index; i--)
	{
		elements[i + 1] = elements[i];
	}
	elements[index] = element;
	size++;
}

🔔：不管是添加删除还是查找某一位置对应的元素都应该进行index的检测，防止数组越界

if(index < 0||index>=size) throw"Index错误";			//检测index是否越界

⚪总代码

ArrayList.h

#pragma once
#include <iostream>
using namespace std;
template <class E>

class ArrayList
{
private:
	int size;
	int *elements;

	static const int DEFAULT_CAPACITY = 10;
	static const int ELEMNT_NONE_FOUND = -1;

	void EnsureCapacity(int capacity);		//检查是否需要扩容
public:
	ArrayList() 
	{
		elements = new int[DEFAULT_CAPACITY];
	}
	ArrayList (E a[],int capaticy) 
	{
		int n = capaticy;
		capaticy = (capaticy < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capaticy;
		elements = new int[capaticy];
		for (int i = 0; i < n; i++)
		{
			elements[i] = a[i];
		}
		size = n;
	}

	int sizeOf();		//元素的数量
	bool isEmpty();		//是否为空
	bool contains(E elemnet);		//是否包含某个元素
	E get(int index);		//返回index位置对应的元素
	E set(int index, E element);		//设置index位置的元素
	void add(E element);		//往尾节点添加元素
	void add(int index, E element);		//往index位置添加元素
	E remove(int index);		//删除index位置对应的元素
	int indexOf(E element);		//查看元素的位置  若存在则返回对应位置，若不存在，则返回-1
	void clear();		//清除所有元素
	void print();		//显示所有元素

	~ArrayList() {};
};

ArrayList.cpp

#include "ArrayList.h"

template <class E>
int ArrayList<E>::sizeOf()		//元素的数量
{
	return size;
}

template <class E>
bool ArrayList<E>::isEmpty()		//是否为空
{
	return size == 0;
}

template <class E>
bool ArrayList<E>::contains(E element)		//是否包含某个元素
{
	for (int i = 0; i < size; i++)
	{
		if (elements[i] == element)
		{
			return true;
		}
	}
	return false;
}

template <class E>
E ArrayList<E>::get(int index)  	//返回index位置对应的元素
{
	if (index < 0 || index >= size) throw "Index错误";//检测index是否越界
	return elements[index];
}

template <class E>
E ArrayList<E>::set(int index, E element)		//设置index位置的元素
{
	if(index < 0 || index >= size) throw"Index错误";			//检测index是否越界
	elements[index] = element;
	return element;
}

template <class E>
void ArrayList<E>::add(E element)
{
	add(size, element);
}

template <class E>
void ArrayList<E>::add(int index, E element)		//往index位置添加元素
{
	EnsureCapacity(size + 1);					//检查是否需要扩容

	if (index < 0 || index > size) throw"Index错误";  //检测index是否越界 此处是 index < 0 || index > size而不是index < 1 || index >= size 因为有可能是往最面前后者最后面插入元素

	for (int i = size - 1; i >= index; i--)
	{
		elements[i + 1] = elements[i];
	}
	elements[index] = element;
	size++;
}

template <class E>
E ArrayList<E>::remove(int index)		//删除index位置对应的元素
{
	if (index < 0 || index >= size) throw"Index错误";			//检测index是否越界

	int old = elements[index];
	for (int i = index + 1; i < size; i++)
	{
		elements[i - 1] = elements[i];
	}
	elements[--size]=NULL;
	return old;
}

template <class E>
int ArrayList<E>::indexOf(E element)		//查看元素的位置 若存在则返回对应位置，若不存在，则返回-1
{
	for (int i = 0; i < size; i++)
	{
		if (elements[i] == element)
		{
			return i;
		}
	}
	return ELEMNT_NONE_FOUND;
}

template <class E>
void ArrayList<E>::clear()		//清除所有元素
{
	for (int i = 0; i < size; i++)
	{
		elements[i] = NULL;
	}
	size = 0;
}

template <class E>
void ArrayList<E>::print()
{
	for (int i = 0; i < size - 1; i++)
	{
		cout << i << ":" << elements[i] << "   ";
	}
}

template <class E>
void ArrayList<E>::EnsureCapacity(int capacity)		//检查是否需要扩容
{
	int oldCapacity = size;
	if (oldCapacity >= capacity)
	{
		return;
	}

	int newCapacity = oldCapacity + (oldCapacity >> 1);
	int* NewElements = new int[newCapacity];
	for (int i = 0; i < size; i++)
	{
		NewElements[i] = elements[i];
	}
	elements = NewElements;
}

main.cpp

#include <iostream>
#include "ArrayList.h"
#include "ArrayList.cpp"

int main()
{
    int r[5] = { 1,2,3,4,5 }, i, x;                             //建立具有5个元素的顺序表
    ArrayList<int> list(r,5);
    cout << "当前线性表的数据为：";                             //输出当前线性表
    list.print();
    try 
    {
        list.add(2, 8);                                         //在第2个位置插入值为8的元素
        cout << "执行插入操作后的数据为：";
        list.print();                                           //插入后的顺序表 1 2 8 3 4 5
    }
    catch (char* str) { cout << str << endl; }
    cout << "当前线性表的长度为：" << list.sizeOf() << endl;    //输出线性表的长度 6
    cout << "请输入查找的元素：";
    cin >> x;
    i = list.indexOf(x);
    if (i == -1)cout << "查找失败" << endl;
    else cout << "元素" << x << "的位置为：" << i << endl;
    try
    {
        cout << "请输入查找第几个元素值：";
        cin >> i;
        cout << "第" << i << "个元素值是" << list.get(i) << endl;
    }
    catch (char* str) { cout << str << endl; 
    }
    try
    {
        cout << "请输入要删除第几个元素：";
        cin >> i;
        x = list.remove(i);                                    //删除第 i 个元素
        cout << "删除的元素是" << x << "，删除后的数据为：";
        list.print();                                          //输出删除后的线性表
    }
    catch (char* str) {cout << str << endl; }

    return 0;
}

全部代码都通过测试，皆可放心食用

GXM.
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
线性表——顺序数组seqList的实现 C++
净无邪博客
02-28 1702
本文主要总结常用的数据结构——线性表之数组实现，实现基本运算功能，不涉及完整功能，目的是为了熟悉常用数据结构特性和代码实现底层原理。 一、线性表——数组Array 1.1线性表定义 从逻辑上来看，线性表就是有n(n>=0)个数据元素a1，a2，…，an组成的有限序列。 对于一个非空的线性表，其逻辑结构特征如下： 有且仅有一个开始结点a1和一个直接后继节点a2，没有直接前驱节点，； 有且仅有一个终止节点an和一个直接前驱节点a*(n-1)*，没有直接后继节点； 其余的内部节点ai （2 <=
《数据结构——C++实现》（第二版）课本源代码.zip
06-16
《数据结构——C++实现》（第二版）是一本深入讲解这一主题的教材，提供了源代码供读者实践和学习。 本书的C++实现部分，旨在帮助读者掌握各种基本和高级数据结构，如数组、链表、栈、队列、树（二叉树、平衡树）、...
数据结构——动态数组（C/C++）
qq_43683352的博客
09-21 655
复现了一个简单的数据结构：动态数组（DynamicArray）。实现了一些简单的操作如：初始化、插入、按位删除。动态数组的初始化操作：对动态数组进行一些常见的初始化操作。动态数组的插入操作：对指定的位置进行数据的插入。动态数组的删除：通过位置对数组元素进行删除。
C/C++数据结构之动态数组篇
qq_63883017的博客
11-05 8844
手把手带你从初识动态数组到手写简单版本的c++vector容器
C/C++数据结构（一） —— 数组
热门推荐
Edison's 小宇宙
07-25 1万+
【数据结构系列】线性表之顺序表的基本操作
c++小白数据结构——————1动态数组
weixin_48077926的博客
05-09 344
c++数据结构，动态数组
线性数据结构——二维数组与动态数组
最新发布
taozhenJ的博客
07-12 588
二维数组本质上是以数组作为元素的数组， 即“数组的数组”， 在C++中，二维数组的格式如下：类型 数组名[行数][列数];例：int a[2][3]; 具体见示例图：接下来看一下二维数组的地址魔法（请自己运行）： 多维数组 多维数组是三维及其以上的数组，三维数组具有高、宽、深的概念，或者说行、列、层的概念，即数组嵌套数组达到三维及其以上， 三维数组定义如下：类型 数组名[行数][列数][层数];数组的基本操作包括：随机访问，查找，修改，插入，删除等其中随机访问, 修改的时间复杂度为O(1), 插入，删
数据结构经典面试之数组——C#和C++篇
qq_35320456的博客
06-20 1011
数组是一种基础且重要的数据结构，在C#和C++这两种编程语言中都有广泛的应用。通过本文的介绍，希望你对数组的概念、特点以及在C#和C++中的使用方法有了更深入的了解。在实际编程过程中，熟练掌握数组的使用对于提高代码效率和性能具有重要意义。在编程中，我们应该根据具体需求选择合适的数据结构。数组适合于处理固定数量和类型的元素，但如果元素数量或类型需要动态变化，可能需要考虑使用其他数据结构，如列表、字典等。此外，随着编程技能的提高，了解和掌握更高级的数据结构将有助于我们编写更高效、更灵活的代码。
数据结构 线性结构篇——动态数组和时间复杂度分析
牧小农
11-21 3725
一、数组基础 1.1 定义 数组（Array）是一种线性表数据结构，它用一组连续的内存空间来存储一组具有相同类型的数据。 1.2 创建流程 当我们在 java 中当创建一个数组时，会在内存中划分出一块 连续的内存 ，当有数据进入的时候会将数据 按顺序 的存储在这块连续的内存中。当需要读取数组中的数据时，需要提供数组中的 索引 ，然后数组根据索引将内存中的数据取出来，返回给读取程序。 把数据...
数据结构——循环队列（C++实现）
qq_67693066的博客
04-22 889
数据结构——循环队列（C++）
【C++】C++数组——定义、访问、动态数组
PuddleRubbish的博客
12-17 940
数据类型 数组名[数组长度]数据类型 数组名[数组长度] = {值1, 值2 …}如果在初始化的时候，没有全部填写完，会用0来填补剩余数据数据类型 数组名[ ] = {值1, 值2 …}定义数组的时候，必须有初始长度，即大括号内的元素个数是明确的注意，数组以 0 作为它们第一个元素的索引，也被称为基索引，数组的最后一个索引是数组的总大小减去 1。合法访问的下标范围：左闭右开数据类型 数组名[ 行数 ][ 列数 ]
C++——数组模拟链表
12-03
C++中的链表是数据结构中非常重要的一部分，而在链表中，我们可以使用数组来模拟链表的结构。今天，我们将讨论如何使用数组来模拟链表，并实现链表的插入和遍历操作。 首先，我们需要了解链表的基本结构。链表是一...
数据结构与算法分析C++语言描述第四版参考答案
10-13
本书深入讨论了这些基本数据结构的实现，例如，如何用C++构建动态数组、单链表、双向链表、循环链表以及各种类型的队列（如FIFO和优先级队列）。此外，书中还涵盖了高级数据结构，如堆、哈希表、二叉搜索树和红黑树...
《数据结构——C++实现》（第二版）课本源代码
10-30
《数据结构——C++实现》（第二版）是一本经典的计算机科学教材，专注于介绍各种数据结构及其在C++编程语言中的实现。这本书的核心是通过实际的代码示例帮助读者理解和掌握数据结构的基本概念，这对于任何想要深入...
数据结构之——单向循环队列完备版（C++实现）
GaoXiaoYuan0728的博客
08-05 827
数据结构——单向循环队列完备版（C++实现） 我看了一下网上C++实现的队列大都是用之前所学的链表来实现，因为不用考虑内存溢出问题，其实单向的队列主要功能是队尾入队和队头出队，是在头和尾实现，若是没有循环在队头这一块的处理动态数组的复杂度为O(n)，而链表是O(1)，当然选用链表来实现。但是当将动态数组优化使其循环，可做到几乎所有功能的平均复杂度都可以做到O(1)。 其实单向循环队列比较好的地方主要是可以最大化的使用动态数组的空间，不必像之前的动态数组一样删除头部元素后方所有元素都要跟着移动，只需要将头节点
数据结构之——单向循环链表完备版（C++实现）
GaoXiaoYuan0728的博客
09-23 795
#pragma once #pragma once #include <iostream> using namespace std; template<class E> class Node { public: E element; //元素值 Node<E>* next; //指向下一个节点 Node() {}; //不含参数的构造函数 Node(E element, Node<E>* next) //含参数的构造函数 { th
数据结构之——双向循环队列完备版（C++实现）
GaoXiaoYuan0728的博客
08-09 780
循环双端队列实际上就是是在之前单向的循环队列的基础上可以进行两端添加、删除操作的循环队列，因此我们在函数中增加了头部入队和尾部删除。 而对于队尾元素没必要再设置一个变量，因为尾部的变量直接可以用front+size 下面是 Circle_Double_Queue.h的代码。 #pragma once #include <iostream> using namespace std; template <class E> class Circle_Double_Queue { pri
数据结构——二叉搜索树完备版（C++）
GaoXiaoYuan0728的博客
08-07 643
二叉搜索树C++实现 细致讲解了添加、遍历、求高度、判断是否为完全二叉树、删除节点的方法 对二叉搜索树进行了完备的代码实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

GXM.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值