sstack.h

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

#ifndef __SSTACK_H
#define __SSTACK_H

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


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


struct  SeqStack
	 {
	   string name;
	   bb1 data;
	   ArrPtr PTop;
	   int top;
	   GrpArr ag;
	 };

  void  SeqStack_setnull(SeqStack& s);
  void  SeqStack_push(SeqStack& s,datatype x);
  void  SeqStack_pop(SeqStack& s, datatype& x);
  datatype  SeqStack_top(SeqStack& s);
  boolean  SeqStack_empty(SeqStack& s);
  void load_SeqStack_file(SeqStack& s,string  dosfile);
  void load_SeqStack(SeqStack& L);
  void save_SeqStack_file(SeqStack& L,string dosfile);
  void save_SeqStack(SeqStack& L);

  void set_SeqStack(SeqStack& L,string title,int s1,int e1);
  void set_SeqStack_dir(SeqStack& L,string title,HorOrLev hl,d_or_i di,
			    int s1,int e1);
  void change_SeqStack_dir(SeqStack& s,HorOrLev hl,d_or_i di);
  void initial_SeqStack(SeqStack& L);
  void initial_SeqStack_Top(SeqStack& L);
  int  SeqStack_minsub(SeqStack& L);
  int  SeqStack_maxsub(SeqStack& L);
  int  SeqStack_cursub(SeqStack& L);

  void display_SeqStack(SeqStack& L);
  void display_SeqStack_top(SeqStack& L);
  void move_SeqStack_to(SeqStack& L,int x,int y);
  void move_SeqStack_dxy(SeqStack& L,int x,int y);
  void move_SeqStack_mid(SeqStack& L,int x0,int y0);
  void move_SeqStack(SeqStack& L);
  void move1_SeqStack(SeqStack& L);
  void clear_SeqStack_range(SeqStack& L);
  void set_SeqStack_range(SeqStack& L);
  void set_SeqStack_to(SeqStack& L,int  x,int y);
  void SeqStack_range(SeqStack& L,int& x1,int& y1,int& x2,int& y2);

  void reset_SeqStack_elmn(SeqStack& L,int i);
  void reset_SeqStack(SeqStack& L);
  void clear_SeqStack_elmn(SeqStack& L,int i);
  void clear_SeqStack(SeqStack& L);
  void modi_SeqStack(SeqStack& L);
  void rand_SeqStack(SeqStack& L,int  range1,int range2);
  void input_SeqStack(SeqStack& L);

  int  SeqStack_sx1(SeqStack& L);
  int  SeqStack_sy1(SeqStack& L);
  int  SeqStack_elmnhigh(SeqStack& L);
  int  SeqStack_elmnwidth(SeqStack& L);
  void set_SeqStack_elmnsize(SeqStack& L,int hh,int ww);

  datatype  SeqStack_elmn(SeqStack& L,int i);
  void put_SeqStack_elmn(SeqStack& L,int i,datatype v,int hl);
  boolean  cmp_SeqStack_elmn(SeqStack& L,int i,int j,string op,int hl);
  void move_SeqStack_elmn(SeqStack& L,int i,int j,int hl);
  void xchg_SeqStack_elmn(SeqStack& L,int i,int j,int hl);
  void SeqStack_elmn_ptr_elmn(SeqStack& L,int i,int hl);
  void cur_SeqStack_elmn_onoff(SeqStack& L,int i);
  void display_SeqStack_elmn(SeqStack& L,int  i);
  void set_SeqStack_top(SeqStack& L, int i);
  void inc_SeqStack_top(SeqStack& L,int i);
  void dec_SeqStack_top(SeqStack& L, int i);

  void handle_SeqStack_event(pmenunode& pmenu, SeqStack& L);
  void handle_SeqStack_menu( mymenu& GrpArrmenu1, boolean& selectorno,
			       pmenunode& pmenu, SeqStack& L);
  void handle_SeqStack(SeqStack& L);
  void get_SeqStack(SeqStack& L);



  void  SeqStack_setnull(SeqStack& s)
    {  s.top=0;
    clear_SeqStack(s);//{display_SeqStack(s)}
     }
  void  SeqStack_push(SeqStack& s,datatype x)
    { // with s do
	 if  (s.top==SeqStack_maxsub(s))
	    cout<<"stack"<<s.name<<"overflow"<<endl;//error_exit('Stack '+name+' overflow!');
	 put_elmn(s.ag,s.top+1, x, 0);
	 inc_SeqStack_top(s,1);
    }
  void  SeqStack_pop(SeqStack& s,datatype& x)
    {//  with s do
	if (s.top==0 )
	  cout<<"stack"<<s.name<<" down overflow"<<endl; // error_exit('Stack '+name+' down overflow ');
	  x=s.data[s.top];
	  dec_SeqStack_top(s,1);
	   clear_SeqStack_elmn(s,s.top+1);
    }
  datatype  SeqStack_top(SeqStack& s)
    {
    // with s do
    if (s.top==0 )
      {
	   cout<<"stack"<<s.name<<" is empty, cannot get top"<<endl;// error('Stack '+name+' is empty, cannot get top ')
	   return datatype(0);
      }
     else {  cur_SeqStack_elmn_onoff(s,s.top);
	    datatype SeqStack_top=s.data[s.top];
	   getch();
	   cur_SeqStack_elmn_onoff(s,s.top);
	   return SeqStack_top;
	  }
     }
  boolean  SeqStack_empty(SeqStack& s)
    { boolean SeqStack_empty=boolean(s.top==0) ;
    return SeqStack_empty;   }

  void load_SeqStack_file(SeqStack& L,string dosfile)
    {  load_Arrbb_file(L.data,sub1(L.ag),sub2(L.ag),dosfile); }
  void load_SeqStack(SeqStack& L)
    {  load_Arrbb(L.data,sub1(L.ag),sub2(L.ag));   }
  void save_SeqStack_file(SeqStack& L,string dosfile)
    {  save_Arrbb_file(L.data,sub1(L.ag),sub2(L.ag), dosfile); }
  void save_SeqStack(SeqStack& L)
    {  save_Arrbb(L.data,sub1(L.ag),sub2(L.ag));   }

  void initial_SeqStack(SeqStack& L)
     {  Into_graph();
	create_arrptr(L.PTop,"Top",L.ag,20);
	initial_SeqStack_Top(L);
	initial_GrpArr(L.ag);
     }
  void set_SeqStack(SeqStack& 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_SeqStack( L );
    }
   void set_SeqStack_dir(SeqStack& 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_SeqStack(L);
    }
  void change_SeqStack_dir(SeqStack& L,HorOrLev hl,d_or_i di)
    { // with L.ag do {
	L.ag.ho_lev=hl; L.ag.decinc=di;
		   initial_SeqStack(L);
    }
  void initial_SeqStack_Top(SeqStack& L)
    {  L.top=SeqStack_minsub(L)-1; }
  int   SeqStack_minsub(SeqStack& L)
    {  int SeqStack_minsub=sub1(L.ag);
    return SeqStack_minsub;
    }
  int  SeqStack_maxsub(SeqStack& L)
    { int SeqStack_maxsub=sub2(L.ag);
    return SeqStack_maxsub;
    }
  int  SeqStack_cursub(SeqStack& L)
    { int  SeqStack_cursub=L.top;
      return SeqStack_cursub;
      }