【单链表】链表的建立及基本操作

链表类的定义和部分成员函数实现已经给出。请根据main函数中的调用，补充输出和删除两个成员函数。

输入时，根据endtag确定是否结束输入；

删除时，位置是从0开始；

注意：输入的顺序跟存放的顺序以及输出的顺序是相反的。

输入

1 2 3 4 5 0
2

输出

5 4 3 2 1
5 4 2 1

代码

#include <iostream>

using namespace std;

class List; //前视定义,否则友元无法定义

class LinkNode

{
    friend  List; //链表结点类的定义

private:

    LinkNode *link;

    int data;

public:

    LinkNode(const int & item, LinkNode *ptr = NULL)
    {
        data=item;
        link=ptr;
    }

    LinkNode (LinkNode *ptr = NULL)
    {
        link=ptr;
    }

    ~LinkNode() { };

};

class List

{
    //单链表类的定义

private:

    LinkNode *first; //指向首结点的指针

public:

    List ()
    {
        first = new LinkNode ();
    }

    ~List ()
    {
        MakeEmpty();   //析构函数
    }

    void MakeEmpty ( );      //链表置空

    int Remove ( int i );     //需要补充的成员函数

    void input(int  endTag);

    void output();      //需要补充的成员函数

};

void List:: MakeEmpty ( )

{
    LinkNode *q;

    while (  first->link != NULL )//从后往前删除

    {
        q = first->link;  //指针q指向上一节点

        first->link = q->link;//first->link指向原节点的上一节点

        delete q;

    }

};

void List :: input (int endTag)

{
    LinkNode  *newnode;
    int val;

    cin>>val;

    while(val!=endTag)

    {
        newnode=new LinkNode (val);   //创建一个新的节点

        newnode->link=first->link;    //新节点的指针域指向上一节点

        first->link=newnode;          //first->link指向新加入的节点

        cin>>val;

    }

}

//所需补充的函数部分
/
void List :: output ()//输出
{
    LinkNode  *p=first->link;//首先指针p指向链表末尾节点
    bool flag=0;
    while(p!=NULL)
    {
        if(flag)
            cout<<' ';
        cout<<p->data;
        p=p->link;         //指针p往前移动
        flag=1;
    }
    cout<<endl;


}

int List :: Remove(int i)
{
    LinkNode  *p=first->link;
    if(i==0)                  //当删除的是链表末尾时，将first->link直接指向末尾节点的前一变量
    {
        first->link=p->link;
    }
    else
    {
        int num=0;               //计数变量，计算指针p往前移动了多少个节点
        while(num < i-1&&p->link!=NULL)//至所需删除节点的前一个节点跳出循环
        {

            p=p->link;
            num++;
        }
        LinkNode  *q=p->link->link; //将p指针所指节点往下移动，使所需删除节点前后两个节点链接
        p->link=q;
    }

    return 0;


}

///

int main()

{
    List l;

    l.input(0); //0为输入的结束数字

    l.output ();

    int index;

    cin>>index; //要删除的元素的下标，下标从0 开始

    l.Remove(index);

    l.output (); //删除后输出

    return 0;

}

==========================================================

问题描述：

1）实现链表的排序(升序)

2）实现两个有序链表的合并：A=A∪B，要求合并后仍然有序。

提交前请将所有的提示信息去掉，只保留最后的输出结果。例如运行时：从键盘直接输入：

2 1 2
3 1 2 3 

输出结果为：

1
2
3

分别表示第一个链表元素个数为2，元素分别为 1,2 ；第二个链表元素个数为3，元素分别为1,2,3。

输入

2 2 1
3 1 2 3

输出

1
2
3

代码

#include <iostream>

using namespace std;

class List; //前视定义,否则友元无法定义

class LinkNode

{
    friend  List; //链表结点类的定义

private:

    LinkNode *link;

    int data;

public:

    LinkNode(const int & item, LinkNode *ptr = NULL)
    {
        data=item;
        link=ptr;
    }

    LinkNode (LinkNode *ptr = NULL)
    {
        link=ptr;
    }

    ~LinkNode() { };

};

class List

{
    //单链表类的定义

private:

    LinkNode *first; //指向首结点的指针

public:

    List ()
    {
        first = new LinkNode ();
    }

    ~List ()
    {
        MakeEmpty();   //析构函数
    }

    void MakeEmpty ( );      //链表置空

    int Remove ( int i );     //删除

    bool Search ( int x );      //搜索

    void input();               //输入

    void output();      //输出

    void sortlist();        //排序（冒泡）

    void unions(List &A);  //并运算

};

void List:: MakeEmpty ( )

{
    LinkNode *q;

    while (  first->link != NULL )//从后往前删除

    {
        q = first->link;  //指针q指向上一节点

        first->link = q->link;//first->link指向原节点的上一节点

        delete q;

    }

};

void List :: input ()

{
    LinkNode  *newnode;
    int num;
    int val;
    cin>>num;

    while(num--)

    {
        cin>>val;
        newnode=new LinkNode (val);   //创建一个新的节点

        newnode->link=first->link;    //新节点的指针域指向上一节点

        first->link=newnode;          //first->link指向新加入的节点



    }

}



void List :: output ()//输出
{
    LinkNode  *p=first->link;//首先指针p指向链表末尾节点

    while(p!=NULL)
    {

        cout<<p->data<<endl;
        p=p->link;         //指针p往前移动

    }



}

int List :: Remove(int i)
{
    LinkNode  *p=first->link;
    if(i==0)                  //当删除的是链表末尾时，将first->link直接指向末尾节点的前一变量
    {
        first->link=p->link;
    }
    else
    {
        int num=0;               //计数变量，计算指针p往前移动了多少个节点
        while(num < i-1&&p->link!=NULL)//至所需删除节点的前一个节点跳出循环
        {

            p=p->link;
            num++;
        }
        LinkNode  *q=p->link->link; //将p指针所指节点往下移动，使所需删除节点前后两个节点链接
        p->link=q;
    }

    return 0;


}

bool List :: Search(int x)
{
    LinkNode *p=first->link;
    while(p!=NULL)
    {
        if(p->data==x)
        {
            return true ;
        }
        else p=p->link;
    }
    return false;
}

void List :: sortlist ()//冒泡法
{
    LinkNode *p1=first->link;
    LinkNode *p2=first->link;

    if(first->link==NULL)
    {
        return ;
    }

    for(;p1->link!=NULL;p1=p1->link)  //n次循环，每次循环进行一次相邻数值比较
    {
        for(p2=first->link;p2->link!=NULL;p2=p2->link)//相邻数值比较
        {
            if(p2->data > p2->link->data)
            {
                int tmp=p2->data;
                p2->data=p2->link->data;
                p2->link->data=tmp;
            }
        }
    }

}

void List :: unions(List &A)  //并运算
{
    LinkNode  *p=A.first->link;
    LinkNode  *newnode;
    while(p!=NULL)//在原单链表中依次检索第二个单链表数值，未找到既加入原单链表
    {

        if(!Search(p->data))//未找到
        {
            newnode=new LinkNode (p->data);

            newnode->link=first->link;

            first->link=newnode;

        }
        p=p->link;

    }
}

int main()

{
    List l;
    List r;

    l.input();

    r.input();

    l.unions(r);
   l.sortlist();

    l.output ();

    return 0;

}