c++实现MyVector和MyList

一、实现MyVector

顺序表

#include<iostream>
#include<assert.h>
using namespace std;

typedef int DataType;
class MyVector{
public:
	//(1)构造空vector
	MyVector()
		:_array(new DataType[3])
		, _size(0)
		,_capacity(3)
	{}
	//(2)构造有n个值为data的元素
	//data为内置对象-->0
	//  自定义--》调datatype类的缺省的构造函数
	MyVector(size_t n, const DataType& data=DataType())
		:_array(new DataType[n])
		, _size(n)
		, _capacity(n)
	{
		size_t  i;
		for (i = 0; i < n; ++i)
		{
			_array[i]=data;
		}
	}
	//（3）用区间进行构造
	MyVector(DataType* first, DataType* last)
	{
		size_t size = last - first;
		_array = new DataType[size];
		_capacity = size;
		_size = size;
		int i;
		for (i = 0; i < size; i++)
		{
			_array[i] = first[i];
		}
	}
	//拷贝构造
	MyVector(const MyVector& v)
		:_array(NULL)
		, _size(0)
		, _capacity(0)
	{
		MyVector tmp(v._array,v._array+v._size);
		swap(_array, tmp._array);
		swap(_size, tmp._size);
		swap(_capacity, tmp._capacity);
	}
	//赋值
	MyVector& operator=(const MyVector& v)
	{
		if (this != &v)
		{
			MyVector tmp(v._array, v._array + v._size);
			swap(_array, tmp._array);
			swap(_size, tmp._size);
			swap(_capacity, tmp._capacity);
		}
		return *this;
	}
	//析构
	~MyVector()
	{
		if (_array)
		{
			delete[] _array;
			_array = NULL;
			_size = 0;
			_capacity = 0;
		}
	}
	//通过下标访问
	DataType& operator[](size_t index)
	{
		assert(index < _size);
		return _array[index];
	}
	
	const DataType& operator[](size_t index) const
	{
		assert(index < _size);
		return _array[index];
	}
	//返回头
	DataType& Front()
	{
		return _array[0];
	}

	const DataType& Front() const
	{
		return _array[0];
	}
	//返回尾
	DataType& Back()
	{
		return _array[_size - 1];
	}

	const DataType& Back() const
	{
		return _array[_size - 1];
	}
	//返回个数
	size_t Size() const
	{
		return _size;
	}
	size_t Capacity() const
	{
		return _capacity;
	}
	//改为n个元素，多出来的写为data
	void Resize(size_t newSize, const DataType& data=DataType())
	{
		size_t oldSize = Size();
		if (newSize <= oldSize)
		{
			_size= newSize;
		}
		else
		{
			if (newSize <= _capacity)
			{
				size_t i;
				for (i = oldSize; i < newSize; i++)
				{
					_array[i] = data;
				}
			}
			else
			{
				//开辟空间
				DataType* tmp = new DataType[newSize];
				//将老数据搬进来
				size_t i;
				for (i = 0; i < oldSize; i++)
				{
					tmp[i] = _array[i];
				}
				//将剩下的用data填充
				for (i = oldSize; i < newSize; i++)
				{
					tmp[i] = data;
				}
				//将老空间释放
				delete[] _array;
				_array = tmp;
				_size = newSize;
				_capacity = newSize;
			}
		}
	}
	//当前顺序表预留空间，不能改变顺序表中有效元素个数
	void Reserve(size_t NewCapacity)
	{
		size_t oldCapacity = Capacity();
		if (NewCapacity > oldCapacity)
		{
			//申请空间
			DataType* tmp = new DataType[NewCapacity];
			//将数据搬过来
			for (size_t i = 0; i < Size(); ++i)
			{
				tmp[i] = _array[i];
			}
			//释放老空间
			delete[] _array;
			_array = tmp;
			_capacity = NewCapacity;
		}
	}
	//尾插
	void PushBack(const DataType& data)
	{
		_checkCapacity();
		_array[_size++]=data;
	}
	//尾删
	void Pop()
	{
		--_size;
	}

	//任意位置插入
	void Insert(size_t pos, const DataType& data);
	//任意位置删除
	void Erase(size_t pos);
	//复杂度太大

	//清空
	void clear()
	{
		_size = 0;
	}
private:
	void _checkCapacity()
	{
		if (_size == Capacity())
			Reserve(2 *Capacity());
	}

	friend ostream& operator<<(ostream& out, const MyVector& v)
	{
		size_t i;
		for (i = 0; i < v._size; ++i)
			out <<v. _array[i] << " ";
			return out;
	}
	
private:
	DataType* _array;
	size_t _size;
	size_t _capacity;
};

2. MyList

链表

#include<iostream>
using namespace std;


//带头结点的双向循环链表
typedef int DataType;
struct ListNode
{
	ListNode(const DataType& data=DataType())
	:_pNext(NULL)
	, _pPre(NULL)
	, _data(data)
	{}

