squeue.h

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

#ifndef __SQUEUE_H
#define __SQUEUE_H

#if !defined(__GRARY1_H)
#include"grary1.h"
#endif

struct  SeqQueue
	  { string name;
	   bb1 data;
	   ArrPtr PFront,PRear;
	   int Front,Rear;
	   GrpArr ag;
	   };

  void SeqQueue_setnull(SeqQueue& s);
  void SeqQueue_enqueue(SeqQueue& s,datatype x);
  void SeqQueue_outqueue(SeqQueue& s,datatype& x);
  datatype   SeqQueue_front(SeqQueue& s);
 boolean    seqQueue_empty(SeqQueue& s);

  void load_SeqQueue_file(SeqQueue& L ,string dosfile);
  void load_SeqQueue(SeqQueue& L);
  void save_SeqQueue_file(SeqQueue& L,string dosfile);
  void save_SeqQueue(SeqQueue& L);

  void set_SeqQueue(SeqQueue& L,string title,int  s1,int e1);
  void set_SeqQueue_dir(SeqQueue& L,string title,HorOrLev hl,d_or_i di,
			   int s1,int e1);
  void change_SeqQueue_dir(SeqQueue& L,HorOrLev hl,d_or_i di);
  void initial_SeqQueue(SeqQueue& L);
  void initial_SeqQueue_front(SeqQueue& L);
  void initial_SeqQueue_rear(SeqQueue& L);
  int   SeqQueue_minsub(SeqQueue& L);
  int   SeqQueue_maxsub(SeqQueue& L);
  int   SeqQueue_cursub(SeqQueue& L);

  void display_SeqQueue(SeqQueue& L);
  void display_SeqQueue_front(SeqQueue& L);
  void display_SeqQueue_rear(SeqQueue& L);
  void move_SeqQueue_to(SeqQueue& L,int x,int y);
  void move_SeqQueue_dxy(SeqQueue& L,int x,int y);
  void move_SeqQueue_mid(SeqQueue& L,int x0,int y0);
  void move_SeqQueue(SeqQueue& L);
  void move1_SeqQueue(SeqQueue& L);
  void clear_SeqQueue_range(SeqQueue& L);
  void set_SeqQueue_range(SeqQueue& L);
  void set_SeqQueue_to(SeqQueue& L,int  x,int y);
  void SeqQueue_range(SeqQueue& L,int& x1,int& y1,int& x2,int& y2);

  void reset_SeqQueue_elmn(SeqQueue& L,int i);
  void reset_SeqQueue(SeqQueue& L);
  void clear_SeqQueue_elmn(SeqQueue& L,int i);
  void clear_SeqQueue(SeqQueue& L);
  void modi_SeqQueue(SeqQueue& L);
  void rand_SeqQueue(SeqQueue& L,int  range1,int range2);
  void input_SeqQueue(SeqQueue& L);

 int  SeqQueue_sx1(SeqQueue& L);
 int  SeqQueue_sy1(SeqQueue& L);
 int  SeqQueue_elmnhigh(SeqQueue& L);
 int  SeqQueue_elmnwidth(SeqQueue& L);
  void set_SeqQueue_elmnsize(SeqQueue& L,int hh,int ww);

 datatype  SeqQueue_elmn(SeqQueue& L,int i);
  void put_SeqQueue_elmn(SeqQueue& L,int i,datatype v,int hl);
  boolean  cmp_SeqQueue_elmn(SeqQueue& L,int i,int j,string op,int hl);
  void move_SeqQueue_elmn(SeqQueue& L,int i,int j,int hl);
  void xchg_SeqQueue_elmn(SeqQueue& L,int i,int j,int hl);
  void SeqQueue_elmn_ptr_elmn(SeqQueue& L,int i,int hl);
  void cur_SeqQueue_elmn_onoff(SeqQueue& L,int i);
  void display_SeqQueue_elmn(SeqQueue& L,int  i);
  void set_SeqQueue_front(SeqQueue& L, int i);
  void set_SeqQueue_rear(SeqQueue& L, int i);
  void inc_SeqQueue_front(SeqQueue& L,int  i );
  void inc_SeqQueue_rear (SeqQueue& L, int i);

  void handle_SeqQueue_event(pmenunode& pmenu, SeqQueue& L);
  void handle_SeqQueue_menu(mymenu& GrpArrmenu1, boolean&selectorno,
			       pmenunode&pmenu, SeqQueue& L);
  void handle_SeqQueue(SeqQueue& L);
  void get_SeqQueue(SeqQueue& L);


