数据结构--单链表基本功能实现程序…

 

#include  

#include     

#include   

const MAXNUMOFBASE=5;  //基础数据总量

enum returninfo{success,fail,overflow,underflow,range_error};//定义返回信息清单

int   sourcedata[MAXNUMOFBASE]={11,22,33,55,66,};  //内部数据数组，节省每次建立时输入时间

class node

{

public:

         int     data;  //数据域

         node   *next;  //结点指针

};

class linklist

{

private:

         node  *headp;

protected:

         int count;                          //计数器 统计结点个数即线性表的长度

public:

         linklist();                                        //构造函数

         ~linklist();                                                                              //析构函数

         returninfo create(void);                           //链表的初始化

         void clearlist(void);                              //清空链表

         bool empty(void) const;                            //判断是否空链

    int size(void) const;                              //求链表的长度

       returninfo traverse(void);                         //遍历链表所有元素

         returninfo retrieve(int position,int &item) const; //读取一个结点

         returninfo replace(int position,const int &item);  //修改一个结点

    returninfo insert(int position,const int &item);   //插入一个结点

         returninfo remove(int position);                   //删除一个结点

         returninfo invertlist(void);                       //链表所有数据反转

};

linklist::linklist()                 //构造函数

{

         headp=new node;                  //申请新结点，作为头结点

         headp->next=NULL;                //头结点的地址域预设为空地址

         count=0;                         //计数器清零，表明开始时没有实际数据

}

linklist::~linklist()                //析构函数

{

    clearlist();                     //删除所有数据，释放所有结点

         delete headp;                    //把头结点也释放掉

         count=0;                         //计数器清零，表明开始时没有实际数据

}

returninfo linklist::create(void)

