双链表的实现，插入，删除，遍历，析构

定义有序的双链表类,链表中存储整型数据，创建带头结点的有序双链表，要求包含以下成员函数：

双链表的构造函数（非空的链表，输入数据为0,表示输入结束）

插入操作（将一个数据元素插入到有序的双链表中，插入之后链表仍然有序，输入数据为0表示插入操作结束）

按值删除节点（考虑有重复值的情况）

双链表的遍历操作

双链表的析构

#include <iostream>
#include<algorithm>
using namespace std;
struct node
{
	int data;
	node* prior, * next;
};

class dlist
{
public:

	dlist(int a[], int n);
	void inset(int n);
	void Delete(int n);
	void print();
	~dlist();
private:
	node* first;
	int sum;
};

dlist::dlist(int a[], int n)
{
	sum = n;
	node* p;
	first = new node;
	first->next = NULL;
	first->prior = NULL;
	p = first;
	for (int i = 0; i <n; i++)
	{
		node* s = NULL;
		s = new node;
		s->data = a[i];
		s->prior = p;
		s->next = NULL;
		p->next = s;
		p = s;
	}
	p->next = NULL;
}

void dlist::inset(int n)//插入
{
	node* p,* q;
	int flag = 0;
	q = first;
	p = first->next;
	while (p != NULL)
	{
		if (n <= p->data)
		{
			node* s = new node;
			s->data = n;
			s->next = p;
			s->prior = p->prior;
			p->prior->next = s;
			p->prior = s;
			sum++;
			flag = 1;
			break;
		}
		q = q->next;
		p = p->next;
	}
	if (flag == 0)
	{
		node* s = new node;
		s->next = q->next;
		s->data = n;
		s->prior = q;
		q->next = s;
		sum++;
	}
}

void dlist::Delete(int n)
{
	int h1 = sum;
	node* p = first->next;
	node* q;

	while (p != NULL)
	{
		if (p->data == n)
		{
			q = p;
			p->prior->next = p->next;
			if (p->next != NULL)
				p->next->prior = p->prior;
			delete q;

			sum--;
		}
		p = p->next;
	}
}

void dlist::print()
{
	node* p = first->next;
	while (p!= NULL)
	{
		cout << p->data << " ";
		p = p->next;
	}
	cout <<endl;
}

dlist::~dlist()
{
	node* p = first;
	while (p != NULL)
	{
		first = first->next;
		delete p;
		p = first;
	}
}
int main()
{
	int a[10000], i = 0;
	int x, xx;
	while (cin >> a[i]&&a[i]!=0)
	{
		i++;
	}
	sort(a, a + i);
	dlist l(a, i);
	l.print();
	while (cin >> x && x != 0)
	{
		l.inset(x);
	}
	l.print();
	while (cin >> xx && xx != 0)
	{
		l.Delete(xx);
	}
	l.print();
}