/*const   {test for GrpArr}
  CominputGrpArr=501;    CommodiGrpArr=502; ComrandGrpArr=503;
  ComreadGrpArr=504;       ComsaveGrpArr=505;
  Comsetrange=506;         Comdisp=507;
  Commove1=508;            Commove2=509;
  ComEditsub1GrpArr=510;   Comeditsub2GrpArr=511;
  ComHorLevGrpArr=512;     ComDisSubGrpArr=513; ComDecIncGrpArr=514;
  ComSetHighGrpArr=515;    ComSetWidthGrpArr=516;
 //var GrpArrmenu1,GrpArrMenu2:mymenu; GrpMp,BMp:pmenunode;
     yn1:string;  yn,ch:char;  n,sb1,sb2,decinc,holv,dssb,agh,agw:integer;
 */

  void SeqQueue_setnull(SeqQueue& s)
    {   clear_GrpArr(s.ag);
       initial_SeqQueue_front(s);
       initial_SeqQueue_rear(s);
    }

  int next(SeqQueue& s,int RorF)
     { int next;
	if (RorF==SeqQueue_maxsub(s))
	     next=SeqQueue_minsub(s);
	   else
	      next=RorF+1;
	return next;
      }
  void SeqQueue_enqueue(SeqQueue& s,datatype x)
    {
      // with s do
       if  (next(s,s.Rear)==s.Front)
	      cout<<"Queue "<<s.name<<"overflow!";// error('Queue '+name+' overflow!')
	 else { s.Rear=next(s,s.Rear);

		put_elmn(s.ag,s.Rear, x, 0);
		display_SeqQueue_rear(s);
	       }
    }
  void SeqQueue_outqueue(SeqQueue& s,datatype&  x)
    {  //with s do
	 if (s.Front==s.Rear)  cout<<" Queue "<<s.name<<"down overflow";
	 // error_exit('Queue '+name+' down overflow ');
	     s.Front=next(s,s.Front);
	      x=s.data[s.Front];
	     display_SeqQueue_front(s);
	     clear_SeqQueue_elmn(s,s.Front);
    }
  datatype   SeqQueue_front(SeqQueue& s)
    { // with s do
      if (s.Front==s.Rear)
	  { cout<<"Queue "<<s.name<<" is empty, cannot get top";
	    //Error('Queue '+name+' is empty, cannot get top ')
	    return  datatype(0);
	    }
      else {     cur_SeqQueue_elmn_onoff(s,next(s,s.Front));
		datatype	  SeqQueue_front=s.data[next(s,s.Front)];
		  getch();
		  cur_SeqQueue_elmn_onoff(s,next(s,s.Front));
		 return  SeqQueue_front ;
	   }
      }
  boolean SeqQueue_empty(SeqQueue& s)
    {boolean  SeqQueue_empty=boolean(s.Front==s.Rear);
    return SeqQueue_empty;   }


  void load_SeqQueue_file(SeqQueue& L,string  dosfile)
    {  load_Arrbb_file(L.data,sub1(L.ag),sub2(L.ag),dosfile); }
  void load_SeqQueue(SeqQueue& L)
    {   load_Arrbb(L.data,sub1(L.ag),sub2(L.ag));   }
  void save_SeqQueue_file(SeqQueue& L,string dosfile)
    {  save_Arrbb_file(L.data,sub1(L.ag),sub2(L.ag), dosfile); }
  void save_SeqQueue(SeqQueue& L)
    {  save_Arrbb(L.data,sub1(L.ag),sub2(L.ag));   }

  void initial_SeqQueue_front(SeqQueue& L)
    {  L.Front=SeqQueue_minsub(L)-1; }
  void initial_SeqQueue_rear(SeqQueue& L)
    {  L.Rear=SeqQueue_minsub(L)-1; }
  void initial_SeqQueue(SeqQueue& L)
     {  Into_graph();
	create_arrptr(L.PFront,"Font",L.ag,20);
	create_arrptr(L.PRear,"Rear",L.ag,35);
	initial_SeqQueue_front(L);
	initial_SeqQueue_rear(L);
	initial_GrpArr(L.ag);
     }

  void set_SeqQueue(SeqQueue& L,string  title,int  s1,int e1)
    {  create_grp_Arrbb(L.ag,(HorOrLev)horizon,(d_or_i)1,true,L.data,"Data",s1,e1);
	   L.name=title;   initial_SeqQueue( L );
    }
  void set_SeqQueue_dir(SeqQueue& L,string title,HorOrLev hl,d_or_i di,int s1,int e1)
      {  create_grp_Arrbb(L.ag,hl,di,true,L.data,"Data",s1,e1);
	   L.name=title;   initial_SeqQueue(L);
    }
  void change_SeqQueue_dir(SeqQueue& L,HorOrLev hl,d_or_i di)
    { // with L.ag do {
	 L.ag.ho_lev=hl;
	 L.ag.decinc=di ;
	 initial_SeqQueue(L);
    }
  int  SeqQueue_minsub(SeqQueue& L)
    { int SeqQueue_minsub=sub1(L.ag);
    return  SeqQueue_minsub; }
  int   SeqQueue_maxsub(SeqQueue& L)
    { int SeqQueue_maxsub=sub2(L.ag);
    return  SeqQueue_maxsub; }
  int   SeqQueue_cursub(SeqQueue& L)
     {int  SeqQueue_cursub=L.Front;
     return SeqQueue_cursub;
      }

  void display_SeqQueue(SeqQueue& L)
    {int  x1,y1,x2,y2,i;
       SeqQueue_range(L, x1,y1,x2,y2);
       Clear_range(x1,y1,x2,y2);
      display_GrpArr(L.ag);
      Arrptr_point_to(L.PFront,L.ag,L.Front);
      Arrptr_point_to(L.PRear,L.ag,L.Rear);
      outtextxy(x1+10,(y1+y2)/2,L.name);
      rectangle(x1+20,y1,x2,y2);
    }
  void display_SeqQueue_front(SeqQueue& L)
    { //create_arrptr(L.PFront,"Font",L.ag,20);
      Arrptr_point_to(L.PFront,L.ag,L.Front); }
  void display_SeqQueue_rear(SeqQueue& L)
    { //create_arrptr(L.PRear,"Rear",L.ag,35);
      Arrptr_point_to(L.PRear,L.ag,L.Rear); }
  void move_SeqQueue_to(SeqQueue& L,int x,int y)
     {  L.ag.sx=x; L.ag.sy=y;
       display_SeqQueue(L) ;  }
  void move_SeqQueue_dxy(SeqQueue& L,int x,int y)
     {
	 clear_SeqQueue_range(L);

	   L.ag.sx=L.ag.sx+x; L.ag.sy=L.ag.sy+y;
	   display_SeqQueue(L);
     }
  void move_SeqQueue_mid(SeqQueue& L,int x0,int y0)
     {   clear_SeqQueue_range(L);
	   move_GrpArr_mid(L.ag,x0,y0);
	    display_SeqQueue(L);
     }
  void move_SeqQueue(SeqQueue& L)
     {
     //clear_SeqQueue_range(L);
     move_GrpArr(L.ag);
     display_SeqQueue(L);
     }
  void move1_SeqQueue(SeqQueue& L)
     { //clear_SeqQueue_range(L);
       move1_GrpArr(L.ag);
       display_SeqQueue(L);
	}

  void clear_SeqQueue_range(SeqQueue& L)
    {int  x1,y1,x2,y2;
      SeqQueue_range(L, x1,y1,x2,y2);
      Clear_range(x1,y1,x2,y2);
       }
  void set_SeqQueue_range(SeqQueue& L)
    { set_GrpArr_range(L.ag);
    }

  void set_SeqQueue_to(SeqQueue& L,int x,int y)
    {  set_GrpArr_to(L.ag, x,y);  }
  void SeqQueue_range(SeqQueue& L,int& x1,int& y1,int& x2,int& y2)
    {  GrpArr_range(L.ag,x1,y1,x2,y2);
       x1=x1-20;
       y2=y2+elmnhigh(L.ag);
	}

  void reset_SeqQueue_elmn(SeqQueue& L,int i)
     { reset_GrpArr_elmn( L.ag,i);
     }
  void reset_SeqQueue(SeqQueue& L)
     { reset_GrpArr( L.ag); }
  void clear_SeqQueue_elmn(SeqQueue& L,int i)
     {  clear_GrpArr_elmn(L.ag,i); }
  void clear_SeqQueue(SeqQueue& L)
     {  clear_GrpArr(L.ag); }
  void modi_SeqQueue(SeqQueue& L)
     {  modi_GrpArr(L.ag);
     }
  void rand_SeqQueue(SeqQueue& L,int range1,int range2)
     { rand_GrpArr(L.ag,range1,range2);
     }
  void input_SeqQueue(SeqQueue& L)
     { input_GrpArr(L.ag);
     }