C++实现向量构造的线性表

#include<iostream>
#include<algorithm>//copy，copy_backward函数
#include<sstream> //ostringstream
#include<string> //字符串
#include<exception>//异常处理
#include<iterator> //ostream_iterator<T>输出流
#include<vector>//vector线性表
using namespace::std;

//异常类
class illegalParameterValue
{
public:
	illegalParameterValue(string theMessage = "Illegal parameter value")
	{
		message = theMessage;
	}
	void outputMessage() { cout << message << endl; }
private:
	string message;
};
class illegalIndex
{
public:
	illegalIndex(string theMessage = "Illegal index") //初始化
	{
		message = theMessage;
	}
	void outputMessage() { cout << message << endl; }
private:
	string message;
};

//向量类
template<typename T>
class vectorList
{
public:
	//构造函数，新加的构造函数，析构函数
	vectorList(int initialCapacity = 10);
	~vectorList() { delete element; }
	//ADT方法
	void erase(int theIndex);
	void insert(int theIndex, const T& theElement);
	void output(ostream& cout);
	typedef typename vector<T>::iterator iterator;   //类的迭代器，很有用
	iterator begin() { return element->begin(); }
	iterator end() { return element->end(); }
	void half();
	void meld(vectorList<T>& a,vectorList<T>& b);
	void merge(vectorList<T>& a, vectorList<T>& b);
	void split(vectorList<T>& a, vectorList<T>& b);
private:
	vector<T>* element;
};
//向量线性表构造函数以及其他函数的定义
template<typename T>
vectorList<T>::vectorList(int initialCapacity)
{
	if (initialCapacity < 1)
	{
		ostringstream s;
		s << "Initial capacity=" << initialCapacity << "Must be >0";
		throw illegalParameterValue(s.str());//s.str(()返回s中储存的string 对象
	}
	element = new vector<T>;
	element->reserve(initialCapacity);
}
//插入函数
template<typename T>
void vectorList<T>::insert(int theIndex, const T& theElement)
{
	element->insert(element->begin()+theIndex, theElement);
}

//删除函数
template<typename T>
void  vectorList<T>::erase(int theIndex)
{
	element->erase(element->begin() + theIndex);
}
//输出函数
template<typename T>
void  vectorList<T>::output(ostream& cout)
{
	copy(element->begin(),element->end(), ostream_iterator<T>(cout, " "));
}
//half函数，删除奇数位的元素
template<typename T>
void vectorList<T>::half()
{
	int n = (element->end() - element->begin()) / 2;
	for (int i= 1; i<=n; i+=1)
	{
		element->erase(element->begin()+i);
	}
}
//合并两个表，值交替进行
template<typename T>
void vectorList<T>::meld(vectorList<T>& a,vectorList<T>& b)
{
	int n = a.end() - a.begin();
	int m = b.end() - b.begin();
	T va;
	if (n<=m)                                    //a比b短，则先按2倍的a进行交替插值，最后把剩余的a值插在末尾
	{
		for (int i = 0; i <2*n; i ++)
		{
			if (i%2 == 0)
				va = (*a.element)[i/2];
			else
				va= (*b.element)[(i-1)/2];
				element->insert(element->begin() + i, va);
		}
		for (int i = 2 * n; i < m + n; i++)
		{
			va = (*b.element)[(i+1)/ 2];
			element->insert(element->begin() + i, va);
		}
	}
	else                                         //a比b长，则操作相反
	{
		for (int i = 0; i <2 * m; i++)
		{
			if (i % 2 == 0)
				va = (*a.element)[i / 2];
			else
				va = (*b.element)[(i - 1) / 2];
			element->insert(element->begin() + i, va);
		}
		for (int i = 2 * m; i < m + n; i++)
		{
			va = (*a.element)[(i + 1) / 2];
			element->insert(element->begin() + i, va);
		}
	}
}
//对两个非递减序列进行合并，保证合并之后是有序的
template<typename T>
void vectorList<T>::merge(vectorList<T>& a, vectorList<T>& b)
{
	int n = a.end() - a.begin();
	int m = b.end() - b.begin();
	int i = 0;
	while(i <n)
	{
		element->insert(element->begin() + i, (*a.element)[i]);
		i++;
	}
	while (i < m + n)
	{
		element->insert(element->begin() + i, (*b.element)[i - n]);
		i++;
	}
	sort(element->begin(),element->end());                    //先合并两个线性表，再用sort函数进行升序排列
}
//分解线性表，生成两个线性表
template<typename T>
void vectorList<T>::split(vectorList<T>& a, vectorList<T>& b)
{
	int n = element->end() - element->begin();
	T va;
	for (int i = 0; i < n; i++)
	{
		va = (*element)[i];
		if (i% 2 == 0)
			a.element->insert(a.element->begin() + i/2, va);
		else
			b.element->insert(b.element->begin() + (i - 1)/ 2, va);
	}
}

int main()
{
	//对向量线性表进行测试
	vectorList<int>y(10);
	y.insert(0, 1);
	y.insert(1, 2);
	y.insert(2, 3);
	y.insert(3, 4);
	//对对半函数测试
	//y.half();
	//y.output(cout);
	vectorList<int>x(10);
	x.insert(0, 0);
	x.insert(1, 1);
	x.insert(2, 0);
	x.insert(3, 1);
	x.insert(4, 8);
	//对合并交替插值函数进行测试
	vectorList<int>z(10);
	//z.meld(y, x);
	//对合并排序函数进行测试
	//z.merge(y, x);
	//z.output(cout);
  //对分割函数测试
	vectorList<int>a(10);
	vectorList<int>b(10);
	y.split(a, b);
	a.output(cout);
	cout << endl;
	b.output(cout);
	return 0;
}