用C++封装顺序表和双循环链表。

今天我来用C++封装一下以前写过的顺序表以及双循环链表。

一。顺序表：

#include
using namespace std;

//定义一个内置类型int。
typedef int DataType;

//写一个动态顺序表：
class Myvector
{
public:
	//形参为空的构造函数
	Myvector()
		:_array(new DataType[3])       //直接初始化列表
		,_size(0)
		,_capacity(3)
	{}

	//已知顺序表的有效长度和每个值进行构造函数。
	Myvector(size_t n, const DataType& data = DataType())
		:_array(new DataType[n])
		,_size(n)
		,_capacity(n)
	{
		size_t i=0;
		for(i=0;iold)
		{
			DataType* t=new DataType[newCapacity];
			for(i=0;ipos;i--)
		{
			_array[i]=_array[i-1];
		}
		_array[i]=data;
		_size++;
	}

	//任意位置进行删除
	void Erase(size_t pos)
	{
		size_t i=pos;
		for(i=pos+1;i

这就是封装后的顺序表，这里面需要注意的就是在写拷贝构造函数时要记得写成深拷贝的任意形式，否则会造成内存泄漏。

 

二。双循环链表：

#include

using namespace std;

typedef int DataType;


//双循环链表的结构体
struct ListNode
{
	ListNode(const DataType& data=DataType())
		:_data(data)
		,next(NULL)
		,pre(NULL)
	{}

	DataType _data;
	ListNode* next;
	ListNode *pre;
};

//双循环链表：
class MyList
{
public:
	//形参数为空的构造函数
	MyList()
	{
		creathead();
	}

	//已知个数和值的构造函数
	MyList(size_t n, const DataType& data = DataType())
	{
		size_t i=0;
		creathead();
		for(i=0;i_data);
		head=p;
		head->next=head->pre=head;
	}

	//赋值运算符重载
	MyList& operator=(const MyList& l)
	{
		if(this!=&l)
		{
			ListNode *p=new ListNode(l.head->_data);
			p->next=p->pre=p;
			delete head;
			head=p;
		}
		return *this;
	}

	//capacity:

	//求个数
	size_t size()
	{
		size_t n=0;
		ListNode* p=head->next;
		while(p!=head)
		{
			n++;
			p=p->next;
		}
		return n;
	}

	//判空
	bool empty()
	{
		return head->next==head;
	}

	//清空
	void clear()
	{
		ListNode *p=head->next;
		ListNode* q=head;
		while(p!=head)
		{
			head->next=p->next;
			delete p;
			p=head->next;
		}
		head->next=head;
		head->pre=head;
	}

	//给出新的大小进行操作。
	void ReSize(size_t newSize, const DataType& data = DataType())
	{
		size_t n=size();
		if(newSize<=n)
		{
			while(newSizenext->_data;
	}

	const DataType& front()const
	{
        return head->next->_data;
	}

	//求最后一个值
	DataType& back()
	{
		return head->pre->_data;
	}

	const DataType& back()const
	{
        return head->pre->_data;
	}


	//modify

	//尾插
	void PushBack(const DataType& d)
	{
		ListNode *pnew=new ListNode(d);
		ListNode *p=head->pre;
		p->next=pnew;
		head->pre=pnew;
		pnew->next=head;
		pnew->pre=p;
	}

	//尾删
	void PopBack()
	{
		ListNode *p=head->pre;
		if(p!=head){
		head->pre=p->pre;
		p->pre->next=head;
		delete p;
		}
	}

	//头插
	void PushFront(const DataType& data)
	{
		ListNode *pnew=new ListNode(data);
		pnew->pre=head;
		pnew->next=head->next;
		head->next->pre=pnew;
		head->next=pnew;
	}

	//头删
	void Popfront()
	{
		ListNode *p=head->next;
		if(p!=head)
		{
			head->next=p->next;
			p->next->pre=head;
			delete p;
		}
	}

	//任意位置插入
	void Insert(ListNode* pos, const DataType& data)
	{
		ListNode *pnew=new ListNode(data);
		pos->pre->next=pnew;
		pnew->pre=pos->pre;
		pnew->next=pos;
		pos->pre=pnew;

	}

	//任意位置删除
	void Erase(ListNode* pos)
	{
		if(pos)
		{
			pos->pre->next=pos->next;
			pos->next->pre=pos->pre;
			delete pos;
		}
	}

	//查找
	ListNode* Find(const DataType& data)
	{
		ListNode *p=head->next;
		while(p!=head)
		{
			if(p->_data==data)
			{
				return p;
			}
			p=p->next;
		}
	}

private:

	//开辟空间
	void creathead()
	{
		head=new ListNode;
		head->next=head;
		head->pre=head;
	}

	//销毁
	void destroy()
	{
		delete head;
		head=0;
		head->next=head->pre=NULL;
	}

	//输出运算符重载
	friend ostream& operator<<(ostream& _cout, const MyList& l)
	{
		ListNode* pCur = l.head->next;
		while(pCur != l.head)
		{
			cout<_data<<" ";
			pCur = pCur->next;
		}

		return _cout;
	}


private:
	ListNode* head;
};
int main()
{
	MyList m1;
	MyList m2(10,5);
	cout<

这就是双循环链表封装后的代码了，总的来说，这两个数据结构并不难，但是还是需要大家多多练习，这样才能熟练掌握。

谢谢观赏