链表操作---面向过程--到---面型对象---到模板类

最新推荐文章于 2024-07-19 22:46:50 发布
最新推荐文章于 2024-07-19 22:46:50 发布
阅读量59 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/beautiful-code/p/5239275.html
版权

设计一个链表操作，从分设计到实现分别从3个step进行  （1）面向过程的程序设计---结构体+函数

/*
链表操作-----step1-----用结构体实现链表操作

链表设计----需求分析
1。创建
2。插入
3。遍历
4。获取长度
5。链接两个链表
6。可以实现插入多个类型的目的---未实现，用类封装后用模板实现
7。根据index来获取数据
8。增加一个排序的功能
9。将以上功能用类进行封装------未实现
*/
#include <iostream>
using namespace std;

struct Node   //链表节点声明
{
public:
    int date;
    Node * next;
};

Node * creat_List()  //创建链表，返回该链表的头指针
{
    Node * head=NULL;  //链表头节点
    Node * p=NULL; 
    int  count; //要创建的链表节点个数
    cout<<"please input the size of the list :";
    cin>>count;    
    while(count<0)
    {  
        cout<<"Warning: the size of list is not smaller than 0,please input again:";
        cin>>count;
    }
    cout<<"the size of list is "<<count<<endl;
    if(count==0)
        return head;  
    while(count--)
    {
        cout<<"the value is ";
        Node * s=new Node;
        cin>>s->date;
        s->next=NULL;
        if(head==NULL) //如果是第一个节点
        { head=s;
        p=s; //p指向当前链表中的最后一个节点
        }
        else  //如果不是第一个节点
        {
            p->next=s;
            p=s; //p指向当前链表中的最后一个节点
        }
    }
    cout<<"create a list successful!"<<endl<<endl;
    return head;
}

int getvalue_List(Node * head,int index) //根据index值获取节点数据
{
    
    if(index==0)
        return head->date;
    int i=0;
    Node * p=head;
    for(i=0;i<index;i++)
        p=p->next;
    return p->date;       
}

void print_List(Node * head)  //遍历链表
{
    Node * p=head;
    if(head==NULL)  //判断是否为空链表
    { cout<<"the list is empty!"<<endl;
    return ;  
    }
    while(p->next!=NULL)  //遍历链表，输出各个节点数据
    { cout<<p->date<<" "; 
    p=p->next;
    }
    cout<<p->date;
    cout<<endl;
    cout<<"print list finished!"<<endl<<endl;
}

int length_List(Node * head)  //获取链表长度（链表中节点数）
{
    if(head==NULL)
        return 0;
    int length=0;
    Node * p=head;
    while(p->next!=NULL)
    {length++;
    p=p->next;
    }
    return length+1;
}

Node * insert_List(Node * head) //插入多个节点
{
    int count=0; //记录总共插入的节点个数
    char flag='y';
    cout<<"do you want to insert a new node? (input \'y\' to insert,inputt \'n\' to exit )"<<endl;
    cin>>flag;
    Node * s=NULL; //指向要插入的节点
    Node * p=NULL; //指向要插入的节点位置
    Node * q=NULL; //指向要插入的节点位置的前一个位置
    while(flag=='y')
    {
        s=new Node;
        cout<<"the value is ";
        cin>>s->date;
        s->next=NULL;
        p=head;
        if(head==NULL)
            head=s;
        else
        {
            if (s->date<p->date) //要插入的节点比头节点数据还小
            {
                s->next=p;
                head=s;
            }
            else 
            {
                while(s->date>p->date&&p->next!=NULL)
                { q=p;
                p=p->next;
                }
                if(p->next!=NULL)
                {
                    s->next=p;
                    q->next=s;
                }
                if(p->next==NULL)
                {
                    if(s->date>p->date)
                        p->next=s;
                    else
                    {
                        s->next=p;
                        q->next=s;
                    }
                }
            }        
        }
        count++;
        cout<<"Insert a new node again? (input \'y\' to insert,input \'n\' to exit )"<<endl;
        cin>>flag;
    }
    cout<<"insert "<<count<<" nodes successful!"<<endl<<endl;
    return head;
}


Node * insert_Node(Node * head,Node * s) //插入一个节点,s指向要插入的节点，找到比s数据大的节点前插入
{
    //Node * s=NULL; 
    Node * p=NULL; //指向要插入的节点位置
    Node * q=NULL; //指向要插入的节点位置的前一个位置
    
    s->next=NULL;
    p=head;
    if(head==NULL)
        head=s;
    else
    {
        if (s->date<p->date) //要插入的节点比头节点数据还小
        {
            s->next=p;
            head=s;
        }
        else 
        {
            while(s->date>p->date&&p->next!=NULL)
            { q=p;
            p=p->next;
            }
            if(p->next!=NULL)
            {
                s->next=p;
                q->next=s;
            }
            if(p->next==NULL)
            {
                if(s->date>p->date)
                    p->next=s;
                else
                {
                    s->next=p;
                    q->next=s;
                }
            }
        }        
    }
    //cout<<"insert a node successful!"<<endl<<endl;    
    return head;
}

Node * link_Lists(Node * list1,Node * list2) //将list2链表链接到list1后面
{
    if(list1==NULL)
        return list2;
    if(list2==NULL)
        return list1;
    Node * p=list1;
    while(p->next!=NULL)
        p=p->next;
    p->next=list2;
    cout<<"the link of the two lists successful!"<<endl<<endl;
    return list1;
}


Node * delete_List(Node * head)   //删除链表
{   int count=0;
    if(head==NULL)
    {cout<<"the list is empty ,no node to delete!"<<endl;
    return head;
    }
    Node * p;
    while(head!=NULL)
    {
        p=head;
        head=head->next;
        delete p;
        count++;
    }
    cout<<"delete "<<count<<" nodes"<<"from list successful!"<<endl<<endl;
    return head;
}

//排序思路
//将无序链表从第一个节点开始依次插入到一个开始为空的空链表上（插入函数要先找到要插入的位置）
Node * list_sort(Node * head)//链表排序
{     
    Node  * head_sort=NULL;
    if(head==NULL)
        return head;
    Node * p;
    //Node * q;
    while(head!=NULL)
    {   p=head;  //将p指向的节点从原链表中删除
        head=head->next; //原链表头节点后移
        p->next=NULL; //将p与原链表中的下一个节点断开
        head_sort=insert_Node(head_sort,p);
    }
    cout<<"the sort of list successful!"<<endl<<endl;
    return head_sort;
}

int main()
{   //创建第一个链表，并对其进行相应操作
    cout<<"create  the first list......: list1"<<endl;
    Node * head1=NULL;  //链表头节点    
    head1=creat_List();  //创建链表
    
    print_List(head1); //遍历链表
    
    cout<<"the length of the list1 is "<<length_List(head1)<<endl<<endl; //链表长度
    
    head1=insert_List(head1); //向链表中插入多个节点
    
    print_List(head1); //遍历链表
    
    cout<<"the length of the list1 is "<<length_List(head1)<<endl<<endl; //链表长度   
    
    int index;
    int length=length_List(head1);
    
    if(head1!=NULL)
    {
        //cout<<"请输入要查找的链表list1的index值，注意index>=0 且 index<"<<length<<endl<<endl;
        cout<<"please input the index of list1(index>=0  index<"<<length<<"):";
        cin>>index;
        while(index<0||index>=length)  //判断index是否合理
        {
            cout<<"the index is not right,please input the index again :";
            cin>>index;
        }
        cout<<"the index="<<index<<" node value="<<getvalue_List(head1,index)<<endl<<endl;
    }
    else
    { 
        cout<<"the list is empty，the index operation not work!"<<endl;
    }
    
    //增加一个新节点
    Node * p=new Node;
    cout<<"please input the data of the new insert node:";
    cin>>p->date;
    p->next=NULL;
    head1=insert_Node(head1,p);
    print_List(head1); //遍历链表
    cout<<"the length of the list1 is "<<length_List(head1)<<endl<<endl; //链表长度
    
    //对链表进行排序
    head1=list_sort(head1);
    print_List(head1); //遍历链表
    cout<<"the length of the list1 is "<<length_List(head1)<<endl<<endl; //链表长度
    
    
    
    
    //创建第二个链表，并对其进行相应操作
    cout<<"create  the second list......: list2"<<endl;
    Node * head2=NULL;  //链表头节点    
    head2=creat_List();  //创建链表
    print_List(head2); //遍历链表
    cout<<"the length of the list2 is "<<length_List(head2)<<endl<<endl; //链表长度
    head2=insert_List(head2);
    print_List(head2); //遍历链表
    cout<<"the length of the list2 is "<<length_List(head2)<<endl<<endl; //链表长度
    
    
    cout<<endl<<endl;
    cout<<"create  the third list......: list3"<<endl;
    //创建第三个链表，完成对list1和list2的链接
    Node * head3=NULL;  //链表头节点
    head3=link_Lists(head1,head2);
    print_List(head3); //遍历链表
    cout<<"the length of the list3 is "<<length_List(head3)<<endl<<endl; //链表长度

    head3=list_sort(head3);
    print_List(head3); //遍历链表
    cout<<"the length of the list3 is "<<length_List(head3)<<endl<<endl; //链表长度
    
    
      //删除链表3
    head3=delete_List(head3);  //只需要删除链表3，因为链表3将链表1和链表2链接
    
    return 0;
}

