grary11.h

该包是数据结构的实验软件,来源于合肥工业大学人工智能与数据挖掘实验室,用来实现数据结构.

#include"iostream.h"
#include"graphics.h"
#include"string.h"
#include"conio.h"
#include"stdlib.h"
#include"stdio.h"
#include"math.h"
#include"malloc.h"
#include"tools.h"
#define    maxnum  100
#define    minsubaa  1
#define    minsubbb  -10
#define    horizon  1
#define    vertical  0
#define    SubDec   -1
#define    SubInc   1
#define   nil    0


#define   NULL  0

class vararray
{private:
    int *element;
    int size;
    int min;
    int max;
  public:
   vararray( int m=0,int s=0);
   vararray();
   int&  operator [](const int index);

   ~vararray();
   };
   vararray::vararray(int m,int s)
   {
	size=s-m+1;
	max=s;
	min=m;
	element=new int[size];
	for(int i=0;i<size;i++)
	element[i]=0;
	}

    int & vararray::operator[](const int index)
     { return element[index-min];}


     vararray::~vararray()
     { delete []element;
     }
  class aa:public vararray
 {
 public:
 aa( int m=10, int s=100): vararray(m,s)
 {}

 };


 class bb1:public vararray
 {
 public:
   bb1( int m=-10, int s=100): vararray(m,s)
 {}
  };


