动态数组

接口设计

int size();//元素的数量
bool isEmpty();	//是否为空
bool contains(E element);//是否包含某个元素
void add(E element);//添加元素到最后面
void add(int index, E element); //往index位置添加元素
void clear();//清除所有元素
E remove(int index);//删除index位置对应的元素
E set(int index, E element); //设置index位置的元素
E get(int index);//返回index位置对应的元素
int indexof(E element);//查看元素的位置	

添加元素

​ add(E element)：默认往数组最后添加元素

​ add(int index, E element)：在index位置插入一个元素
​ 往index = 2添加元素，从后往前将index = 2以后的元素依次后移，然后赋值

删除元素

​ 删除 index = 3 的数组元素，应当从前往后开始移动，用后面的元素覆盖前面的元素

泛型动态数组源码

#pragma once
#include<iostream>

template <class E>
class ArrayList
{
private:
	int m_size;		//元素数量
	int m_capacity;	//数组容量
	E* m_elements;	//类型指针,用于存放动态分配的数组内存首地址
	static const int DEFAULT_CAPACITY = 10;	//初始容量
	static const int ELEMENT_NOF_FOUND = -1;
	
    //抛出异常
	void OutOfBounds(int index)
	{
		throw index;
	}

	//检查下标越界(不可访问或删除size位置)
	void rangeCheck(int index)
	{
		if (index < 0 || index >= m_size)
		{
			OutOfBounds(index);
		}
	}

	//检查add()下标越界,可以在size位置添加元素
	void rangeCheckForAdd(int index)
	{
		if (index<0 || index>m_size)
		{
			OutOfBounds(index);
		}
	}

	//扩容操作
	void ensureCapacity(int capacity)
	{
		int oldCapacity = m_capacity;
		if (oldCapacity >= capacity) return;		
		int newCapacity = oldCapacity + (oldCapacity >> 1);
		E* newElements = new E[newCapacity];
		for (int i = 0; i < m_size; i++)
		{
			newElements[i] = m_elements[i];
		}
		delete[] m_elements;
		m_elements = newElements;
		m_capacity = newCapacity;
		cout << oldCapacity << "扩容为" << newCapacity << endl;
	}
public:
	ArrayList(int capacity)
	{
		m_capacity = (capacity < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capacity;
		m_elements = new E[m_capacity];
	}

	ArrayList()
	{
		m_capacity = DEFAULT_CAPACITY;
		m_elements = new E[m_capacity];
	}

	~ArrayList()
	{
		delete[] m_elements;
	}

	//元素的数量
	int size()
	{
		return m_size;
	}

	//是否为空
	bool isEmpty()
	{
		return m_size == 0;
	}

	//查看元素的索引
	int indexof(E element)
	{
		for (int i = 0; i < m_size; i++)
		{
			if (m_elements[i] == element)
			{
				return i;
			}
		}
		return ELEMENT_NOF_FOUND;
	}

	//是否包含某个元素
	bool contains(E element)
	{
		return indexof(element) != ELEMENT_NOF_FOUND;
	}

	//设置index位置的元素
	E set(int index, E element)
	{
		rangeCheck(index);
		E old = m_elements[index];
		m_elements[index] = element;
		return old;
	}

	//获取index位置的元素
	E get(int index)
	{
		rangeCheck(index);
		return m_elements[index];
	}

	//在index位置插入一个元素
	void add(int index, E element)
	{
		rangeCheckForAdd(index);
		ensureCapacity(m_size + 1);

		// 0 1 2 3 4 5 6 7 8 9	(index)
		// 1 2 3 4 5 6 x x x x	(原数组)
		// 在index=2处,插入9,元素全部后移
		// 1 2 9 3 4 5 6 x x x	(add后数组)
		// 先从后往前开始,将每个元素往后移一位,然后再赋值
		for (int i = m_size - 1; i > index; i--)
		{
			m_elements[i + 1] = m_elements[i];
		}
		m_elements[index] = element;
		m_size++;
	}

	//添加元素到最后面
	void add(E element)
	{
		add(m_size, element);
	}	
	
	//删除index位置的元素
	E remove(int index)
	{
		rangeCheck(index);
		E old = m_elements[index];
		// 0 1 2 3 4 5 	(index)
		// 1 2 3 4 5 6 	(原数组)
		// 删除index为2的元素，元素前移
		// 1 2 4 5 6	(remove后的数组)
		// 从前往后开始移,用后面的元素覆盖前面的元素
		for (int i = index; i < m_size - 1; i++)
		{
			m_elements[i] = m_elements[i + 1];
		}
		m_elements[--m_size] = NULL;
		return old;
	}

	//清除所有元素
	void clear()
	{
		for (int i = 0; i < size; i++)
		{
			m_elements[i] = NULL;
		}
		m_size = 0;
	}
};