（2）面向对象分析设计-----用类进行封装

/*
链表操作----step2----用类对链表进行封装

链表设计----需求分析
1。创建
2。插入
3。遍历
4。获取长度
5。链接两个链表
6。可以实现插入多个类型的目的---未实现，用类封装后用模板实现
7。根据index来获取数据
8。增加一个排序的功能
9。将以上功能用类进行封装
*/
#include <iostream>
using namespace std;

struct Node   //链表节点声明
{
    int date;
    Node * next;
};

class MyList
{ public:
      Node * head; //链表头指针
      int size;    //链表大小，链表中节点个数
      MyList() //构造函数
      {
          head=NULL;
          size=0;
      }
      void creat_List();  //创建链表，返回该链表的头指针
      Node * get_head();  //返回链表头指针     
      int get_size();  //返回链表大小     
      void print_List();  //遍历链表
      int length_List();  //获取链表长度（链表中节点数）
      int getvalue_List(int index); //根据index值获取节点数据
      void insert_List();//插入多个节点     
      void insert_Node(Node * s);//插入一个节点,s指向要插入的节点，找到比s数据大的节点前插入
      void list_sort();//链表排序
      void delete_List();   //删除链表                                             
      void link_Lists(MyList); //将list链表链接到当前链表后      
      void link_copy(MyList); //链表拷贝(深拷贝)
};

void MyList::creat_List()  //创建链表
{
    head=NULL;  //链表头节点
    Node * p=NULL; 
    int  count; //要创建的链表节点个数
    cout<<"please input the size of the list :";
    cin>>count;    
    while(count<0)
    {  
        cout<<"Warning: the size of list is not smaller than 0,please input again:";
        cin>>count;
    }
    cout<<"the size of list is "<<count<<endl;
    size=count;
    if(count==0)
        return ;  
    while(count--)
    {
        cout<<"the value is ";
        Node * s=new Node;
        cin>>s->date;
        s->next=NULL;
        if(head==NULL) //如果是第一个节点
        { head=s;
        p=s; //p指向当前链表中的最后一个节点
        }
        else  //如果不是第一个节点
        {
            p->next=s;
            p=s; //p指向当前链表中的最后一个节点
        }
    }
    cout<<"create a list successful!"<<endl<<endl;
}


Node * MyList::get_head()  //返回链表头指针
{
    return head;
}

int MyList::get_size()   //返回链表大小
{
    return size;
}


void MyList::print_List( )  //遍历链表
{
    Node * p=head;
    if(head==NULL)  //判断是否为空链表
    { cout<<"the list is empty!"<<endl;
    return ;  
    }
    while(p->next!=NULL)  //遍历链表，输出各个节点数据
    { cout<<p->date<<" "; 
    p=p->next;
    }
    cout<<p->date;
    cout<<endl;
    cout<<"print list finished!"<<endl<<endl;
}

int MyList::length_List( )  //获取链表长度（链表中节点数）
{
    if(head==NULL)
        return 0;
    int length=0;
    Node * p=head;
    while(p->next!=NULL)
    {length++;
    p=p->next;
    }
    return length+1;
    /*
    return size;
    */
}



int MyList::getvalue_List(int index) //根据index值获取节点数据
{
    
    if(index==0)
        return head->date;
    int i=0;
    Node * p=head;
    for(i=0;i<index;i++)
        p=p->next;
    return p->date;       
}


void MyList::insert_List() //插入多个节点
{
    int count=0; //记录总共插入的节点个数
    char flag='y';
    cout<<"do you want to insert a new node? (input \'y\' to insert,input \'n\' to exit )"<<endl;
    cin>>flag;
    Node * s=NULL; //指向要插入的节点
    Node * p=NULL; //指向要插入的节点位置
    Node * q=NULL; //指向要插入的节点位置的前一个位置
    while(flag=='y')
    {
        s=new Node;
        cout<<"the value is ";
        cin>>s->date;
        s->next=NULL;
        p=head;
        if(head==NULL)
            head=s;
        else
        {
            if (s->date<p->date) //要插入的节点比头节点数据还小
            {
                s->next=p;
                head=s;
            }
            else 
            {
                while(s->date>p->date&&p->next!=NULL)
                { q=p;
                p=p->next;
                }
                if(p->next!=NULL)
                {
                    s->next=p;
                    q->next=s;
                }
                if(p->next==NULL)
                {
                    if(s->date>p->date)
                        p->next=s;
                    else
                    {
                        s->next=p;
                        q->next=s;
                    }
                }
            }
        }
        count++;
        cout<<"Insert a new node again? (input \'y\' to insert,input \'n\' to exit )"<<endl;
        cin>>flag;
    }
    size=size+count;
    cout<<"insert "<<count<<" nodes successful!"<<endl<<endl;
}


void  MyList::insert_Node(Node * s) //插入一个节点,s指向要插入的节点，找到比s数据大的节点前插入
{
    
    Node * p=NULL; //指向要插入的节点位置
    Node * q=NULL; //指向要插入的节点位置的前一个位置
    
    s->next=NULL;
    p=head;
    if(head==NULL)
        head=s;
    else
    {
        if (s->date<p->date) //要插入的节点比头节点数据还小
        {
            s->next=p;
            head=s;
        }
        else 
        {
            while(s->date>p->date&&p->next!=NULL)
            { q=p;
            p=p->next;
            }
            if(p->next!=NULL)
            {
                s->next=p;
                q->next=s;
            }
            if(p->next==NULL)
            {
                if(s->date>p->date)
                    p->next=s;
                else
                {
                    s->next=p;
                    q->next=s;
                }
            }
        }        
    }
    size++;
}

//排序思路
//将无序链表从第一个节点开始依次插入到一个开始为空的空链表上（插入函数要先找到要插入的位置）
void MyList::list_sort()//链表排序
{     
    MyList mylist_sort; //定义一个临时MyList变量 mylist_sort，mylist_sort.head=NULL
    if(head==NULL)
        return ;
    Node * p;
    while(head!=NULL)
    {   p=head;  //将p指向的节点从原链表中删除
        head=head->next; //原链表头节点后移
        p->next=NULL; //将p与原链表中的下一个节点断开
        mylist_sort.insert_Node(p); //将从原链表脱离的头节点插入到 mylist_sort对象的链表中
    }
    cout<<"the sort of list successful!"<<endl;
    head=mylist_sort.get_head();
}

void MyList::delete_List()   //删除链表
{   
    int count=0;  //count用来记录要链表上删除的节点个数
    if(head==NULL)
    {
        cout<<"the list is empty ,no node to delete!"<<endl;
        return ;
    }
    Node * p;
    while(head!=NULL)
    {
        p=head;
        head=head->next;
        delete p;
        count++;
    }
    cout<<"delete "<<count<<" nodes"<<" from list successful!"<<endl<<endl;
    size-=count;
}


void MyList::link_Lists(MyList list_after) //将list_after链表链接到当前链表后
{
    if(head==NULL)
    {   this->link_copy(list_after);
        return ;
    }
    if(list_after.get_head()==NULL)
        return ;
    Node * p=head;
    while(p->next!=NULL)
        p=p->next;
    Node *q,*s;
    q=list_after.get_head();//q首先指向被链接的链表的头节点
    int count=list_after.get_size();
    while(count--)
    {   s=new Node;
        s->date=q->date;
        s->next=NULL;
        p->next=s;
        p=s;
        q=q->next;    
    }        
    cout<<"the link of the two lists successful!"<<endl<<endl;    
    size+=list_after.length_List();
}


 void MyList::link_copy(MyList list_copyed)//链表拷贝(深拷贝)
 {
    if(list_copyed.get_head()==NULL)
    {
       head=NULL;
       size=0;
    }
    else
    {
        int count=list_copyed.get_size();
        size=count;
        head=NULL;
        Node * p,*q,*s;
        q=list_copyed.get_head();//q首先指向被拷贝的链表的头节点
        s=new Node;
        p=s;
        head=p;
        while(count--)
        {
          s->date=q->date;
          s->next=NULL;
          if(head==NULL)
          {
              head=s;
              p=s;              
          }
          else
          {
              p->next=s;
              p=s;
          }
          q=q->next;    
          s=new Node;
        }        
    }
 }

