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

 
#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();
   
}
}//主函数结束