数据结构算法笔记_数组

特点：

内存是连续的。

优点：

下标访问（随机访问）时间复杂度是O（1）

末尾位置增加删除元素的时间复杂度是O（1）

访问元素前后相邻位置的元素非常方便

缺点：

非末尾位置增加删除元素需要进行大量的数据移动O（n）

搜索的时间复杂度

• 无序数组-线性搜素O（n）
• 有序数组-二分搜索O（logn）

增加元素可能会涉及到数组扩容消耗比较大。

数组的实现代码：

#include <iostream>
#include <stdlib.h>
#include <time.h>
using namespace std;

class Array
{
public:
	Array(int size = 10) :mCur(0), mCap(size)
	{
		mpArr = new int[mCap]();
	}
	~Array()
	{
		delete[] mpArr;
		mpArr = nullptr;
	}

public:
	// 末尾增加元素
	void push_back(int val)
	{
		if (mCur == mCap)
		{
			expand(2 * mCap); //O(n)
		}
		mpArr[mCur++] = val;
	}

	// 末尾删除元素
	void pop_back() //O(1)
	{
		if (mCur == 0)
		{
			return;
		}
		mCur--;
	}

	// 按位置增加元素
	void insert(int pos, int val)
	{
		if (pos < 0||pos > mCur)
		{
			return;
		}
		if (mCur == mCap)
		{
			expand(2 * mCap);
		}
		// 移动元素O(n)
		for (int i = mCur - 1; i >= pos; i--)
		{
			mpArr[i + 1] = mpArr[i];
		}
		mpArr[pos] = val;
		mCur++;
	}

	// 按位置删除
	void erase(int pos)
	{
		if (pos < 0||pos >= mCur)
		{
			return;
		}
		//O(n)
		for (int i = pos+1; i < mCur; i++)
		{
			mpArr[i - 1] = mpArr[i];
		}
		mCur--;
	}

	// 元素查询
	int find(int val) const
	{
		for (int i = 0; i < mCur; i++)
		{
			if (mpArr[i] == val)
			{
				return i;
			}
		}
		return -1;
	}

	// 打印数据
	void show() const
	{
		for (int i = 0; i < mCur; i++)
		{
			cout << mpArr[i] << " ";
		}
		cout << endl;
	}

private:
	// 内部数组扩容接口
	void expand(int size)
	{
		int* p = new int[size];
		memcpy(p, mpArr, sizeof(int) * mCap);
		delete[] mpArr;
		mpArr = p;
		mCap = size;
	}
private:
	int* mpArr; // 指向可扩容的数组内存
	int mCap; // 数组的容量
	int mCur; // 数组有效元素的个数
};
int main()
{
	Array arr;

	srand(time(0));
	for (int i = 0; i < 10; i++)
	{
		arr.push_back(rand() % 100);
	}

	arr.show();
	arr.pop_back();
	arr.show();

	arr.insert(0, 100);
	arr.show();

	arr.insert(10, 200);
	arr.show();

	int pos = arr.find(100);
	if (pos!=-1)
	{
		arr.erase(pos);
		arr.show();
	}

	return 0;
}