	ListNode* _pNext;
	ListNode* _pPre;
	DataType _data;
};
class Mylist
{
public:
	//无参
	Mylist()
	{
		//创建头结点
		CreateHead();
	}
	//将n个结点初始化为data
	Mylist(size_t n, const DataType& data)
	{
		CreateHead();
		for (size_t i = 0; i < n; i++)
		{
			PushBack(data);
		}
	}
	//传区间
	Mylist(DataType* pFirst, DataType* pLast)
	{
		CreateHead();
		while (pFirst != pLast)
		{
			PushBack(*pFirst);
			pFirst++;
		}
	}
	//拷贝构造
	Mylist(const Mylist& l)
	{
		CreateHead();
		ListNode* pcur = l._pHead->_pNext;
		while (pcur != l._pHead)
		{
			PushBack(pcur->_data);
			pcur = pcur->_pNext;
		}
	}
	//赋值
	Mylist& operator=(const Mylist l)
	{
		if (this != &l)
		{
			Clear();
			ListNode* pcur = l._pHead->_pNext;
			while (pcur != l._pHead)
			{
				PushBack(pcur->_data);
				pcur = pcur->_pNext;
			}
		}
		return *this;
	}

	//析构
	~Mylist()
	{
		//销毁链表中的有效结点-- - 头删法
		Clear();
		Destroy();
	}
	//////////////////
	//个数
	size_t Size() const
	{
		size_t cout = 0;
		ListNode* pcur = _pHead->_pNext;
		while (pcur != _pHead)
		{
			cout++;
			pcur = pcur->_pNext;
		}
		return cout;
	}
	//是否为空
	bool Empty() const
	{
		return _pHead->_pNext = _pHead;
	}
	//改为n个元素，多出来的写data
	void Resize(size_t n, const DataType& data = DataType())
	{
		size_t oldSize = Size();
		if (oldSize >= n)
		{
			for (size_t t = n; t < oldSize; ++t)
			{
				PopBack();
			}
		}
		else
		{
			for (size_t i = oldSize; i < n; i++)
			{
				PushBack(data);
			}
		}
	}
	////////////////
	//返回头
	DataType& Front()
	{
		return _pHead->_pNext->_data;
	}
	const DataType& Front() const
	{
		return _pHead->_pNext->_data;
	}
	//返回尾
	DataType& Back()
	{
		return _pHead->_pPre->_data;
	}
	const DataType& Back() const
	{
		return _pHead->_pPre->_data;
	}

	///////////////////////
	//尾插
	void PushBack(const DataType& data)
	{
		ListNode* pNew = new ListNode(data);
		pNew->_pPre = _pHead->_pPre;
		pNew->_pNext = _pHead;
		_pHead->_pPre = pNew;
		pNew->_pPre->_pNext = pNew;
	}
	//尾删
	void PopBack()
	{
		ListNode* del = _pHead->_pPre;
		if (del!=_pHead){
			_pHead->_pPre = del->_pPre;
			del->_pPre->_pNext = _pHead;
			delete del;
		}
	}
	//头插
	void PushFront(const DataType& data)
	{
		ListNode* pNew = new ListNode(data);

		pNew->_pPre = _pHead;
		pNew->_pNext = _pHead->_pNext;
		_pHead->_pNext = pNew;
		pNew->_pNext->_pPre = pNew;
	}
	//头删
	void PopFront()
	{
		ListNode* del=_pHead->_pNext;
		if (del != _pHead){
			_pHead->_pNext = del->_pNext;
			del->_pNext->_pPre = _pHead;
			delete del;
		}
	}
	//任意位置插入
	void Insert(ListNode* pos,const DataType& data)
	{
		ListNode* pNew = new ListNode(data);
		pNew->_pPre = pos->_pPre;
		pNew->_pNext = pos;
		pNew->_pPre->_pNext = pNew;
		pos->_pPre = pNew;
	}
	//任意位置删除
	void Erase(ListNode* pos)
	{
		if (pos)
		{
			pos->_pPre->_pNext = pos->_pNext;
			pos->_pNext->_pPre = pos->_pPre;
			delete pos;
		}
	}
	//清空
	void Clear()
	{
		ListNode* pcur = _pHead->_pNext;
		while (pcur != _pHead)
		{
			_pHead->_pNext = pcur->_pNext;
			delete pcur;
			pcur = _pHead->_pNext;
		}
		_pHead->_pNext = _pHead;
		_pHead->_pPre = _pHead;
	}
	//查找
	ListNode* Find(const DataType& data)
	{
		ListNode* pcur = _pHead->_pNext;
		while (pcur != _pHead)
		{
			if (pcur->_data == data)
				return pcur;
			pcur = pcur->_pNext;
		}
		return NULL;
	}
private:
	void Destroy()
	{
		delete _pHead;
		_pHead =0;
	}
	void CreateHead()
	{
		_pHead = new ListNode;
		_pHead->_pNext = _pHead;
		_pHead->_pPre = _pHead;
	}
	friend ostream& operator<< (ostream& _cout, const Mylist& l)
	{
		ListNode* pcur = l._pHead->_pNext;
		while (pcur !=l._pHead)
		{
			_cout << pcur->_data << " ";
			pcur = pcur->_pNext;
		}
		return _cout;
	}
private:
	ListNode* _pHead;
};