SHARE
TWEET

Untitled

a guest Oct 21st, 2019 96 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include<iostream>
  2. using namespace std;
  3.  
  4. class elementD{ private: int info;
  5.                        class elementD *next;
  6.                        class elementD *prev;
  7.  
  8.                        public: elementD(){ next=NULL;}
  9.                         ~elementD(){prev = NULL;};
  10.                        int set_value(int this_value){ info=this_value;}
  11.                        int reveal_value(){ return info; }
  12.                        int set_next(elementD *next_element){ next=next_element; }
  13.                        int set_prev(elementD *prev_element){ prev=prev_element; }
  14.                        elementD *reveal_prev(){ return prev; };
  15.                        elementD *reveal_next(){ return next; }};
  16.  
  17. class some_listD{ private: elementD *start,*current,*last;
  18.                                        int lungime;
  19.  
  20.                          public: some_list(){ start=current=last=NULL;lungime=0; }
  21.                          int set_lenght(int new_lenght){ lungime=new_lenght; }
  22.                          int set_start(elementD *new_start){ start=new_start; }
  23.                          int set_current(elementD *new_current){ current=new_current; }
  24.                          int set_end(elementD *new_last){ last=new_last; }
  25.  
  26.                          elementD *reveal_end(){ return last; }
  27.                          elementD *reveal_start(){ return start; }
  28.                          int reveal_lenght(){ return lungime; }
  29.                          int stack_empty()
  30.                          {
  31.                          if(reveal_lenght()== 0) return 1;
  32.                          return 0;
  33.                          }
  34.                          elementD *reveal_current(){ return current; }
  35.                          int reveal_me(int direction){
  36.                          cout<<endl; cout<<" START : ";
  37.                          int counter=reveal_lenght();
  38.                          if ( direction==1) {
  39.                                                 elementD *walker=start;
  40.                                                 if (counter>=1){while(counter>=2){
  41.                                                         cout<<walker->reveal_value()<<" -> ";
  42.                                                         walker=walker->reveal_next();counter--;}
  43.                                                 cout<<walker->reveal_value();} cout<<" : STOP ";
  44.                                                    }
  45.                         else  {
  46.                         elementD *walker = last;
  47.                                 if (counter>=1){while(counter>=2){
  48.                                     cout<<walker->reveal_value()<<" -> ";
  49.                                             walker=walker->reveal_prev();counter--;}
  50.                                                 cout<<walker->reveal_value();} cout<<" : STOP ";
  51.                                                     }
  52.                         return 1;}
  53. };
  54.  
  55. class no_strategyD:public some_listD
  56.                       {
  57.                       public :
  58.                       int  find_value(int this_value);
  59.                       int  addsome ( int value, int direction );
  60.                       int  delsome ( int *old_value,int direction );
  61.                       };
  62.  
  63. no_strategyD L;
  64.  
  65.  
  66. int main(){
  67.  
  68. L.addsome(1,1);
  69. L.addsome(2,1);
  70. L.addsome(3,1);
  71.  
  72. L.some_listD::reveal_me(0);  // 1 2 3
  73. L.some_listD::reveal_me(1);  // 3 2 1
  74.  
  75.  
  76. return 0;
  77. }
  78.  
  79.  
  80. int  no_strategyD::addsome ( int value, int direction )
  81.                   {
  82. // Work : (1) lista vida (2) adaugare dreapta curent la sfarsit
  83.                        if (stack_empty())  {
  84.                                                     elementD *new_one;
  85.                                                     new_one->set_value(value);
  86.                                                     new_one->set_next(NULL);
  87.                                                     some_listD::set_lenght(1);
  88.                                                     some_listD::set_current(new_one);
  89.                                                     some_listD::set_start(new_one);
  90.                                                     some_listD::set_end(new_one);
  91.                                                     return -1;
  92.                                                    }
  93.                       if (direction==0) {
  94.                                                     if (some_listD::reveal_current()==some_listD::reveal_start())
  95.                                                     {
  96.                                                         // .... (!)  // pentru curent pe primul element
  97.                                                         elementD *new_one = new elementD;
  98.                                                         new_one->set_value(value);
  99.                                                         new_one->set_next(some_listD::reveal_current());
  100.                                                         elementD *walker=some_listD::reveal_start();
  101.                                                         while(walker->reveal_next()!=some_listD::reveal_end())
  102.                                                         walker=walker->reveal_next();
  103.                                                         new_one->set_next(some_listD::reveal_current());
  104.                                                         walker->set_next(new_one);
  105.                                                         some_listD::set_lenght(some_listD::reveal_lenght()+1);
  106.                                                         return -1;
  107.                                                     }
  108.                                         else {
  109.                                                     elementD *new_one=new elementD;
  110.                                                     new_one->set_value(value);
  111.                                                     new_one->set_next(some_listD::reveal_current());
  112.                                                     elementD *walker=some_listD::reveal_start();
  113.                                                     while(walker->reveal_next()!=some_listD::reveal_current())
  114.                                                                             walker=walker->reveal_next();
  115.                                                     new_one->set_next(some_listD::reveal_current());
  116.                                                     walker->set_next(new_one);
  117.                                                     some_listD::set_lenght(some_listD::reveal_lenght()+1);
  118.                                                     return 1;
  119.                                                  }
  120.                                         }
  121.  
  122.                                     //.... (!)  pentru  direction!=0 adica adaugarea la dreapta
  123.                         return 1;
  124.                       }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top