int main()
{   //创建第一个链表，并对其进行相应操作
    cout<<"create  the first list......: list1"<<endl;
    MyList mylist1; //建立链表对象mylist1
    mylist1.creat_List();//创建链表
    mylist1.print_List();//遍历链表
    cout<<"the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    cout<<"the size of the list1: "<<mylist1.get_size()<<endl;  //链表长度


    int index;
    int length=mylist1.length_List();
    if(mylist1.get_head()!=NULL)
    {
        cout<<"\nplease input the index of list1 (index>=0  index<"<<length<<"): ";
        cin>>index;
        while(index<0||index>=length)  //判断index是否合理
        {
            cout<<"the index is not right,please input the index again :";
            cin>>index;
        }
        cout<<"the index="<<index<<" node value="<<mylist1.getvalue_List(index)<<endl<<endl;
    }
    else
    { 
        cout<<"the list is empty，the index operation not work!"<<endl;
    }
    
    mylist1.insert_List(); //向链表中插入多个节点
    mylist1.print_List();//遍历链表
    cout<<"the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    cout<<"the size of the list1: "<<mylist1.get_size()<<endl<<endl;  //链表长度
    
    
    Node * p=new Node;//增加一个新节点
    cout<<"please input the data of the new  node insert to list1:";
    cin>>p->date;
    p->next=NULL;
    mylist1.insert_Node(p);
    mylist1.print_List();//遍历链表
    cout<<"the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    cout<<"the size of the list1: "<<mylist1.get_size()<<endl;  //链表长度

      //对链表进行排序
    cout<<"the result of after sorting list1"<<endl;
    mylist1.list_sort();    
    mylist1.print_List();//遍历链表
    cout<<"the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    cout<<"the size of the list1: "<<mylist1.get_size()<<endl<<endl;  //链表长度

        
    //创建第二个链表，并对其进行相应操作
    cout<<"create  the second list......: list2"<<endl;
    MyList mylist2; //建立链表对象mylist2
    mylist2.creat_List();//创建链表
    mylist2.print_List();//遍历链表
    cout<<"the length of the list2: "<<mylist2.length_List()<<endl;  //链表长度
    cout<<"the size of the list2: "<<mylist2.get_size()<<endl<<endl;  //链表长度

    //将链表2链到链表1后
    cout<<"link list1 and list2..."<<endl;    
    mylist1.link_Lists(mylist2);
    mylist1.print_List();//遍历链表
    cout<<"after link the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    cout<<"after link the size of the list1: "<<mylist1.get_size()<<endl<<endl;  //链表长度

    //创建第三个链表，由链表1深拷贝而来
    cout<<"create  the second list......: list3"<<endl;    
    MyList mylist3; //建立链表对象mylist3
    cout<<"list3 is copy from list1"<<endl;
    mylist3.link_copy(mylist1);
    mylist3.print_List();
    cout<<"the length of the list3: "<<mylist3.length_List()<<endl;  //链表长度
    cout<<"the size of the list3: "<<mylist3.get_size()<<endl<<endl;  //链表长度

    cout<<"delete the list1."<<endl;
    mylist1.delete_List(); //删除链表1
    //cout<<"the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    //cout<<"the size of the list1: "<<mylist1.get_size()<<endl<<endl;  //链表长度


    cout<<"delete the list3."<<endl;
    mylist3.delete_List(); //删除链表3
    //cout<<"the length of the list3: "<<mylist3.length_List()<<endl;  //链表长度
    //cout<<"the size of the list3: "<<mylist3.get_size()<<endl<<endl;  //链表长度

    cout<<"delete the list2."<<endl;
    mylist2.delete_List(); //删除链表2
    //cout<<"the length of the list2: "<<mylist2.length_List()<<endl;  //链表长度
    //cout<<"the size of the list2: "<<mylist2.get_size()<<endl<<endl;  //链表长度


    return 0;
}

（3）将具体类用模板类来实现，这样对node数据的类型可以进行指定

/*
链表操作----step3----用类对链表进行封装，再用类模板实现

链表设计----需求分析
1。创建
2。插入
3。遍历
4。获取长度
5。链接两个链表
6。可以实现插入多个类型的目的---用模板实现
7。根据index来获取数据
8。增加一个排序的功能
9。将以上功能用类进行封装
*/
#include <iostream>
using namespace std;

template<class T>
struct Node   //链表节点声明
{
    T date;
    Node<T> * next;
};

template<class T>
class MyList
{ public:
      Node<T> * head; //链表头指针
      int size;    //链表大小，链表中节点个数
      MyList() //构造函数
      {
          head=NULL;
          size=0;
      }
      void creat_List();  //创建链表，返回该链表的头指针
      Node<T> * get_head();  //返回链表头指针     
      int get_size();  //返回链表大小     
      void print_List();  //遍历链表
      int length_List();  //获取链表长度（链表中节点数）
      T getvalue_List(int index); //根据index值获取节点数据
      void insert_List();//插入多个节点     
      void insert_Node(Node<T> * s);//插入一个节点,s指向要插入的节点，找到比s数据大的节点前插入
      void list_sort();//链表排序
      void delete_List();   //删除链表                                             
      void link_Lists(MyList); //将list链表链接到当前链表后      
      void link_copy(MyList); //链表拷贝(深拷贝)
};

template<class T>
void MyList<T>::creat_List()  //创建链表
{
    head=NULL;  //链表头节点
    Node<T> * p=NULL; 
    int  count; //要创建的链表节点个数
    cout<<"please input the size of the list :";
    cin>>count;    
    while(count<0)
    {  
        cout<<"Warning: the size of list is not smaller than 0,please input again:";
        cin>>count;
    }
    cout<<"the size of list is "<<count<<endl;
    size=count;
    if(count==0)
        return ;  
    while(count--)
    {
        cout<<"the value is ";
        Node<T> * s=new Node<T>;
        cin>>s->date;
        s->next=NULL;
        if(head==NULL) //如果是第一个节点
        { head=s;
        p=s; //p指向当前链表中的最后一个节点
        }
        else  //如果不是第一个节点
        {
            p->next=s;
            p=s; //p指向当前链表中的最后一个节点
        }
    }
    cout<<"create a list successful!"<<endl<<endl;
}

template<class T>
Node<T> * MyList<T>::get_head()  //返回链表头指针
{
    return head;
}

template<class T>
int MyList<T>::get_size()   //返回链表大小
{
    return size;
}

template<class T>
void MyList<T>::print_List( )  //遍历链表
{
    Node<T> * p=head;
    if(head==NULL)  //判断是否为空链表
    { cout<<"the list is empty!"<<endl;
    return ;  
    }
    while(p->next!=NULL)  //遍历链表，输出各个节点数据
    { cout<<p->date<<" "; 
    p=p->next;
    }
    cout<<p->date;
    cout<<endl;
    cout<<"print list finished!"<<endl<<endl;
}

template<class T>
int MyList<T>::length_List( )  //获取链表长度（链表中节点数）
{
    if(head==NULL)
        return 0;
    int length=0;
    Node<T> * p=head;
    while(p->next!=NULL)
    {length++;
    p=p->next;
    }
    return length+1;
    /*
    return size;
    */
}


template<class T>
T MyList<T>::getvalue_List(int index) //根据index值获取节点数据
{
    
    if(index==0)
        return head->date;
    int i=0;
    Node<T> * p=head;
    for(i=0;i<index;i++)
        p=p->next;
    return p->date;       
}

template<class T>
void MyList<T>::insert_List() //插入多个节点
{
    int count=0; //记录总共插入的节点个数
    char flag='y';
    cout<<"do you want to insert a new node? (input \'y\' to insert,input \'n\' to exit )"<<endl;
    cin>>flag;
    Node<T> * s=NULL; //指向要插入的节点
    Node<T> * p=NULL; //指向要插入的节点位置
    Node<T> * q=NULL; //指向要插入的节点位置的前一个位置
    while(flag=='y')
    {
        s=new Node<T>;
        cout<<"the value is ";
        cin>>s->date;
        s->next=NULL;
        p=head;
        if(head==NULL)
            head=s;
        else
        {
            if (s->date<p->date) //要插入的节点比头节点数据还小
            {
                s->next=p;
                head=s;
            }
            else 
            {
                while(s->date>p->date&&p->next!=NULL)
                { q=p;
                p=p->next;
                }
                if(p->next!=NULL)
                {
                    s->next=p;
                    q->next=s;
                }
                if(p->next==NULL)
                {
                    if(s->date>p->date)
                        p->next=s;
                    else
                    {
                        s->next=p;
                        q->next=s;
                    }
                }
            }
        }
        count++;
        cout<<"Insert a new node again? (input \'y\' to insert,input \'n\' to exit )"<<endl;
        cin>>flag;
    }
    size=size+count;
    cout<<"insert "<<count<<" nodes successful!"<<endl<<endl;
}

template<class T>
void  MyList<T>::insert_Node(Node<T> * s) //插入一个节点,s指向要插入的节点，找到比s数据大的节点前插入
{
    
    Node<T> * p=NULL; //指向要插入的节点位置
    Node<T> * q=NULL; //指向要插入的节点位置的前一个位置
    
    s->next=NULL;
    p=head;
    if(head==NULL)
        head=s;
    else
    {
        if (s->date<p->date) //要插入的节点比头节点数据还小
        {
            s->next=p;
            head=s;
        }
        else 
        {
            while(s->date>p->date&&p->next!=NULL)
            { q=p;
            p=p->next;
            }
            if(p->next!=NULL)
            {
                s->next=p;
                q->next=s;
            }
            if(p->next==NULL)
            {
                if(s->date>p->date)
                    p->next=s;
                else
                {
                    s->next=p;
                    q->next=s;
                }
            }
        }        
    }
    size++;
}