struct element{
  int val;
  element *next;
  };

  class list
  {
    public:
     element *elems;
    list(){elems=0;}
    ~list();
    int get();
    virtual boolean insert(int);
    virtual boolean deletes(int);
    boolean contain(int);
    void print();
    };
    class set:public list{
     int card;
     public:
       set(){card=0;}
       boolean insert(int);
       boolean deletes(int);
	set * com(set&);
       set * bin(set&);
       set *jian(set &);
       };

     int  list::get(void)

      {int i;
      element *elem;
      if(elems!=0)
	 {elem=elems;
	   elems=elem->next;
	   i=elem->val;
	   delete elem;

	 return i;
	     }
       return 9999;
       }

       list::~list()
      { element  *tmp;
       for(element* elem=elems;elem!=0;)
      { tmp=elem;
       elem=elem->next;
       delete tmp;
       }
       }
       boolean list::insert(int val)
       {
       element *elem=new element;
       if(elem!=0)
       {
       elem->val=val;
       elem->next=elems;
       elems=elem;
       return true;
  }
     else  return    false;
     }
     boolean list::deletes(int val)
     {
     if(elems==0) return false;
     element * tmp=elems;
     if(elems->val==val)
      {elems=elems->next;
       delete  tmp;
       return true;
       }
       else for(element* elem=elems;elem->next!=0;elem=elem->next)
	if(elem->next->val==val)
	{tmp=elem->next;
	elem->next=tmp->next;
	delete tmp;
	return true;
	}
	return false;
	}
	 boolean list::contain(int val)
	 {
	 if (elems==0) return false;
	 if(elems->val==val)
		 return true;
	 else
	     for(element *elem=elems;elem->next!=0;elem=elem->next)
		 if(elem->next->val==val)
		 return true;
	 return false;
	   }
	   void list::print()
	   {
	   if(elems==0) return;
	   for(element *elem=elems;elem!=0;elem=elem->next)
	    cout<<elem->val<<"  ";
	    cout<<endl;
	    }
	    boolean set::insert(int val)
	    {
	    if(!list::contain(val))
	    {++card;
	    list::insert(val);
	    return true;
	    }
	    return false;
	    }

       set * set::com(set& s2)
       {
       element * elem;
       set c,* p;
       p=&c;
       for(elem=elems;elem!=0;elem=elem->next)
	   if(s2.contain(elem->val))
	    p->insert(elem->val);
	    return p;

	  }


      set * set::jian(set& s2)
       {
       boolean f;
       element * elem;
       set c,* p;
       p=&c;
       for(elem=elems;elem!=0;elem=elem->next)
	   if(!s2.contain(elem->val))
	    p->insert(elem->val);
	    return p;

	  }
     set * set::bin(set& s2)
       {

       element * elem;
       set c,* p;
       p=&c;
     for(elem=elems;elem!=0;elem=elem->next)
	   if(!s2.contain(elem->val))
	    p->insert(elem->val);
	for(elem=s2.elems;elem!=0;elem=elem->next)
	  p->insert(elem->val);
	   return p;
      }
     boolean set::deletes(int val)

     {
     if(list::deletes(val))
     {
     card--;
     return true;
     }
     return false;
     }

   class vset:public set
    {public:
       int sets1;
       int sets2;
      vset(int ,int );
       };

     vset::vset(int vs1,int vs2)
     { sets1=vs1;
       sets2=vs2;
      for(int z=vs1;z<=vs2;z++)
       vset::insert(z);
       }


  enum HorOrLev{  v=0,h=1};
  enum d_or_i {D=-1, I=1};

  typedef  int datatype;
  typedef void  far * ffield;
  typedef void far * Arrptrfd;


   //    ArrPtr=^arlnode;
   struct arlnode
	 {
	  int  oldx,oldy,ox1,oy1,hl,cursub;
	   Arrptrfd fd0,fd1;
	   int   size0,size1;
	   boolean hide;
	   string  ptr_name;
	   arlnode far *next;
	   };
   typedef arlnode far * ArrPtr;
    //	VarPtr=^vrlnode;
       struct	vrlnode
	  {
	  int  vx, vy, hl, cursub, varopnum;
	  datatype v;
	  string  var_name;
	  vrlnode far *next;
	  };
    typedef vrlnode far * VarPtr;
     struct  GrpArr
	{
	   int * ag1;
	   boolean  dsb;
	   int sx,sy,dx,dy,h,w,sub1,count,asub1,asub2;
	   HorOrLev ho_lev;
	   d_or_i decinc;
	   ArrPtr firstptr;
	   VarPtr firstvar;
	   string  name;
	   ffield   datafild[2];
	   boolean  havefd;
	   HorOrLev  fdsub;
	   int size;
	 };


  void Trace1_off();
  void Trace1();
  void Set_trace1_mode(int  delaytime);

  void Load_arraa_file(aa& a,int n,string  dosfile);
  void Load_arraa(aa& a,int n);
  void Save_arraa_file(aa& a,int n,string dosfile);
  void Save_arraa(  aa& a,int n);
  void Disp_arraa(  aa& a,int n);
  void Load_arrbb_file(  bb1& a,int sn,int en,string dosfile);
  void Load_arrbb(  bb1& a,int sn,int en);
  void Save_arrbb_file(  bb1& a,int sn,int en,string dosfile);
  void Save_arrbb(  bb1& a,int sn,int en);
  void Disp_arrbb(  bb1& b,int sn,int en);
  void Reset_arrbb( bb1& b,int i1,int i2);
  void Input_arrbb(  bb1& b,int i1,int i2);
  void Modi_arrbb(  bb1& b,int i1,int i2);
  void Rand_arrbb(  bb1& b,int i1,int i2,int range1,int range2);

  void Create_grp_arrbb(  GrpArr& ag,HorOrLev hl,d_or_i di,
		   boolean dsub, bb1& b,string title,int fstsub,int lstsub);
  void Input_grp_arrbb(  GrpArr& ag,bb1&  b,string title,int fstsub,int lstsub);
  void Initial_grparr(  GrpArr& ag);

  void Cur_cover(  GrpArr& ag,int i,int orxor);
  void Cur_onoff(  GrpArr& ag,int i);
  void Cur_elmn_onoff(  GrpArr& ag,int i);

  void Reset_grparr_elmn(  GrpArr& ag,int i);
  void Reset_grparr(  GrpArr& ag);
  void Clear_arparr_elmn(  GrpArr& ag,int i);
  void Clear_arparr(  GrpArr& ag);
  void Modi_arparr(  GrpArr& ag );
  void Rand_grparr(  GrpArr& ag,int  range1,int range2);
  void Input_grparr(  GrpArr& ag);
  void Load_grparr_file(  GrpArr& ag,string dosfile);
  void Save_grparr_file(  GrpArr& ag,string dosfile);
  void Load_grparr(  GrpArr& ag);
  void Save_grparr(  GrpArr& ag);
  void Disp_elmn_data(  GrpArr& ag,int  i);
  void Display_grparr_elmn(  GrpArr& ag,int i);
  void Disp_sub(  GrpArr& ag);
  void Disnodedat(  GrpArr& ag,int i);
  void Dissub(  GrpArr& ag);
  void Display_arr(  GrpArr& ag);
  void Display_grparr_elmns(  GrpArr& ag);
  void Display_grparr_frame(   GrpArr& ag);
  void Display_grparr(  GrpArr& ag);
  void Set_grparr_to(  GrpArr& ag, int x,int y);
  int   Sx1( GrpArr& ag);
  int   Sy1( GrpArr& ag);
  int   Elmnhigh(  GrpArr& ag);
  int  Elmnwidth(  GrpArr& ag);
  void Setelmnsize(  GrpArr& ag,int  hh,int ww);
  int  Sub1(  GrpArr& ag);
  int  Sub2( GrpArr& ag);
  HorOrLev  Hor_vert(  GrpArr& ag);
  d_or_i  Subdecorinc(  GrpArr& ag);
  boolean  Dispsub(  GrpArr& ag);
  void Move_grparr_to(  GrpArr& ag,int x,int y);
  void Move_grparr_dxy( GrpArr& ag,int x,int y);
  void Grparr_range(  GrpArr& ag,int& x1,int& y1,int& x2,int& y2);
  void Clear_grparr_range(  GrpArr& ag);
  void Move_grparr_mid(  GrpArr& ag,int x0,int y0);
  void Move_grparr(  GrpArr& ag);
  void Move1_grparr(  GrpArr& ag);
  void Set_grparr_range(  GrpArr& ag);

  datatype  Elmn(  GrpArr& ag,int i);
  void Put_elmn(  GrpArr& ag,int i,datatype v,int hl);
  boolean Cmp_elmn( GrpArr& ag,int i,int j,string op,int hl);
  void Move_elmn(  GrpArr& ag,int i,int j,int hl);
  void Xchg_elmn(  GrpArr& ag,int i,int j,int hl);
  void Elmn_ptr_elmn(  GrpArr& ag,int i,int hl);

  void Create_Arrptr(  ArrPtr& p,string ptrname, GrpArr& ag,int hh);
  boolean Have_arrptr(  GrpArr& ag, string title);
  void Put_elmn_value( GrpArr& ag,int i,datatype v,  ArrPtr& p);
  void Move_elmn_to(  GrpArr& ag,int i,int j, ArrPtr& p);
  void Xchg_elmn_with( GrpArr& ag,int i,int j,int hh,  ArrPtr& p);
  void Point_off_on(  ArrPtr& p,int i,  GrpArr& ag,HorOrLev nf);
  void Point_to(  ArrPtr& p,  GrpArr& ag,int num);
  void Arrptr_point_to(  ArrPtr& p,  GrpArr& ag,int num);

  void Create_varptr(  VarPtr& p,string ptrname,GrpArr& ag,int hh);
  boolean  Have_varptr(  GrpArr& ag, string title);
  void Disp_varptr(  VarPtr& p,   GrpArr& ag);
  void Disp_varptr_data(  VarPtr& p, GrpArr& ag);
  void Disvardat(  VarPtr& p,   GrpArr& ag);
  void Put_var (  VarPtr& p,datatype w,  GrpArr& ag);
  void Move_var_grparr(  VarPtr& p, GrpArr& ag,int i);
  void Move_grparr_var (  VarPtr& p, GrpArr& ag,int i);
  void Join_varptr_Grparr(  VarPtr& p, GrpArr& ag,int i);

  void Create_grp_anyarr(  GrpArr& ag,HorOrLev hl,d_or_i di,boolean dsub,
		bb1&  b,string title,int Arrsub1,int Arrsub2,int fstsub,int lstsub);
  void Input_grp_anyArr(  GrpArr& ag,  bb1& b,string title,
			     int Arrsub1,int Arrsub2,int fstsub,int lstsub);
  void Reset_anyarr( bb1& b,int i01,int i02,int i1,int i2);
  void Load_anyarr_file(aa&  a,int i01,int i02,int i1,int i2,string dosfile);
  void Load_anyarr(  aa& a, int i01,int i02,int i1,int i2);
  void Save_anyarr_file(  aa& a,int  i01,int i02,int i1,int i2,string dosfile);
  void Save_anyarr(  aa& a, int i01,int i02,int i1,int i2);
  void Disp_anyarr(  aa& a, int i01,int i02,int i1,int i2);
  void Input_anyarr( bb1& b,int i01,int i02,int i1,int i2);
  void Modi_anyarr(  bb1& b,int i01,int i02,int i1,int i2);
  void Rand_anyarr(  bb1& b,int i01,int i02,int i1,int i2,int range1,int range2);
  void Handle_grparr_event(  pmenunode& pmenu,   GrpArr& ag);
  void Handle_grparr_menu(  mymenu& GrpArrmenu1,  boolean& selectorno,
				pmenunode& pmenu,   GrpArr& ag);
  void Handle_grparr(  GrpArr& ag);
  void Get_grparr(  GrpArr& ag);
  void Get_arrbb(  bb1& b);
  void Get_anyarr( bb1& b, int i1,int i2);
  void Get_grp_arrbb(  GrpArr& ag,  bb1& b);
  void Get_grp_anyarr(  GrpArr& ag,    bb1& b,int  i1,int i2);

