【数据结构】有序的双链表的实现

描述

定义有序的双链表类,链表中存储整型数据，创建带头结点的有序双链表，要求包含以下成员函数：
双链表的构造函数（非空的链表，输入数据为0,表示输入结束）
插入操作（将一个数据元素插入到有序的双链表中，插入之后链表仍然有序，输入数据为0表示插入操作结束）
按值删除节点（考虑有重复值的情况）
双链表的遍历操作
双链表的析构

输入

输入链表中的元素，根据输入元素，创建有序双链表（非空的链表，输入数据为0,表示输入结束）
输入要插入的值(可以插入多个值，0表示输入结束，)
输入要删除的值（可以删除多个值，0表示结束，）

输出

输出创建的结果
输出插入的结果
输出删除之后的结果

#include <iostream>
#include<algorithm>

using namespace std;
/*
输入链表中的元素，根据输入元素，创建有序双链表（非空的链表，输入数据为0,表示输入结束）
输入要插入的值(可以插入多个值，0表示输入结束，)
输入要删除的值（可以删除多个值，0表示结束，）*/
template <class t>
struct node
{
    t data;
    node <t> *rlink;
    node <t> *llink;
};

template <class t>
class list
{

private:
    node<t> *first;
public:
    list();
    list(int a[],int n);
    void insert(int a[],int n);
    void print();
    void cha(int a[],int n);
    void d(int a[],int n);
};
template <class t>
list<t>::list()
{
    first=new node<t>;
    first->rlink=NULL;
    first->llink=NULL;

}
template <class t>
list<t>::list(int a[],int n)
{
    first=new node<t>;
    first->llink=NULL;
    first->rlink=NULL;
    for(int i=0; i<n; i++)
    {
        node <t> *s=NULL;
        s=new node<t>;
        s->data=a[i];
        s->rlink=first->rlink;
        first->rlink=s;
        s->llink=first;
        if(s->rlink)
            s->rlink->llink=s;
    }
}

template <class t>

void list<t> ::print ()
{
    node <t> *p;
    p=first->rlink;
    while (p!=NULL)
    {
        cout<<p->data<<" ";
        p=p->rlink;
    }

}

template <class t>
void list <t>::cha(int a[],int n)
{

    for(int i=0; i<n; i++)
    {
        node<t> *p=first,*q=first->rlink;
        while(p->rlink!=NULL)
        {
            q=p->rlink;
            if(q->data>a[i])
            {
                node<t> *s;
                s=new node<t>;
                s->data=a[i];
                s->rlink=q;
                q->llink=s;
                p->rlink=s;
                s->llink=p;
                break;
            }
            p=p->rlink;
        }
        if(p->rlink==NULL)
        {
            node <t>*s;
            s=new node<t>;
            s->data=a[i];
            s->rlink=NULL;
            p->rlink=s;
            s->llink=p;
        }
    }


}
template <class t>
void list <t>::d(int a[],int n)
{
    int i;

    for( i=0; i<n; i++)
    {
        node<t> *p=first->rlink;
        while(p->rlink!=NULL)
        {
            if(p->data==a[i])
            {
                p->llink->rlink=p->rlink;
                p->rlink->llink=p->llink;
                delete p;
            }
            p=p->rlink;
        }
        if(p->rlink==NULL&&p->data==a[i])
        {
            p->llink->rlink=NULL;
            delete p;
        }
    }

}
bool cmp(int a,int b)
{

    return a>b;
}
int main()
{
    int a1[100];
    int a2[100];
    int a3[100];
    int t,x;
    int i=0;
    while (cin>>t&&t)
    {
        a1[i]=t;
        i++;
    }
    sort(a1,a1+i,cmp);
    list <int> a(a1,i);
    a.print();
    cout<<endl;
    int j=0;
    while (cin>>t&&t)
    {
        a2[j]=t;
        j++;
    }
    a.cha(a2,j);
    a.print ();
    cout<<endl;
    int k=0;
    while (cin>>t&&t)
    {
        a3[k]=t;
        k++;
    }

    a.d(a3,k);
    a.print ();
}