grary1.h

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

#ifndef __GRARY1_H
#define __GRARY1_H

#if !defined(__TOOLS_H)
#include"tools.h"
#endif


#define    maxnum  100
#define    minsubaa  1
#define    minsubbb  -10
#define    horizon  1
#define    vertical  0
#define    SubDec   -1
#define    SubInc   1
#define   nil    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(){ delete []element; }
   };

   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];
     }


  class aa:public vararray
 {
 public:
 aa( int m=1, int s=100): vararray(m,s){}

 };

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

#ifdef __GRAPH2_H
 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);
 };

     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;
	    }


     boolean set::deletes(int val)

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

#endif


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

  typedef void far  * Arrptrfd;

  typedef  int datatype;
   class arlnode
	 {
	public:
	  int  oldx,oldy,ox1,oy1,hl,cursub;
	   Arrptrfd fd0,fd1;
	   int   size0,size1;
	   boolean hide;
	   string  ptr_name;
	   arlnode far *next;
	   arlnode(){ptr_name=nil;next=nil;fd0=nil;fd1=nil;}
	   ~arlnode(){};
	   };

     typedef arlnode far * ArrPtr;
    //	VarPtr=^vrlnode;
       class	vrlnode
	  {
	 public:
	  int  vx, vy, hl, cursub, varopnum;
	  datatype v;
	  string  var_name;
	  vrlnode  far* next;
	  vrlnode() {var_name=nil;next=nil; }
	  ~vrlnode(){};
	  };


    typedef vrlnode far * VarPtr;
     class  GrpArr
	{ public:
	   int far* 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;
	   GrpArr(){name=nil;firstptr=nil;firstvar=nil;datafild[0]=nil;datafild[1]=nil;ag1=nil;}
	   ~GrpArr();
	 };

       GrpArr::~GrpArr()
      { ArrPtr p1=nil,p2=nil;
       VarPtr q1=nil,q2=nil;

       p1=this->firstptr;
       q1=this->firstvar;
     while(p1!=nil)
     {
       p2=p1->next;
       if(p1->fd0!=nil)
	   farfree(p1->fd0);
       delete p1;
       p1=p2;
       }
       while(q1!=nil)
       {
	q2=q1->next;
	delete q1;
	q1=q2;
       }
      ffield   r=this->datafild[0];
      if (r!=nil)
	 farfree(this->datafild[0]);
      r=this->datafild[1];
      if (r!=nil)
	 farfree(this->datafild[1]);

    }

  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& b,int sn,int en,string dosfile);
  void load_Arrbb(  bb1& b,int sn,int en);
  void save_Arrbb_file(  bb1& a,int sn,int en,string dosfile);
  void save_Arrbb(  bb1& b,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_GrpArr_elmn(  GrpArr& ag,int i);
  void clear_GrpArr(  GrpArr& ag);
  void modi_GrpArr(  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(bb1&  b,int i01,int i02,int i1,int i2,string dosfile);
  void load_AnyArr(  bb1& b, int i01,int i02,int i1,int i2);
  void save_AnyArr_file(  bb1& b,int  i01,int i02,int i1,int i2,string dosfile);
  void save_AnyArr(  bb1& b, int i01,int i02,int i1,int i2);
  void disp_AnyArr(  bb1& b, 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);
  void  clear_space(GrpArr& ag);




int trace1time;

#ifndef constvar
#define constvar
    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;
    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}};
 #endif

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;


  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;

     }

  void coordtwo(  GrpArr& ag,int i,int hl,int&  x1,int& y1,int& x2,int& y2)
     {  if (hl<0)
	    { coordsm(ag,i,x1,y1);
	     coordsml(ag,i,x2,y2,-hl);
	      }
     else  {
	    coorddm(ag,i,x1,y1);
	    coorddml(ag,i,x2,y2,hl);  }
     }

  void fifild(  GrpArr& ag,int i,int orxor)
      {    int x=0,y=0;
	   coord(ag,i,x,y);
	   putimage(x+1,y+1,ag.datafild[ag.fdsub],orxor);
    }
  int far*relptr(int far*p,int rel)
    {int far * relptr=nil;
	  relptr=p+rel;
     return relptr;   }

  int  far* nextptr(int far*p)
    {int far* nextptr=nil;
	    nextptr=p+1;
	    return nextptr;
	    }
  int  far*grp_elmn_ptr(  GrpArr& ag,int i)
    {int far* grp_elmn_ptr=nil;
	   grp_elmn_ptr=relptr(ag.ag1,i-ag.sub1);
	   return grp_elmn_ptr;}
  datatype elmn(  GrpArr& ag,int i)
    {
     datatype elmn= datatype(*relptr(ag.ag1,i-ag.sub1));

      return elmn;   }

    void disnodedat(  GrpArr& ag,int i)
    { int x=0,y=0;
      unsigned char st[8]="";
      fifild(ag,i,0);
      fifild(ag,i,1);
      coord(ag,i,x,y);
      Convs(elmn(ag,i),st);
      outtextxy(x+ag.w/6,y+ag.h/2,st);

    }
  void disp_elmn_data(  GrpArr& ag,int  i)
    {  disnodedat(ag,i); }
  void display_GrpArr_elmn(  GrpArr& ag,int i)
    { disnodedat(ag,i); }
  void dissub(  GrpArr& ag)
     {  int x=0,y=0;
	unsigned char st[8]="";
	for (int i=ag.sub1; i<=ag.count+ag.sub1-1;i++)
	    {     coordsml(ag,i,x,y,((1-ag.ho_lev)*ag.w+ag.ho_lev*ag.h)/4);
		   Convs(i,st);
		   outtextxy(x-10,y,st);

	    }
    }
  void disp_sub(  GrpArr& ag)
     {  dissub(ag); }
  void InitElmnSize( GrpArr& ag)
    {

	  if (ag.ho_lev==0)
		{ ag.dx=0; ag.dy=16;  ag.h=16;ag.w=30; }
	  else
		{ ag.dx=30; ag.dy=0;  ag.h=30; ag.w=30; }

    }
  void create_grp_Arrbb(  GrpArr& ag,HorOrLev hl,d_or_i di,
		boolean dsub,  bb1& b, string title, int fstsub,int lstsub)
    {
	    { ag.sub1=fstsub;
	      ag.count=Min(lstsub-fstsub+1,maxnum);
	      ag.dsb=dsub;
	      ag.firstptr=NULL;
	      ag.firstvar=NULL;