单链表与有序双链表的实现

单链表的实现：

描述
定义单链表类，创建带头结点的单链表（节点类型为整型数据），要求包含以下成员函数：
头插法创建单链表(利用构造函数实现)
尾插法创建单链表(重载构造函数实现)
链表的遍历
按值删除一个节点
按位置删除一个节点
链表的析构
输入
输入一组数据，以尾插法的形式创建单链表（０表示输入结束）（构造第一个链表）
输入一组数据，以头插法的形式创建单链表（０表示输入结束）（构造第二个链表）
输入要删除元素的值（在尾插法创建的链表中进行改操作）
输入要删除元素的位置（在尾插法创建的链表中进行改操作）
输出
输出尾插法创建链表的结果
输出头插法插法创建链表的结果
输出按值删除之后链表中剩余的元素（若删除的元素不存在，输出Error）
输出按位置删除之后链表中剩余的元素（若删除的元素不存在，输出Error
样例输入

1 2 3 4 5　０　
1 2 3 4 5　０
2
0

样例输出

1 2 3 4 5
5 4 3 2 1
1 3 4 5
Error

代码：

#include<iostream>
#include<cstdio>
#include<algorithm>

using namespace std;
struct Node
{
    int data;
    Node *next;
    Node(){}
};

class List{
    Node *first;//头插
    Node *head;//尾插
public:
    List(){}
    List(int a[],int n);//头插法
    List(int a[],int n,int m);//尾插法
    void Listdel(int n);//按位查找
    void Listremove(int num);//按值查找
};

List::List(int a[],int n)
{
    Node *s;
    first=new Node();  //带头节点的
    first->next=NULL;
    for(int i=1;i<=n;i++){
        s=new Node();
        s->data=a[i];
        s->next=first->next;
        first->next=s;
    }
    Node *p;
    p=first->next;  //设立指针p并移动指针输出
    while(p!=NULL){
        cout<<p->data<<" ";
        p=p->next;
    }
}
List::List(int a[],int n,int num){
    Node *s,*p;
    head=new Node();  //带尾节点的
    p=head;
    for(int i=1;i<=n;i++){
        s=new Node();
        s->data=a[i];
        p->next=s;
        p=s;
    }
    p->next=NULL;
    Node *q;
    q=head->next;  //设立指针q并移动指针输出
    while(q!=NULL){
        cout<<q->data<<" ";
        q=q->next;
    }
}
void List::Listdel(int n)//按位
{
    Node *p;
    int count=0,flag=0;
    p=head;
    while(p->next!=NULL){
        count++;
        if(count==n){
            p->next=p->next->next;
            flag=1;
            break;
        }
        p=p->next;
    }
    if(!flag) cout<<"Error";
    else{
        Node *q;
        q=head;
        while(q->next!=NULL){
        cout<<q->next->data<<" ";
        q=q->next;
        }
    }
}
void List::Listremove(int num){
    Node *p;
    int flag=0;
    p=head;
    while(p->next!=NULL){
        if(p->next->data==num){
            p->next=p->next->next;
            flag=1;
        }
        p=p->next;
    }
    if(!flag) cout<<"Error";
    else{
        Node *q;
        q=head;
        while(q->next!=NULL){
        cout<<q->next->data<<" ";
        q=q->next;
        }
    }
}
int a[1000001],b[1000001];
int main()
{
    int n=0,num,tmp;
    while(cin>>tmp&&tmp) a[++n]=tmp;
    List ob1(a,n,1);
    cout<<endl;
    n=0;
    while(cin>>tmp&&tmp) a[++n]=tmp;
    List ob2(a,n);
    cout<<endl;
    cin>>num;
    ob1.Listremove(num);
    cout<<endl;
    cin>>num;
    ob1.Listdel(num);
    cout<<endl;

}

有序的双链表的实现：

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

1 6 3 7 5 9 0
8 0
2 0

样例输出

1 3 5 6 7 9
1 3 5 6 7 8 9
1 3 5 6 7 8 9

代码：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>

using namespace std;
struct Node
{
    int data;
    Node *pre,*next;
    Node(){}
};
class List
{
    Node *first;
public:
    List() {}
    List(int a[],int n);
    void in(int a[],int n);
    void del(int a[],int n);
    void out();
    ~List() {}
};
void List::out(){
    Node *p;
    p=first->next;
    while(p!=NULL){
        cout<<p->data<<" ";
        p=p->next;
    }
}
List::List(int a[],int n){
    if(n){
    first=new Node();
    first->next=NULL;
    Node *s,*p;
    s=new Node();
    s->data=a[1];
    s->next=first->next;
    first->next=s;
    for(int i=2; i<=n; i++){
        p=first;
        int flag=0;
        s=new Node();
        s->data=a[i];
        while(p->next!=NULL){
            if(p->next->data>=a[i]){
                s->next=p->next;
                p->next=s;
                flag=1;
                break;
            }
            p=p->next;
        }
        if(!flag){
            s->next=p->next;
            p->next=s;
        }
    }
    out();
    }
}
void List::in(int a[],int n){
    Node *p,*s;
    for(int i=1; i<=n; i++){
        p=first;
        int flag=0;
        s=new Node();
        s->data=a[i];
        while(p->next!=NULL){
            if(p->next->data>=a[i]){
                s->next=p->next;
                p->next=s;
                flag=1;
                break;
            }
            p=p->next;
        }
        if(!flag){
            s->next=p->next;
            p->next=s;
        }
    }
    out();
}
void List::del(int a[],int n){
    Node *p,*s;
    for(int i=1;i<=n;i++){
        p=first;
        while(p->next!=NULL){
            if(p->next->data==a[i]){
                s=p->next;
                p->next=p->next->next;
                delete s;
                continue;
            }
            p=p->next;
        }
    }
    out();
}
int a[100000],n,m,tmp;
int main()
{
    while(cin>>tmp&&tmp) a[++n]=tmp;
    List ob(a,n);cout<<endl;
    n=0;
    while(cin>>tmp&&tmp) a[++n]=tmp;
    ob.in(a,n);cout<<endl;
    n=0;
    while(cin>>tmp&&tmp) a[++n]=tmp;
    ob.del(a,n);cout<<endl;
}