//排序思路
//将无序链表从第一个节点开始依次插入到一个开始为空的空链表上（插入函数要先找到要插入的位置）
template<class T>
void MyList<T>::list_sort()//链表排序
{     
    MyList<T> mylist_sort; //定义一个临时MyList变量 mylist_sort，mylist_sort.head=NULL
    if(head==NULL)
        return ;
    Node<T> * p;
    while(head!=NULL)
    {   p=head;  //将p指向的节点从原链表中删除
        head=head->next; //原链表头节点后移
        p->next=NULL; //将p与原链表中的下一个节点断开
        mylist_sort.insert_Node(p); //将从原链表脱离的头节点插入到 mylist_sort对象的链表中
    }
    cout<<"the sort of list successful!"<<endl;
    head=mylist_sort.get_head();
}

template<class T>
void MyList<T>::delete_List()   //删除链表
{   
    int count=0;  //count用来记录要链表上删除的节点个数
    if(head==NULL)
    {
        cout<<"the list is empty ,no node to delete!"<<endl;
        return ;
    }
    Node<T> * p;
    while(head!=NULL)
    {
        p=head;
        head=head->next;
        delete p;
        count++;
    }
    cout<<"delete "<<count<<" nodes"<<" from list successful!"<<endl<<endl;
    size-=count;
}

template<class T>
void MyList<T>::link_Lists(MyList list_after) //将list_after链表链接到当前链表后
{
    if(head==NULL)
    {   this->link_copy(list_after);
        return ;
    }
    if(list_after.get_head()==NULL)
        return ;
    Node<T> * p=head;
    while(p->next!=NULL)
        p=p->next;
    Node<T> *q,*s;
    q=list_after.get_head();//q首先指向被链接的链表的头节点
    int count=list_after.get_size();
    while(count--)
    {   s=new Node<T>;
        s->date=q->date;
        s->next=NULL;
        p->next=s;
        p=s;
        q=q->next;    
    }        
    cout<<"the link of the two lists successful!"<<endl<<endl;    
    size+=list_after.length_List();
}


template<class T>
 void MyList<T>::link_copy(MyList list_copyed)//链表拷贝(深拷贝)
 {
    if(list_copyed.get_head()==NULL)
    {
       head=NULL;
       size=0;
    }
    else
    {
        int count=list_copyed.get_size();
        size=count;
        head=NULL;
        Node<T> * p,*q,*s;
        q=list_copyed.get_head();//q首先指向被拷贝的链表的头节点
        s=new Node<T>;
        p=s;
        head=p;
        while(count--)
        {
          s->date=q->date;
          s->next=NULL;
          if(head==NULL)
          {
              head=s;
              p=s;              
          }
          else
          {
              p->next=s;
              p=s;
          }
          q=q->next;    
          s=new Node<T>;
        }        
    }
 }

int main()
{   //创建第一个链表，并对其进行相应操作
    cout<<"create  the first list......: list1"<<endl;
    MyList<char> mylist1; //建立链表对象mylist1
    mylist1.creat_List();//创建链表
    mylist1.print_List();//遍历链表
    cout<<"the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    cout<<"the size of the list1: "<<mylist1.get_size()<<endl;  //链表长度


    int index;
    int length=mylist1.length_List();
    if(mylist1.get_head()!=NULL)
    {
        cout<<"\nplease input the index of list1 (index>=0  index<"<<length<<"): ";
        cin>>index;
        while(index<0||index>=length)  //判断index是否合理
        {
            cout<<"the index is not right,please input the index again :";
            cin>>index;
        }
        cout<<"the index="<<index<<" node value="<<mylist1.getvalue_List(index)<<endl<<endl;
    }
    else
    { 
        cout<<"the list is empty，the index operation not work!"<<endl;
    }
    
    mylist1.insert_List(); //向链表中插入多个节点
    mylist1.print_List();//遍历链表
    cout<<"the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    cout<<"the size of the list1: "<<mylist1.get_size()<<endl<<endl;  //链表长度
    
    
    Node<char> * p=new Node<char>;//增加一个新节点
    cout<<"please input the data of the new  node insert to list1:";
    cin>>p->date;
    p->next=NULL;
    mylist1.insert_Node(p);
    mylist1.print_List();//遍历链表
    cout<<"the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    cout<<"the size of the list1: "<<mylist1.get_size()<<endl;  //链表长度

      //对链表进行排序
    cout<<"the result of after sorting list1"<<endl;
    mylist1.list_sort();    
    mylist1.print_List();//遍历链表
    cout<<"the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    cout<<"the size of the list1: "<<mylist1.get_size()<<endl<<endl;  //链表长度

        
    //创建第二个链表，并对其进行相应操作
    cout<<"create  the second list......: list2"<<endl;
    MyList<char> mylist2; //建立链表对象mylist2
    mylist2.creat_List();//创建链表
    mylist2.print_List();//遍历链表
    cout<<"the length of the list2: "<<mylist2.length_List()<<endl;  //链表长度
    cout<<"the size of the list2: "<<mylist2.get_size()<<endl<<endl;  //链表长度

    //将链表2链到链表1后
    cout<<"link list1 and list2..."<<endl;    
    mylist1.link_Lists(mylist2);
    mylist1.print_List();//遍历链表
    cout<<"after link the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    cout<<"after link the size of the list1: "<<mylist1.get_size()<<endl<<endl;  //链表长度

    //创建第三个链表，由链表1深拷贝而来
    cout<<"create  the third list......: list3"<<endl;    
    MyList<char> mylist3; //建立链表对象mylist3
    cout<<"list3 is copy from list1"<<endl;
    mylist3.link_copy(mylist1);
    mylist3.print_List();
    cout<<"the length of the list3: "<<mylist3.length_List()<<endl;  //链表长度
    cout<<"the size of the list3: "<<mylist3.get_size()<<endl<<endl;  //链表长度

    cout<<"delete the list1."<<endl;
    mylist1.delete_List(); //删除链表1
    //cout<<"the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    //cout<<"the size of the list1: "<<mylist1.get_size()<<endl<<endl;  //链表长度


    cout<<"delete the list3."<<endl;
    mylist3.delete_List(); //删除链表3
    //cout<<"the length of the list3: "<<mylist3.length_List()<<endl;  //链表长度
    //cout<<"the size of the list3: "<<mylist3.get_size()<<endl<<endl;  //链表长度

    cout<<"delete the list2."<<endl;
    mylist2.delete_List(); //删除链表2
    //cout<<"the length of the list2: "<<mylist2.length_List()<<endl;  //链表长度
    //cout<<"the size of the list2: "<<mylist2.get_size()<<endl<<endl;  //链表长度


    return 0;
}

注意：在step2时，我对链表的链接进行了改进，还添加了一个对象拷贝的功能。

(4)

/*
链表操作----step2-2----用类对链表进行封装
在链表操作----step2 的基础上增加运算符重载的相关操作
在step2的基础上
(1)增加了一个拷贝构造函数
(2)增加了<<输出运算符重载函数
(2)增加了+运算符重载函数


链表设计----需求分析
1。创建
2。插入
3。遍历
4。获取长度
5。链接两个链表
6。可以实现插入多个类型的目的---未实现，用类封装后用模板实现
7。根据index来获取数据
8。增加一个排序的功能
9。将以上功能用类进行封装
*/
#include <iostream>
using namespace std;

struct Node   //链表节点声明
{
    int date;
    Node * next;
};

class MyList
{ public:
      Node * head; //链表头指针
      int size;    //链表大小，链表中节点个数
      MyList(); //构造函数
      MyList(MyList & ); //拷贝构造函数
      void creat_List();  //创建链表，返回该链表的头指针
      Node * get_head();  //返回链表头指针     
      int get_size();  //返回链表大小     
      void print_List();  //遍历链表
      int length_List();  //获取链表长度（链表中节点数）
      int getvalue_List(int index); //根据index值获取节点数据
      void insert_List();//插入多个节点     
      void insert_Node(Node * s);//插入一个节点,s指向要插入的节点，找到比s数据大的节点前插入
      void list_sort();//链表排序
      void delete_List();   //删除链表                                             
      void link_Lists(MyList); //将list链表链接到当前链表后      
      void link_copy(MyList); //链表拷贝(深拷贝)

      //运算符重载函数声明
      MyList   operator+(MyList mylist);  //成员函数
      friend ostream & operator<<(ostream & out, MyList & mylist);  //对输出运算符进行重载，友元函数
};

MyList::MyList() //构造函数
{
    head=NULL;
    size=0;
}

MyList::MyList(MyList & list_copyed) //拷贝构造函数,使用深拷贝来拷贝资源，链表上的节点
{  
    if(list_copyed.get_head()==NULL)
   {
       head=NULL;
       size=0;
   }
   else
   {
       int count=list_copyed.get_size();
       size=count;
       head=NULL;
       Node * p,*q,*s;
       q=list_copyed.get_head();//q首先指向被拷贝的链表的头节点
       s=new Node;
       p=s;
       head=p;
       while(count--)
       {
           s->date=q->date;
           s->next=NULL;
           if(head==NULL)
           {
               head=s;
               p=s;              
           }
           else
           {
               p->next=s;
               p=s;
           }
           q=q->next;    
           s=new Node;
       }        
    } 

}