//implementation
   aa a;
   bb1 b;
   GrpArr ag;
   int   lsz=0,i=0,j=0,wn=0,k=0,xm=0,ym=0,x=0, dxl=0,dyl=0,dxr=0,dyr=0;//y=0

   int key;
   vset dir_keyset(1,255),fun_keyset(1,255);
   char j1, st[10];
   string ss;
     int trace1time=0;
    const int startrow=30;
    const int keystep=5;
    const int bigstep=40;
    const int sd=4;
    const int d=0;
    const int m=2;
    const int dirnum=6;
    const int mvstep=5;
    const int step=30;
   // type  move=Array[1..dirnum,1..3] of integer;
    typedef int move[dirnum][3];
    const move mv={{0,-1,  up },
		   {0,1,down},
		   {-1,0,left},
		   {1,0,right},
		   {-4,0,bigleft},
		   {4,0,bigright}
		   };
   //{test for GrpArr}
const int  ComInputGrpArr=501;
const int  ComModiGrpArr=502;
const int  ComRandGrpArr=503;
const int  ComReadGrpArr=504;
const int  ComSaveGrpArr=505;
const int  ComSetrange=506;
const int  ComDisp=507;
const int  ComMove1=508;
const int  ComMove2=509;
const int  ComEditsub1GrpArr=510;
const int  ComEditsub2GrpArr=511;
const int  ComHorLevGrpArr=512;
const int  ComDisSubGrpArr=513;
const int  ComDecIncGrpArr=514;
const int  ComSetHighGrpArr=515;
const int  ComSetWidthGrpArr=516;

   mymenu GrpArrmenu1,GrpArrmenu2;
   pmenunode GrpMp,BMp;
   //string yn1;
   //char yn,ch;
   //int  n,
   int sb1,sb2,decinc,holv,dssb,agh,agw;

  void Set_trace1_mode(int delaytime)
     {   // <0==trace,(wait for anykey), k(>=0)==delay k ms }
	 trace1time=delaytime;
     }
  void Trace1_off()
     {	 trace1time=0;
     }

  void Trace1()
     {   Cond_waitanykey(boolean(trace1time<0),trace1time);
     }

  void Coord(  GrpArr& ag,int i,int& x,int& y)
    {
		x=ag.sx+ag.decinc*(i-ag.sub1-(1-ag.decinc)/2)*ag.dx;
		y=ag.sy+ag.decinc*(i-ag.sub1-(1-ag.decinc)/2)*ag.dy;

     }
  void Coorddm(  GrpArr& ag,int i,int& x,int& y)
    { Coord(ag,i,x,y);
	   {  x=x+(1-ag.ho_lev)*ag.w+ag.w/2*ag.ho_lev;
	      y=y+ag.ho_lev*ag.h+(1-ag.ho_lev)*ag.h/2;
	}
     }
  void Coorddml(  GrpArr& ag,int i,int& x,int& y,int l)
    {
     Coorddm(ag,i,x,y);
     x=x+(1-ag.ho_lev)*l;
     y=y+ag.ho_lev*l;
     }
  void Coord_var_m(  GrpArr& ag,int cx,int cy,int& mx,int& my)
    {
	   mx=cx+ag.ho_lev*ag.w/2;
	   my=cy+(1-ag.ho_lev)*ag.h/2;

    }
  void Coordsm(  GrpArr& ag,int i,int& x,int& y)
     {
     Coord(ag,i,x,y);
     Coord_var_m(ag,x,y,x,y);

     }
  void Coordsml(  GrpArr& ag,int i,int&  x,int& y,int l)
   {
    Coordsm(ag,i,x,y);

     x=x-(1-ag.ho_lev)*l;
     y=y-ag.ho_lev*l;

     }