{

         node *searchp=headp,*newnodep;

         int i;

    for (i=0;i

         {       

                   newnodep=new node;//此处对于申请失败并没有处理

                   newnodep->data=sourcedata[i];

        newnodep->next=NULL;

                   searchp->next=newnodep;

                   searchp=searchp->next;

                   count ;

         }

         searchp->next=NULL;     

    traverse();

         return success;

}

void linklist::clearlist(void)        //清空链表

{

         node *searchp=headp->next,*followp=headp;    //初始化两个指针

    while(searchp!=NULL)         

         {       

                   followp=searchp;

                   searchp=searchp->next;

                   delete followp;

         }

         headp->next=NULL;              //保留了最后一个结点，就是头结点，并且链域置为空

         count=0;                      //计数器也清零

}

bool linklist::empty(void)const   //是否空链

{

         if(headp->next==NULL)         

                   return true;

         else

                   return false;

}

int linklist::size(void)const   //求链表的长度

{

         return count;              

}

returninfo linklist::traverse(void)         //遍历链表中的所有元素

{

         node  *searchp;                         //启用搜索指针        

         if(empty())

             return underflow;                   //空表的处理

    searchp=headp->next;

         cout<<"链表中的全部数据为: Headp-->";   //提示显示数据开始

         while(searchp!=NULL)                    //循环显示所有数据

         {

                   cout<<" "<<searchp->data;  

                   if (searchp->next==NULL)

                            cout<<" -->endl";

                   else

                            cout<<" -->";

                   searchp=searchp->next;

         }

         cout<<endl;                             //最后有一个回车的控制

         return success;                         //本次操作成功

}

returninfo linklist::retrieve(int position, int &item) const  //读取一个结点

{

         if(empty())                              //处理意外

                   return underflow;   

         if(position<=0||position>=count 1)       //处理意外

                   return range_error;

         node *searchp=headp->next;             //定义搜索指针，初始化

         for(int i=1; i   //提示：注意小于号

        searchp=searchp->next;    //顺序访问方式，用循环，算法复杂度是O(n)

         item=searchp->data;           //返回读取的数据

         return success;               //本次操作成功

}

returninfo linklist::replace(int position,const int &item)  //修改一个结点

{

         if(empty())                               

                   return underflow;   

         if(position<=0||position>=count 1)

                   return range_error;

         node *searchp=headp->next;

         for(int i=1; i 

        searchp=searchp->next;

         searchp->data=item;           //实际修改数据的语句

         return success;

}

returninfo linklist::insert(int position,const int &item)    //插入一个结点

{

         if(position<=0 || position>=count 2)     

                   return range_error;

    node *newnodep=new node,  *searchp=headp->next,   *followp=headp;       

         for(int i=1; i 

    {

                   followp=searchp;        

                   searchp=searchp->next;

         }

         newnodep->data=item;                  //给数据赋值    

         newnodep->next=followp->next;         //注意此处的次序相关性

         followp->next=newnodep;

         count ;                              //计数器加一

         return success;

}

returninfo linklist::remove(int position)          //删除一个结点

{

         if(empty())

                   return underflow;   

         if(position<=0||position>=count 1)

                   return range_error;

         node *searchp=headp->next,*followp=headp;    //这里两个指针的初始值设计一前一后

         for(int i=1; i 

    {

                   followp=searchp;                         

                   searchp=searchp->next;

         }

         followp->next=searchp->next;        //删除结点的实际语句

         delete searchp;                     //释放该结点 

         count--;                            //计数器减一

         return success;

}

returninfo linklist::invertlist(void)

{

         node *nowp,*midp,*lastp;     //启用多个辅助指针

         if(empty())

                   return underflow;

         nowp=headp->next;

         midp=NULL;

         while(nowp!=NULL)          

         {

                   lastp=midp;

                   midp=nowp;

                   nowp=nowp->next;

                   midp->next=lastp;

         }

         headp->next=midp;

         return success;

}

class interfacebase

{

private:

         linklist listonface;

public:

         void clearscreen(void);

         void showmenu(void);

         int userchoice(void);

         returninfo processmenu(int menuchoice);

};

void interfacebase::clearscreen(void)

{

    system("cls");

}

void interfacebase::showmenu(void)

{

       cout<<"链表基本功能菜单"<<endl;

    cout<<"=========="<<endl;

    cout<<"1.输入数据（内部用数组提供5个数据）"<<endl;

    cout<<"2.显示数据（遍历全部数据）"<<endl;

    cout<<"3.修改数据（要提供位置和新值）"<<endl;

    cout<<"4.插入数据（要提供位置和新值）"<<endl;

    cout<<"5.删除数据（要提供位置）"<<endl;

    cout<<"6.读取数据（要提供位置）"<<endl;

    cout<<"7.求表长度"<<endl;

         cout<<"8.数据反转（全部数据逆序存储）"<<endl;

    cout<<"9.结束程序"<<endl;

         cout<<"=========="<<endl;

}

int interfacebase::userchoice(void)

{        int menuchoice;

         cout<<"请输入您的选择：";  

         cin>>menuchoice;

         return menuchoice;

}

returninfo interfacebase::processmenu(int menuchoice)

{

         int position,item,returnvalue;

         switch(menuchoice)    //根据用户的选择进行相应的操作

         {

         case 1:

                                     returnvalue=listonface.create();

                                     if(returnvalue==success)

                                               cout<<"建立链表操作成功!请按任意键继续..."<<endl;

                                     break;

         case 2:

                                     returnvalue=listonface.traverse();                  

                                     if(returnvalue==underflow)

                                               cout<<"链表目前为空，没有数据可以显示!请按任意键继续..."<<endl;

                                     else

                                               cout<<"链表遍历操作成功!请按任意键继续..."<<endl;

                                     break;

         case 3:

                                     cout<<"请输入要修改数据的位置：";

                                     cin>>position;

                                     cout<<"请输入要修改的新数据：";

                cin>>item;

                                     returnvalue=listonface.replace(position,item);

                                     if(returnvalue==underflow)

                                         cout<<"对不起，链表已空!请按任意键继续..."<<endl;

                                     else if(returnvalue==range_error)

                                               cout<<"对不起，修改的位置超出了范围!请按任意键继续..."<<endl;

                                     else

                                               cout<<"修改操作成功!请按任意键继续..."<<endl;

                                     break;               

        

         case 4:

                                     cout<<"请输入要插入数据的位置：";

                                     cin>>position;

                                     cout<<"请输入要插入的新数据：";

                cin>>item;

                                     returnvalue=listonface.insert(position,item);

                                     if(returnvalue==range_error)

                                               cout<<"对不起，插入的位置超出了范围!请按任意键继续..."<<endl;

                                     else

                                               cout<<"插入操作成功!请按任意键继续..."<<endl;

                                     break;

                           

         case 5:

                                     cout<<"请输入要删除数据的位置：";

                                     cin>>position;

                                     returnvalue=listonface.remove(position);

                                     if(returnvalue==underflow)

                                         cout<<"对不起，链表已空!请按任意键继续..."<<endl;

                                     else if(returnvalue==range_error)

                                               cout<<"对不起，删除的位置超出了范围!请按任意键继续..."<<endl;

                                     else

                                               cout<<"删除操作成功!请按任意键继续..."<<endl;

                                     break;

         case 6:

                                      cout<<"请输入要读取数据的位置：";

                                     cin>>position;

                                     returnvalue=listonface.retrieve(position,item);

                                     if(returnvalue==underflow)

                                         cout<<"对不起，链表已空!请按任意键继续..."<<endl;

                                     else if(returnvalue==range_error)

                                               cout<<"对不起，读取的位置超出了范围!请按任意键继续..."<<endl;

                                     else

                                               cout<<"读取的数据为："<<item<<endl<<"读取操作成功!请按任意键继续..."<<endl;

                                break;

                           

         case 7:

                                     cout<<"链表目前的长度为: "<<listonface.size()<<endl;

                                     cout<<"求链表长度操作成功!请按任意键继续..."<<endl;

                                     break;

                                                                

         case 8:

                                     returnvalue=listonface.invertlist();          

                                      if(returnvalue==underflow)

                                         cout<<"对不起，链表已空!请按任意键继续..."<<endl;

                                     else

                                               cout<<"链表所有元素反转操作成功!请按任意键继续..."<<endl;

                                     break;      

         case 9:    

                           exit(0);

         default:

                                     cout<<"对不起，您输入的功能编号有错!请重新输入!!!"<<endl;

                                break;

                                     }

                   return success;

}

void main(void)                     //程序主入口

{  

         int menuchoice;                 //下面要用到

         interfacebase interfacenow;

         linklist linklistnow;

         interfacenow.clearscreen();

    while (1)

         {

                interfacenow.showmenu();

                   menuchoice=interfacenow.userchoice();

                   interfacenow.processmenu(menuchoice);

                   getch();

                   Sleep(200);                     //延迟了一会

                   interfacenow.clearscreen();

    }

}//主函数结束