void MyList::creat_List()  //创建链表
{
    head=NULL;  //链表头节点
    Node * p=NULL; 
    int  count; //要创建的链表节点个数
    cout<<"please input the size of the list :";
    cin>>count;    
    while(count<0)
    {  
        cout<<"Warning: the size of list is not smaller than 0,please input again:";
        cin>>count;
    }
    cout<<"the size of list is "<<count<<endl;
    size=count;
    if(count==0)
        return ;  
    while(count--)
    {
        cout<<"the value is ";
        Node * s=new Node;
        cin>>s->date;
        s->next=NULL;
        if(head==NULL) //如果是第一个节点
        { head=s;
        p=s; //p指向当前链表中的最后一个节点
        }
        else  //如果不是第一个节点
        {
            p->next=s;
            p=s; //p指向当前链表中的最后一个节点
        }
    }
    cout<<"create a list successful!"<<endl<<endl;
}


Node * MyList::get_head()  //返回链表头指针
{
    return head;
}

int MyList::get_size()   //返回链表大小
{
    return size;
}


void MyList::print_List( )  //遍历链表
{
    Node * p=head;
    if(head==NULL)  //判断是否为空链表
    { cout<<"the list is empty!"<<endl;
    return ;  
    }
    while(p->next!=NULL)  //遍历链表，输出各个节点数据
    { cout<<p->date<<" "; 
    p=p->next;
    }
    cout<<p->date;
    cout<<endl;
    cout<<"print list finished!"<<endl<<endl;
}

int MyList::length_List( )  //获取链表长度（链表中节点数）
{
    if(head==NULL)
        return 0;
    int length=0;
    Node * p=head;
    while(p->next!=NULL)
    {length++;
    p=p->next;
    }
    return length+1;
    /*
    return size;
    */
}



int MyList::getvalue_List(int index) //根据index值获取节点数据
{
    
    if(index==0)
        return head->date;
    int i=0;
    Node * p=head;
    for(i=0;i<index;i++)
        p=p->next;
    return p->date;       
}


void MyList::insert_List() //插入多个节点
{
    int count=0; //记录总共插入的节点个数
    char flag='y';
    cout<<"do you want to insert a new node? (input \'y\' to insert,input \'n\' to exit )"<<endl;
    cin>>flag;
    Node * s=NULL; //指向要插入的节点
    Node * p=NULL; //指向要插入的节点位置
    Node * q=NULL; //指向要插入的节点位置的前一个位置
    while(flag=='y')
    {
        s=new Node;
        cout<<"the value is ";
        cin>>s->date;
        s->next=NULL;
        p=head;
        if(head==NULL)
            head=s;
        else
        {
            if (s->date<p->date) //要插入的节点比头节点数据还小
            {
                s->next=p;
                head=s;
            }
            else 
            {
                while(s->date>p->date&&p->next!=NULL)
                { q=p;
                p=p->next;
                }
                if(p->next!=NULL)
                {
                    s->next=p;
                    q->next=s;
                }
                if(p->next==NULL)
                {
                    if(s->date>p->date)
                        p->next=s;
                    else
                    {
                        s->next=p;
                        q->next=s;
                    }
                }
            }
        }
        count++;
        cout<<"Insert a new node again? (input \'y\' to insert,input \'n\' to exit )"<<endl;
        cin>>flag;
    }
    size=size+count;
    cout<<"insert "<<count<<" nodes successful!"<<endl<<endl;
}


void  MyList::insert_Node(Node * s) //插入一个节点,s指向要插入的节点，找到比s数据大的节点前插入
{
    
    Node * p=NULL; //指向要插入的节点位置
    Node * q=NULL; //指向要插入的节点位置的前一个位置
    
    s->next=NULL;
    p=head;
    if(head==NULL)
        head=s;
    else
    {
        if (s->date<p->date) //要插入的节点比头节点数据还小
        {
            s->next=p;
            head=s;
        }
        else 
        {
            while(s->date>p->date&&p->next!=NULL)
            { q=p;
            p=p->next;
            }
            if(p->next!=NULL)
            {
                s->next=p;
                q->next=s;
            }
            if(p->next==NULL)
            {
                if(s->date>p->date)
                    p->next=s;
                else
                {
                    s->next=p;
                    q->next=s;
                }
            }
        }        
    }
    size++;
}

//排序思路
//将无序链表从第一个节点开始依次插入到一个开始为空的空链表上（插入函数要先找到要插入的位置）
void MyList::list_sort()//链表排序
{     
    MyList mylist_sort; //定义一个临时MyList变量 mylist_sort，mylist_sort.head=NULL
    if(head==NULL)
        return ;
    Node * p;
    while(head!=NULL)
    {   p=head;  //将p指向的节点从原链表中删除
        head=head->next; //原链表头节点后移
        p->next=NULL; //将p与原链表中的下一个节点断开
        mylist_sort.insert_Node(p); //将从原链表脱离的头节点插入到 mylist_sort对象的链表中
    }
    cout<<"the sort of list successful!"<<endl;
    head=mylist_sort.get_head();
}

void MyList::delete_List()   //删除链表
{   
    int count=0;  //count用来记录要链表上删除的节点个数
    if(head==NULL)
    {
        cout<<"the list is empty ,no node to delete!"<<endl;
        return ;
    }
    Node * p;
    while(head!=NULL)
    {
        p=head;
        head=head->next;
        delete p;
        count++;
    }
    cout<<"delete "<<count<<" nodes"<<" from list successful!"<<endl<<endl;
    size-=count;
}


void MyList::link_Lists(MyList list_after) //将list_after链表链接到当前链表后
{
    if(head==NULL)
    {   this->link_copy(list_after);
        return ;
    }
    if(list_after.get_head()==NULL)
        return ;
    Node * p=head;
    while(p->next!=NULL)
        p=p->next;
    Node *q,*s;
    q=list_after.get_head();//q首先指向被链接的链表的头节点
    int count=list_after.get_size();
    while(count--)
    {   s=new Node;
        s->date=q->date;
        s->next=NULL;
        p->next=s;
        p=s;
        q=q->next;    
    }        
    cout<<"the link of the two lists successful!"<<endl<<endl;    
    size+=list_after.length_List();
}


 void MyList::link_copy(MyList list_copyed)//链表拷贝(深拷贝)
 {
    if(list_copyed.get_head()==NULL)
    {
       head=NULL;
       size=0;
    }
    else
    {
        int count=list_copyed.get_size();
        size=count;
        head=NULL;
        Node * p,*q,*s;
        q=list_copyed.get_head();//q首先指向被拷贝的链表的头节点
        s=new Node;
        p=s;
        head=p;
        while(count--)
        {
          s->date=q->date;
          s->next=NULL;
          if(head==NULL)
          {
              head=s;
              p=s;              
          }
          else
          {
              p->next=s;
              p=s;
          }
          q=q->next;    
          s=new Node;
        }        
    }
 }

//运算符重载函数定义

 MyList   MyList::operator+(MyList list_after)  //+运算符重载函数作为MyList的成员函数
 {
     MyList  result;

     if(this->head==NULL)
     {   result.link_copy(list_after);
         result.size=list_after.get_size();             
         return result;
     }

     if(list_after.get_head()==NULL)
     { 
         result.link_copy(*this);
         result.size=this->size;
         return result;
     }

      Node * p=NULL;
      Node * s=NULL;
      Node * q=NULL;


      q=this->get_head();//q首先指向+的左操作数
      int count=this->get_size(); //count获取左操作数的链表节点个数
      while(count--)   
      {   
         s=new Node;
         s->date=q->date;
         s->next=NULL;
         if(result.get_head()==NULL)
         {
            result.head=s;
            p=s;
            q=q->next;
         }
         else
         {
             p->next=s;
             p=s;
             q=q->next;    
         }
        
     }        
     q=list_after.get_head();//q首先指向+的右操作数
     count=list_after.get_size(); //count获取右操作数的链表节点个数
     while(count--)
     {   
          s=new Node;
          s->date=q->date;
          s->next=NULL;
          p->next=s;
          p=s;
          q=q->next;    
     }        
    
    result.size=this->length_List()+list_after.length_List();
    return result;
 }


ostream & operator<<(ostream & out, MyList & mylist)  //<<运算符重载函数作为MyList的友元函数
{
  
   Node * head=mylist.get_head();
   Node * p=head;
   if(head==NULL)  //判断是否为空链表
   { out<<"the list is empty!"<<endl;
     return  out;  
   } 
   out<<"the list is :";
   while(p->next!=NULL)  //遍历链表，输出各个节点数据
   { out<<p->date<<" "; 
     p=p->next;
   }
   out<<p->date;
   out<<endl;
   return out;
}  

