求图的所有哈密顿环算法2

---------   node.h   ------------------//定义节点类  
   
  #include<string>  
  #include<vector>  
  using   namespace   std;  
   
  class   node  
  {  
  public:  
  node(int   c,const   string     _name):cp(c),name(_name){}  
  string   name;   //结点名称  
  int   cp;         //结点标号  
  };  
   
  -----------   sort.h   ---------------------//寻找哈密尔顿回路的算法部分  
   
  #include<iostream>  
  #include<string>  
  #include<vector>  
  #include"node.h"  
  using   namespace   std;  
   
  vector<node>   v_sort;   //记录当前搜索时结点的连接状况  
  int   N;       //结点总数  
  vector<string>   in_name;   //结点名称  
  vector<vector<bool>   >   link_state;   //结点的初始连接状况  
  vector<vector<bool>   >   clink;             //结点当前连接状况（用于搜索）  
   
  //用于搜索的函数，由sort()调用，搜索结果保存在v_sort里  
  int   node_sort()  
  {  
  int   count=v_sort.back().cp; //v_sort栈顶结点的标号  
  if(v_sort.size()==N   &&   link_state[count][0]==true)  
  return   1;     //当成功找到一回路时返回   1  
   
  //通过查看clink进行搜索  
  for(int   i=0;i<N;i++)  
  {  
  //发现另一结点M可与该结点相连  
  if(clink[count][i]==true)  
  {  
  bool   in_stack=false;   //标示M是否已在v_sort里  
  for(int   j=0;j<v_sort.size();j++)  
  if(v_sort[j].name==in_name[i])  
  in_stack=true;   //M已在v_sort里  
  if(in_stack==false)  
  {  
  //压入M结点  
          node   tmp(i,in_name[i]);    
          v_sort.push_back(tmp);  
  //修改clink,堵住已走的路  
          clink[i][count]=false;  
          clink[count][i]=false;          
          return   0;    
  }  
  }  
  }  
  v_sort.pop_back();   //当找不到路时弹出该结点  
  clink[count]=link_state[count];   //恢复弹出结点的初始连接状态  
  return   0;  
  if(v_sort.size()==0)  
        return   -1;     //搜索失败，此时v_sort为空，返回-1  
  }  
   
  //sort函数由用户调用，依次传入结点数量，名称，初始连接状况；输出排好的结点名  
  bool   sort(int   n,const   vector<string>   _in_name,const   vector<vector<bool>   >             _link_state,vector<string>&   out_name)  
  {  
  //初始化全局变量  
  N=n;  
  in_name=_in_name;  
  link_state=_link_state;  
  clink=link_state;  
  v_sort.clear();    
   
  //先压入第一个结点  
                    node   first(0,in_name[0]);  
  v_sort.push_back(first);  
  while(1)  
  {  
          int   r=node_sort();  
                            if(r==1)  
          {  
  for(int   i=0;i<n;i++)    
            out_name.push_back(v_sort[i].name);//找到回路就初始化out_name  
  return   true;  
            }  
   
          if(r==-1)  
                  return   false;   //未找到  
  }  
  }  
   
  -------------   main.cpp   ----------------//这个是调用部分，没有注释，有点乱，不过不是主要的  
   
  #include<iostream>  
  #include<string>  
  #include<vector>  
  #include"sort.h"  
  #include<cstdlib>  
  using   namespace   std;  
   
  void   main()  
  {  
  cout<<endl<<"*************寻找哈密尔顿回路程序***************/n";  
           
  string   is_continue="y";  
  while(is_continue=="y"||is_continue=="Y"   )  
  {  
          int   np;  
          string   inN;                          
          vector<string>   in_name;  
  bool   judge=true;  
   
          cout<<"/n   请依次输入各节点名称,以空格隔开:";  
          while(1)  
          {  
                do{  
        cin>>inN;  
        judge=true;  
     
        for(int   i=0;i<in_name.size();i++)  
        {    
                if(inN==in_name[i])  
                {  
                      cout<<"/n!节点名称不能重复,请重新输入各节点名称(先空一格):";  
    judge=false;  
    cin.ignore(1000,'/n');    
    in_name.assign(0,"");    
    break;    
                  }  
          }  
        if(judge==true)          
                  in_name.push_back(inN);    
     
  }while(cin.get()!='/n');  
  if(in_name.size()>=3)  
          break;  
  cout<<"/n!节点数必需大于或等于3,请重新输入:";  
                                      in_name.assign(0,"");          
          }  
   
          np=in_name.size();  
          vector<bool>   _link_state(np);  
          vector<vector<bool>   >   link_state;  
  string   in_link;  
                   
          cout<<"/n请依次输入该节点与所有节点的连接情况,以空格隔开/n       ";  
          for(int   i=0;i<np;i++)  
                  cout<<in_name[i]<<"   ";  
          cout<<"/n";  
          bool   input_again=false;  
          for(i=0;i<np;i++)  
          {  
                do{  
                                            input_again=false;  
        cout<<"   "<<in_name[i]<<":";  
        for(int   k=0;k<np;k++)  
        {  
                cin>>in_link;  
                if(in_link!="0"   &&   in_link!="1")  
                {  
      cout<<"/n   !!只能输入'0'/'1',请重新输入该节点连接情况:/n";  
      input_again=true;  
      cin.ignore(1000,'/n');  
                        break;  
                }  
                else   if(k==i   &&   in_link=="1")  
                {  
      cout<<"/n   !!这里节点不能与自身相连,请重新输入该节点连接情况:/n";  
      input_again=true;  
      cin.ignore(1000,'/n');  
                                                            break;  
                  }    
                  in_link=="0"?   _link_state[k]=false:_link_state[k]=true;          
            }  
  }while(input_again==true);  
   
  link_state.push_back(_link_state);  
          }  
   
          vector<string>   out_name;  
   
          if(sort(np,in_name,link_state,out_name)==false)  
      cout<<"/n   无哈密尔顿回路   /n";  
          else  
          {  
                cout<<"/n   找到一条哈密尔顿回路:   /n";        
                for(i=0;i<out_name.size();i++)                
          cout<<out_name[i]<<"---";          
         
                cout<<out_name[0];  
          }  
   
          cout<<"/n/n是否继续?(y/n):";  
          cin>>is_continue;  
          while(is_continue!="Y"   &&   is_continue!="y"   &&   is_continue!="N"   &&   is_continue!="n")  
          {  
    cout<<"/n只能输入'y'/'n',请重新选择(y/n):";  
    cin>>is_continue;  
            }  
  }  
   
  cout<<"/n欢迎使用/n";  
  system("PAUSE");  
  }