数据结构线性表的顺序存储结构

线性表是由零个或多个数据元素组成的有序序列。

特点：

• 数据元素间是有顺序的；

• 数据元素的个数是有限的；

• 一般来说，数据元素的类型是相同的（强类型语言）。c/c++是强类型语言，必须指定数据类型。js、php、python等语言是弱类型就不需要指定数据类型。

线性表的顺序存储结构指的是用一段连续的存储空间来存储线性表中的数据元素，数组就是一个典型的顺序存储结构。

下面实现一个动态数组。

头文件

#pragma once
class DynamicArray
{
private:
	//成员变量
	int* data;//data指向存放数据元素的内存空间，堆区空间，数据元素类型默认是整数
	int size;//动态数组的大小，多少个数据元素，也就是线性表的长度
	int capacity;//动态数组容量
public:
	//特殊成员函数
	DynamicArray();//无参构造
	DynamicArray(int capacity);//有参构造
	~DynamicArray();//析构
	//普通成员函数
	//尾部添加元素
	void pushBack(int value);
	//打印动态数组
	void printDynamicArray();
	//在指定位置前插入元素
	void insertByIndex(int index,int value);
	//查询相关操作
	int getCapacity();//返回动态数组容量
	int getSize();//返回动态数组的大小
	int getValueByIndex(int index);//返回指定位置的元素
	int front();//返回动态数组第一个元素
	int back();//返回动态数组最后一个元素
	//删除元素
	void popBack();//删除最后一个元素
	void delByIndex(int index);//删除元素
};

源文件

#include
#include"dynamicArray.h"
using namespace std;
#include
DynamicArray::DynamicArray()//无参构造,初始化成员变量
{
	capacity = 5;//动态数组默认长度为5
	data = new int[capacity];//data指向五个大小的内存空间
	size = 0;
}
DynamicArray::DynamicArray(int capacity)//有参构造，传入容量
{
	this->capacity = capacity;
	data = new int[capacity];
	size = 0;
}
DynamicArray::~DynamicArray()//析构,释放内存空间
{
	if(data!=nullptr)
	{
		delete[]data;
		data = nullptr;
	}
}
void DynamicArray::pushBack(int value)
{
	//考虑容量够不够
	if (capacity == size)//容量已满，需要扩容，扩充一倍
	{
		int* temp_data = new int[capacity * 2];
		//复制原始空间数据到新空间
		for (int i = 0; i < size; i++)
		{
			temp_data[i] = data[i];
		}
		delete[]data;//释放原始空间
		data = temp_data;
		capacity = capacity * 2;
	}
	data[size] = value;
	size++;
}
void DynamicArray::insertByIndex(int index, int value)
{
	if (index<0 || index>size - 1)
	{
		return;
	}
	if (capacity == size)
	{
		int* temp_data = new int[capacity * 2];
		for (int i = 0; i < size; i++)
		{
			temp_data[i] = data[i];
		}
		delete[]data;//释放原始空间
		data = temp_data;//更新成员变量
		capacity = capacity * 2;//更新容量
		//新元素插在index前，index开始的元素都往后移
		for (int i = size - 1; i >= index; i--)
		{
			data[i + 1] = data[i];
		}
		data[index] = value;
		size++;
	}
}
void DynamicArray::printDynamicArray()
{
	for (int i = 0; i < size; i++)
	{
		cout << data[i]<<" ";
	}
	cout << endl;
}
int DynamicArray::getCapacity()
{
	return capacity;
}
int DynamicArray::getSize()
{
	return size;
}
int DynamicArray::getValueByIndex(int index)
{
	if (index<0 || index>size - 1)
	{
		return NULL;
	}
	return data[index];
}
int DynamicArray::front()
{
	if (size>0)
	{
		return data[0];
	}
	return NULL;
}
int DynamicArray::back()
{
	if (size > 0)
	{
		return data[size - 1];
	}
	return NULL;
}
void DynamicArray::popBack()
{
	if (size > 0)
	{
		size--;
	}
}
void DynamicArray::delByIndex(int index)
{
	if (index<0 || index>size - 1)
	{
		return;
	}
	for (int i = index; i < size - 1; i++)
	{
		data[i] = data[i + 1];
	}
	size--;
}
void test_dynamicarray()
{
	
	//DynamicArray dy;
	DynamicArray* dy = new DynamicArray();//堆对象
	dy->pushBack(11);
	dy->pushBack(12);
	dy->pushBack(13);
	dy->pushBack(14);
	dy->pushBack(15);
	dy->printDynamicArray();
	dy->insertByIndex(2, 88);
	dy->printDynamicArray();
	cout<<"动态数组容量为"<getCapacity()<pushBack(i + 20);
	}
	dy->printDynamicArray();
	cout << "动态数组容量为" << dy->getCapacity() << endl;*/
	cout << "动态数组的大小" << dy->getSize()<getValueByIndex(3) << endl;
	cout << "动态数组第一个元素是" << dy->front()<back() << endl;;
	dy->popBack();
	dy->printDynamicArray();
	dy->delByIndex(2);
	dy->printDynamicArray();
	delete dy;
}
void test_homework()
{
	
	srand((unsigned int)time(0));
	//srand(time(0));
	DynamicArray d;
	//DynamicArray* dy = new DynamicArray(8);
	
	for (int i = 0; i < 8; i++)
	{
		d.pushBack(rand() % 41+60);//生成0-19之间的整数
	}
	//d.pushBack(5);
	//d.pushBack(7);
	//d.pushBack(8);
	//d.pushBack(6);
	//d.pushBack(2);
	//d.pushBack(1);
	//d.pushBack(9);
	d.printDynamicArray();
	for (int i = 0; i < d.getSize();)
	{
		if (d.getValueByIndex(i)%2!=0)
		{
			d.delByIndex(i);
		}
		else
		{
			i++;
		}
	}
	d.printDynamicArray();

}
int main()
{
	//test_dynamicarray();
	test_homework();
	return 0;
}