int main()
{   //创建第一个链表，并对其进行相应操作
    cout<<"create  the first list......: list1"<<endl;
    MyList mylist1; //建立链表对象mylist1
    mylist1.creat_List();//创建链表
    mylist1.print_List();//遍历链表

    cout<<mylist1; //使用输出运算符重载来对MyList对象的链表节点数据进行输出
   
    cout<<"the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    cout<<"the size of the list1: "<<mylist1.get_size()<<endl;  //链表长度
    /*
    
    int index;
    int length=mylist1.length_List();
    if(mylist1.get_head()!=NULL)
    {
        cout<<"\nplease input the index of list1 (index>=0  index<"<<length<<"): ";
        cin>>index;
        while(index<0||index>=length)  //判断index是否合理
        {
            cout<<"the index is not right,please input the index again :";
            cin>>index;
        }
        cout<<"the index="<<index<<" node value="<<mylist1.getvalue_List(index)<<endl<<endl;
    }
    else
    { 
        cout<<"the list is empty，the index operation not work!"<<endl;
    }
    
    mylist1.insert_List(); //向链表中插入多个节点
    mylist1.print_List();//遍历链表
    cout<<"the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    cout<<"the size of the list1: "<<mylist1.get_size()<<endl<<endl;  //链表长度
    
    
    Node * p=new Node;//增加一个新节点
    cout<<"please input the data of the new  node insert to list1:";
    cin>>p->date;
    p->next=NULL;
    mylist1.insert_Node(p);
    mylist1.print_List();//遍历链表
    cout<<"the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    cout<<"the size of the list1: "<<mylist1.get_size()<<endl;  //链表长度

      //对链表进行排序
    cout<<"the result of after sorting list1"<<endl;
    mylist1.list_sort();    
    mylist1.print_List();//遍历链表
    cout<<"the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    cout<<"the size of the list1: "<<mylist1.get_size()<<endl<<endl;  //链表长度
    */
        
    //创建第二个链表，并对其进行相应操作
    cout<<"create  the second list......: list2"<<endl;
    MyList mylist2; //建立链表对象mylist2
    mylist2.creat_List();//创建链表
    mylist2.print_List();//遍历链表

    cout<<mylist2;//使用输出运算符重载来对MyList对象的链表节点数据进行输出

    cout<<"the length of the list2: "<<mylist2.length_List()<<endl;  //链表长度
    cout<<"the size of the list2: "<<mylist2.get_size()<<endl<<endl;  //链表长度

    MyList mylist5=mylist1; //调用拷贝构造函数
    cout<<"list5=list1    "<<mylist5;
    
    mylist5=mylist1+mylist2; //使用运算符重载函数
    cout<<"list5=list1 + list2  "<<mylist5;
        
    /*

    //将链表2链到链表1后
    cout<<"link list1 and list2..."<<endl;    
    mylist1.link_Lists(mylist2);
    mylist1.print_List();//遍历链表
    cout<<"after link the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    cout<<"after link the size of the list1: "<<mylist1.get_size()<<endl<<endl;  //链表长度

    //创建第三个链表，由链表1深拷贝而来
    cout<<"create  the second list......: list3"<<endl;    
    MyList mylist3; //建立链表对象mylist3
    cout<<"list3 is copy from list1"<<endl;
    mylist3.link_copy(mylist1);
    mylist3.print_List();
    cout<<"the length of the list3: "<<mylist3.length_List()<<endl;  //链表长度
    cout<<"the size of the list3: "<<mylist3.get_size()<<endl<<endl;  //链表长度

    cout<<"delete the list1."<<endl;
    mylist1.delete_List(); //删除链表1
    //cout<<"the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    //cout<<"the size of the list1: "<<mylist1.get_size()<<endl<<endl;  //链表长度


    cout<<"delete the list3."<<endl;
    mylist3.delete_List(); //删除链表3
    //cout<<"the length of the list3: "<<mylist3.length_List()<<endl;  //链表长度
    //cout<<"the size of the list3: "<<mylist3.get_size()<<endl<<endl;  //链表长度

    cout<<"delete the list2."<<endl;
    mylist2.delete_List(); //删除链表2
    //cout<<"the length of the list2: "<<mylist2.length_List()<<endl;  //链表长度
    //cout<<"the size of the list2: "<<mylist2.get_size()<<endl<<endl;  //链表长度
    */

    return 0;
}

(5)

/*
链表操作----step3----用类对链表进行封装，再用类模板实现
在链表操作----step3 的基础上增加运算符重载的相关操作
在step3的基础上
(1)增加了一个拷贝构造函数
(2)增加了<<输出运算符重载函数
(2)增加了+运算符重载函数


链表设计----需求分析
1。创建
2。插入
3。遍历
4。获取长度
5。链接两个链表
6。可以实现插入多个类型的目的---用模板实现
7。根据index来获取数据
8。增加一个排序的功能
9。将以上功能用类进行封装
*/
#include <iostream>
using namespace std;

template<class T>
struct Node   //链表节点声明
{
    T date;
    Node<T> * next;
};

template<class T>
class MyList
{ public:
      Node<T> * head; //链表头指针
      int size;    //链表大小，链表中节点个数
      MyList() //构造函数
      {
          head=NULL;
          size=0;
      }
      MyList(MyList & ); //拷贝构造函数
      void creat_List();  //创建链表，返回该链表的头指针
      Node<T> * get_head();  //返回链表头指针     
      int get_size();  //返回链表大小     
      void print_List();  //遍历链表
      int length_List();  //获取链表长度（链表中节点数）
      T getvalue_List(int index); //根据index值获取节点数据
      void insert_List();//插入多个节点     
      void insert_Node(Node<T> * s);//插入一个节点,s指向要插入的节点，找到比s数据大的节点前插入
      void list_sort();//链表排序
      void delete_List();   //删除链表                                             
      void link_Lists(MyList); //将list链表链接到当前链表后      
      void link_copy(MyList); //链表拷贝(深拷贝)

      //运算符重载函数声明
      MyList   operator+(MyList mylist);  //成员函数
      friend ostream & operator<<(ostream & out, MyList & mylist);  //对输出运算符进行重载，友元函数
};

template<class T>
MyList<T>::MyList(MyList<T> & list_copyed) //拷贝构造函数,使用深拷贝来拷贝资源，链表上的节点
{  
    if(list_copyed.get_head()==NULL)
    {
        head=NULL;
        size=0;
    }
    else
    {
        int count=list_copyed.get_size();
        size=count;
        head=NULL;
        Node<T> * p,*q,*s;
        q=list_copyed.get_head();//q首先指向被拷贝的链表的头节点
        s=new Node<T>;
        p=s;
        head=p;
        while(count--)
        {
            s->date=q->date;
            s->next=NULL;
            if(head==NULL)
            {
                head=s;
                p=s;              
            }
            else
            {
                p->next=s;
                p=s;
            }
            q=q->next;    
            s=new Node<T>;
        }        
    } 
    
}


template<class T>
void MyList<T>::creat_List()  //创建链表
{
    head=NULL;  //链表头节点
    Node<T> * p=NULL; 
    int  count; //要创建的链表节点个数
    cout<<"please input the size of the list :";
    cin>>count;    
    while(count<0)
    {  
        cout<<"Warning: the size of list is not smaller than 0,please input again:";
        cin>>count;
    }
    cout<<"the size of list is "<<count<<endl;
    size=count;
    if(count==0)
        return ;  
    while(count--)
    {
        cout<<"the value is ";
        Node<T> * s=new Node<T>;
        cin>>s->date;
        s->next=NULL;
        if(head==NULL) //如果是第一个节点
        { head=s;
        p=s; //p指向当前链表中的最后一个节点
        }
        else  //如果不是第一个节点
        {
            p->next=s;
            p=s; //p指向当前链表中的最后一个节点
        }
    }
    cout<<"create a list successful!"<<endl<<endl;
}

template<class T>
Node<T> * MyList<T>::get_head()  //返回链表头指针
{
    return head;
}

template<class T>
int MyList<T>::get_size()   //返回链表大小
{
    return size;
}

template<class T>
void MyList<T>::print_List( )  //遍历链表
{
    Node<T> * p=head;
    if(head==NULL)  //判断是否为空链表
    { cout<<"the list is empty!"<<endl;
    return ;  
    }
    while(p->next!=NULL)  //遍历链表，输出各个节点数据
    { cout<<p->date<<" "; 
    p=p->next;
    }
    cout<<p->date;
    cout<<endl;
    cout<<"print list finished!"<<endl<<endl;
}

template<class T>
int MyList<T>::length_List( )  //获取链表长度（链表中节点数）
{
    if(head==NULL)
        return 0;
    int length=0;
    Node<T> * p=head;
    while(p->next!=NULL)
    {length++;
    p=p->next;
    }
    return length+1;
    /*
    return size;
    */
}


template<class T>
T MyList<T>::getvalue_List(int index) //根据index值获取节点数据
{
    
    if(index==0)
        return head->date;
    int i=0;
    Node<T> * p=head;
    for(i=0;i<index;i++)
        p=p->next;
    return p->date;       
}

template<class T>
void MyList<T>::insert_List() //插入多个节点
{
    int count=0; //记录总共插入的节点个数
    char flag='y';
    cout<<"do you want to insert a new node? (input \'y\' to insert,input \'n\' to exit )"<<endl;
    cin>>flag;
    Node<T> * s=NULL; //指向要插入的节点
    Node<T> * p=NULL; //指向要插入的节点位置
    Node<T> * q=NULL; //指向要插入的节点位置的前一个位置
    while(flag=='y')
    {
        s=new Node<T>;
        cout<<"the value is ";
        cin>>s->date;
        s->next=NULL;
        p=head;
        if(head==NULL)
            head=s;
        else
        {
            if (s->date<p->date) //要插入的节点比头节点数据还小
            {
                s->next=p;
                head=s;
            }
            else 
            {
                while(s->date>p->date&&p->next!=NULL)
                { q=p;
                p=p->next;
                }
                if(p->next!=NULL)
                {
                    s->next=p;
                    q->next=s;
                }
                if(p->next==NULL)
                {
                    if(s->date>p->date)
                        p->next=s;
                    else
                    {
                        s->next=p;
                        q->next=s;
                    }
                }
            }
        }
        count++;
        cout<<"Insert a new node again? (input \'y\' to insert,input \'n\' to exit )"<<endl;
        cin>>flag;
    }
    size=size+count;
    cout<<"insert "<<count<<" nodes successful!"<<endl<<endl;
}

template<class T>
void  MyList<T>::insert_Node(Node<T> * s) //插入一个节点,s指向要插入的节点，找到比s数据大的节点前插入
{
    
    Node<T> * p=NULL; //指向要插入的节点位置
    Node<T> * q=NULL; //指向要插入的节点位置的前一个位置
    
    s->next=NULL;
    p=head;
    if(head==NULL)
        head=s;
    else
    {
        if (s->date<p->date) //要插入的节点比头节点数据还小
        {
            s->next=p;
            head=s;
        }
        else 
        {
            while(s->date>p->date&&p->next!=NULL)
            { q=p;
            p=p->next;
            }
            if(p->next!=NULL)
            {
                s->next=p;
                q->next=s;
            }
            if(p->next==NULL)
            {
                if(s->date>p->date)
                    p->next=s;
                else
                {
                    s->next=p;
                    q->next=s;
                }
            }
        }        
    }
    size++;
}

//排序思路
//将无序链表从第一个节点开始依次插入到一个开始为空的空链表上（插入函数要先找到要插入的位置）
template<class T>
void MyList<T>::list_sort()//链表排序
{     
    MyList<T> mylist_sort; //定义一个临时MyList变量 mylist_sort，mylist_sort.head=NULL
    if(head==NULL)
        return ;
    Node<T> * p;
    while(head!=NULL)
    {   p=head;  //将p指向的节点从原链表中删除
        head=head->next; //原链表头节点后移
        p->next=NULL; //将p与原链表中的下一个节点断开
        mylist_sort.insert_Node(p); //将从原链表脱离的头节点插入到 mylist_sort对象的链表中
    }
    cout<<"the sort of list successful!"<<endl;
    head=mylist_sort.get_head();
}

template<class T>
void MyList<T>::delete_List()   //删除链表
{   
    int count=0;  //count用来记录要链表上删除的节点个数
    if(head==NULL)
    {
        cout<<"the list is empty ,no node to delete!"<<endl;
        return ;
    }
    Node<T> * p;
    while(head!=NULL)
    {
        p=head;
        head=head->next;
        delete p;
        count++;
    }
    cout<<"delete "<<count<<" nodes"<<" from list successful!"<<endl<<endl;
    size-=count;
}

template<class T>
void MyList<T>::link_Lists(MyList list_after) //将list_after链表链接到当前链表后
{
    if(head==NULL)
    {   this->link_copy(list_after);
        return ;
    }
    if(list_after.get_head()==NULL)
        return ;
    Node<T> * p=head;
    while(p->next!=NULL)
        p=p->next;
    Node<T> *q,*s;
    q=list_after.get_head();//q首先指向被链接的链表的头节点
    int count=list_after.get_size();
    while(count--)
    {   s=new Node<T>;
        s->date=q->date;
        s->next=NULL;
        p->next=s;
        p=s;
        q=q->next;    
    }        
    cout<<"the link of the two lists successful!"<<endl<<endl;    
    size+=list_after.length_List();
}


template<class T>
 void MyList<T>::link_copy(MyList list_copyed)//链表拷贝(深拷贝)
 {
    if(list_copyed.get_head()==NULL)
    {
       head=NULL;
       size=0;
    }
    else
    {
        int count=list_copyed.get_size();
        size=count;
        head=NULL;
        Node<T> * p,*q,*s;
        q=list_copyed.get_head();//q首先指向被拷贝的链表的头节点
        s=new Node<T>;
        p=s;
        head=p;
        while(count--)
        {
          s->date=q->date;
          s->next=NULL;
          if(head==NULL)
          {
              head=s;
              p=s;              
          }
          else
          {
              p->next=s;
              p=s;
          }
          q=q->next;    
          s=new Node<T>;
        }        
    }
 }


//运算符重载函数定义
template<class T>
MyList<T>   MyList<T>::operator+(MyList<T> list_after)  //+运算符重载函数作为MyList的成员函数
{
    MyList<T>  result;
    
    if(this->head==NULL)
    {   result.link_copy(list_after);
    result.size=list_after.get_size();             
    return result;
    }
    
    if(list_after.get_head()==NULL)
    { 
        result.link_copy(*this);
        result.size=this->size;
        return result;
    }
    
    Node<T> * p=NULL;
    Node<T> * s=NULL;
    Node<T> * q=NULL;
    
    
    q=this->get_head();//q首先指向+的左操作数
    int count=this->get_size(); //count获取左操作数的链表节点个数
    while(count--)   
    {   
        s=new Node<T>;
        s->date=q->date;
        s->next=NULL;
        if(result.get_head()==NULL)
        {
            result.head=s;
            p=s;
            q=q->next;
        }
        else
        {
            p->next=s;
            p=s;
            q=q->next;    
        }
        
    }        
    q=list_after.get_head();//q首先指向+的右操作数
    count=list_after.get_size(); //count获取右操作数的链表节点个数
    while(count--)
    {   
        s=new Node<T>;
        s->date=q->date;
        s->next=NULL;
        p->next=s;
        p=s;
        q=q->next;    
    }        
    
    result.size=this->length_List()+list_after.length_List();
    return result;
}

template<class T>
ostream & operator<<(ostream & out, MyList<T> & mylist)  //<<运算符重载函数作为MyList的友元函数
{
    
    Node<T> * head=mylist.get_head();
    Node<T> * p=head;
    if(head==NULL)  //判断是否为空链表
    { out<<"the list is empty!"<<endl;
    return  out;  
    } 
    out<<"the list is :";
    while(p->next!=NULL)  //遍历链表，输出各个节点数据
    { out<<p->date<<" "; 
    p=p->next;
    }
    out<<p->date;
    out<<endl;
    return out;
}  

int main()
{   //创建第一个链表，并对其进行相应操作
    cout<<"create  the first list......: list1"<<endl;
    MyList<char> mylist1; //建立链表对象mylist1
    mylist1.creat_List();//创建链表
    mylist1.print_List();//遍历链表
    cout<<mylist1<<endl;
    cout<<"the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    cout<<"the size of the list1: "<<mylist1.get_size()<<endl;  //链表长度


    int index;
    int length=mylist1.length_List();
    if(mylist1.get_head()!=NULL)
    {
        cout<<"\nplease input the index of list1 (index>=0  index<"<<length<<"): ";
        cin>>index;
        while(index<0||index>=length)  //判断index是否合理
        {
            cout<<"the index is not right,please input the index again :";
            cin>>index;
        }
        cout<<"the index="<<index<<" node value="<<mylist1.getvalue_List(index)<<endl<<endl;
    }
    else
    { 
        cout<<"the list is empty，the index operation not work!"<<endl;
    }
    
    mylist1.insert_List(); //向链表中插入多个节点
    mylist1.print_List();//遍历链表
    cout<<mylist1<<endl;
    cout<<"the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    cout<<"the size of the list1: "<<mylist1.get_size()<<endl<<endl;  //链表长度
    
    
    Node<char> * p=new Node<char>;//增加一个新节点
    cout<<"please input the data of the new  node insert to list1:";
    cin>>p->date;
    p->next=NULL;
    mylist1.insert_Node(p);
    mylist1.print_List();//遍历链表
    cout<<mylist1<<endl;
    cout<<"the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    cout<<"the size of the list1: "<<mylist1.get_size()<<endl;  //链表长度

      //对链表进行排序
    cout<<"the result of after sorting list1"<<endl;
    mylist1.list_sort();    
    mylist1.print_List();//遍历链表
    cout<<mylist1<<endl;
    cout<<"the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    cout<<"the size of the list1: "<<mylist1.get_size()<<endl<<endl;  //链表长度

        
    //创建第二个链表，并对其进行相应操作
    cout<<"create  the second list......: list2"<<endl;
    MyList<char> mylist2; //建立链表对象mylist2
    mylist2.creat_List();//创建链表
    mylist2.print_List();//遍历链表
    cout<<mylist2<<endl;
    cout<<"the length of the list2: "<<mylist2.length_List()<<endl;  //链表长度
    cout<<"the size of the list2: "<<mylist2.get_size()<<endl<<endl;  //链表长度

    //将链表2链到链表1后
    cout<<"link list1 and list2..."<<endl;    
    mylist1.link_Lists(mylist2);
    mylist1.print_List();//遍历链表
    cout<<mylist1<<endl;
    cout<<"after link the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    cout<<"after link the size of the list1: "<<mylist1.get_size()<<endl<<endl;  //链表长度

    //创建第三个链表，由链表1深拷贝而来
    cout<<"create  the third list......: list3"<<endl;    
    MyList<char> mylist3; //建立链表对象mylist3
    cout<<"list3 is copy from list1"<<endl;
    mylist3.link_copy(mylist1);
    mylist3.print_List();
    cout<<mylist3<<endl;
    cout<<"the length of the list3: "<<mylist3.length_List()<<endl;  //链表长度
    cout<<"the size of the list3: "<<mylist3.get_size()<<endl<<endl;  //链表长度

    //创建第四个链表，由链表1复制拷贝而来
    cout<<"create  the third list......: list4"<<endl; 
    MyList<char> mylist4=mylist1; //调用拷贝构造函数
    cout<<"list4=list1    "<<mylist4<<endl;
    
    mylist4=mylist1+mylist2; //使用运算符重载函数
    cout<<"list4=list1 + list2  "<<mylist4<<endl;

    cout<<"delete the list1."<<endl;
    mylist1.delete_List(); //删除链表1
    //cout<<"the length of the list1: "<<mylist1.length_List()<<endl;  //链表长度
    //cout<<"the size of the list1: "<<mylist1.get_size()<<endl<<endl;  //链表长度


    cout<<"delete the list2."<<endl;
    mylist2.delete_List(); //删除链表2
    //cout<<"the length of the list2: "<<mylist2.length_List()<<endl;  //链表长度
    //cout<<"the size of the list2: "<<mylist2.get_size()<<endl<<endl;  //链表长度

       cout<<"delete the list3."<<endl;
    mylist3.delete_List(); //删除链表3
    //cout<<"the length of the list3: "<<mylist3.length_List()<<endl;  //链表长度
    //cout<<"the size of the list3: "<<mylist3.get_size()<<endl<<endl;  //链表长度

    cout<<"delete the list4."<<endl;
    mylist4.delete_List(); //删除链表3
    //cout<<"the length of the list4: "<<mylist4.length_List()<<endl;  //链表长度
    //cout<<"the size of the list4: "<<mylist4.get_size()<<endl<<endl;  //链表长度


    return 0;
}

 

转载于:https://www.cnblogs.com/beautiful-code/p/5239275.html

weixin_30510153
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
头歌--C++ 面向对象 - STL 的应用
m0_56638814的博客
07-24 6982
C++ 面向对象 - STL 的应用
如何学习C++
lypzcgf的专栏
12-31 531
学习C++的入门之法
面向过程编程（pop），面向对象编程（oop），函数式编程（fp）
热门推荐
大海
08-26 1万+
1、概念 面向过程编程（procedure oriented Programming）（POP） 面向对象编程（object oriented programming）(OOP) 函数式编程（functional programming)(FP) 2、解释 面向过程编程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。 面向对象编程是...
Servlet - JavaEE初阶 - 细节狂魔
DarkAndGrey的博客
06-03 2273
文章目录前言前置知识：Maven 前言 前文说到： 其实 web 开发主要的工作就是在 动态页面 这边。 因此接下来重点学习的，就是 动态页面的构造。 动态页面的构造：其实就是学习 Tomcat 给程序员提供的这组用来操作 HTTP 的 API。 我们给 这组 API，单独起了个名字：Servlet。 Servlet，可以说是在Java世界中，进行 web 开发的一个基石。 我们未来用到一些像 Spring 这样的框架，其实它也是基于 Servlet 这样的机制，进行了进一步的封装。   Servlet
编译原理 CS-143(更新至week4)
hxhxhxhxx的博客
01-15 2360
Pre-Course Survey 一个小调查，无伤大雅 实验所需虚拟机 链接: https://pan.baidu.com/s/16KXICHhpBb22v4CyNQugMg 提取码: n44a Navigation Your Course 课程导览 属性bar用的 介绍了 课程模块，大纲模块，讨论模块，测评模块，测评模块会打分 讨论模块要遵守规则，不发一些不必要的内容，淫秽色情，垃圾邮件，抄袭的内容 01-01: Introduction (8m20s) 编程语言又两种实现，也就是编译器和解释器
嵌入式面向对象学习 RT-Thread I/O 设备管理框架 设备驱动层 案例测试
dele
04-06 1118
嵌入式面向对象 RT-Thread I/O 设备管理 设备驱动层 案例测试
Java初级知识复习-2021.12.27~2022.02.09
weixin_43136158的博客
02-09 1665
Java语法基础1 1、Java简介 Java三大版本含义 Java的特性和核心优势 2、Java开发环境配置 Java应用程序的运行机制 开发环境搭建 3、Java基础语法 4、Java基本数据类 5、Java修饰符 访问权限修饰符： 非访问权限修饰符 接口修饰
IOT-OS之RT-Thread（三）--- C语言对象化与内核对象管理
流云
09-14 2781
一、RT-thread内核对象模型 RT-Thread的内核对象模型是一种非常有趣的面向对象实现方式。由于C语言更为面向系统底层，操作系统核心通常都是采用C语言和汇编语言混合编写而成。C语言作为一门高级计算机编程语言，一般被认为是一种面向过程的编程语言：程序员按照特定的方式把要处理事物的过程一级级分解成一个个子过程。面向对象源于人类对世界的认知多偏向于类别模式，根据世界中不同物品的特性分门别类的组织在一起抽象并归纳，形成各个类别的自有属性。
Java面试题--基础知识部分
面朝大海，春暖花开
11-30 2420
前面还电话面试过两个实习生同学，经常需要问道一些Java基础，收集了一些基本的Java面试基础知识，总结如下： 1、面向对象的特征有哪些方面   1.抽象： 抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用 部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。 2.继承： 继承是一种联结类
基于C++的ACM-ICPC模板
02-22
4. **模板类**：定义了一些常用的模板类，如大整数操作、矩阵运算、动态规划状态等，这些模板类可以减少重复代码，提高代码复用性。 5. **测试框架**：包含测试样例的读取和验证，帮助开发者在本地进行充分的测试，...
source code_C-C++_Years_
09-29
1. **C语言基础**：C语言是面向过程的语言，主要由基本数据类型（如int, char, float等）、控制结构（如if-else, switch-case, for, while循环）、函数、数组和指针等构成。学习C语言的基础是理解这些概念并能熟练...
cpp-Web在线斗地主游戏
08-16
理解C++的基本语法、类和对象、模板、异常处理、内存管理等是开发的基础。 2. **Web框架集成**：为了实现Web接口，项目可能使用了如Poco或者cpprest库来处理HTTP请求和响应。这些库提供了一种在C++中与Web服务器...
cpp-清华大学计算机系课程攻略
08-16
C++比C语言更加强大，因为它引入了类和对象，这是面向对象编程的核心，让你能够设计和实现复杂的软件系统。 攻略中可能包含对C++标准库的讲解，例如STL（Standard Template Library），它提供了容器（如vector和...
leetcode-solutions:Leetcode问题解决
03-16
8. 泛型编程和模板：模板类、模板函数，以及模板特化。 9. 常用数据结构：栈、队列、链表、树、图的C++实现。 10. 树结构：二叉树、平衡二叉树、红黑树等的C++实现。 11. 图论：邻接矩阵、邻接表，以及Dijkstra、...
代码随想录打卡第二十九天
weixin_48013375的博客
07-19 360
day 29 贪心算法第三天。
小欧吃苹果-OPPO 2024届校招正式批笔试题-数据开发（C卷）
sigd的博客
07-16 498
小欧吃苹果，拓扑排序处理贪心问题。
华为od机试真题 — 代表团坐车(Python)
学习,你不是一个人在战斗 ～ 961302305（QQ,微信）
07-17 573
【华为od机试真题 】代表团坐车(Python) 某组织举行会议，来了多个代表团同时到达，接待处只有一辆汽车可以同时接待多个代表团，为了提高车辆利用率，请帮接待员计算可以坐满车的接待方案输出方案数量。
大模型面经
最新发布
weixin_43744732的博客
07-19 665
大模型，面试，八股文
面向对象编程：C++语言程序设计基础-郑莉解析
C++中的类和对象是面向对象编程的核心概念，类是数据和操作数据的方法的集合，而对象是类的实例，具备类定义的属性和行为。理解类和对象的关系，以及如何通过封装、继承和多态来实现代码复用和模块化，是掌握C++的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值