Matematické Fórum

#include<iostream>
 using namespace std;
//Napište šablonu třídy Prvek, z jejichž instancí může být vytvořen spojový 
//seznam hodnot typu T. 
template <class T>
class Prvek
{
  public:
     T hodn;
     Prvek *dalsi;
     Prvek(T s, Prvek *d)
     {
        hodn=s; 
        dalsi=d;
     }
    
};
//a)
//napište šablonu funkce, která do výstupního proudu os vypíše hodnoty 
//ze spojového seznamu s.
template <class T>
ostream& vypis(ostream & os, Prvek<T>* s)
{
   while(s!=0)
   {
      os << s->hodn << " ";
      s=s->dalsi;
   }
   //cout << endl;

   return os;
}

//b)
//napište šablonu funkce jejímž výsledkem je počet prvků spojového seznamu s.
template <class T>
int pocetPrvku(Prvek<T>* s)
{
  int pp=0;
  while (s != NULL)
  { 
    pp++;
    s = s->dalsi;   
  }
  cout << pp;
}

//c)
//napište šablonu funkce, která vytvoří spojový seznam z n prvků pole p 
//tak, že hodnoty ve spojovém seznamu mají stejné pořadí, jako v poli p.
template <class T>
Prvek<T>* vytvor(T* p, int n)
{
   Prvek<T> *s;
   n=sizeof(p);
   for(int i=n; i>0; i--)
   {
      s=new Prvek<T>(p[i],s);
   }
   return s;
}

//d)
//napište šablonu funkce, která vypíše hodnoty ze seznamu s v opačném pořadí (použijte rekurzi).
template <class T>
void vypisObracene(Prvek<T>* s) 
{
   while(s)
   {
      cout << s->hodn << " ";
      s=s->dalsi;
   }
   vypisObracene(s);
   
}
//e)
//napište šablonu funkce, která ze seznamu s odstraní všechny prvky, jejichž 
//hodnota je stejná s hodnotou předcházejícího prvku a vrátí ukazatel na upravený seznam.
template <class T>
Prvek<T>* odstranDuplicity(Prvek<T>* s)
{
  Prvek<T> *pom, *pr=0, *ak=s;
  while (ak!=0)
  {
     if((ak->hodn == pr->hodn))   
     {
       pom=ak->dalsi;
       delete ak;
       if(pr)
         pr->dalsi=pom;
       else     // když není předchozí prvek
         s=pom;
       ak=pom;
    }
    else
    { 
        pr=ak;
        ak=ak->dalsi; 
    }
  }
  return s;
}
//f)
//napište šablonu funkce, která hodnoty ze spojového seznamu s uloží do dynamicky
//vytvořeného pole. Ukazatel na pole bude výsledkem funkce.
template <class T>
T* vytvorPole(Prvek<T>* s)
{
  int n=pocetPrvku(s); 
  char *p;
  p=new char [n];
  for(int i=0; i<n; i++)
  {
      p[i]=s->hodn;
      s=s->dalsi;
  }
  return p;
}


//h)
//napište šablonu funkce, která vytvoří spojový seznam hodnot obsažených 
//v seznamu s, ale v opačném pořadí.
template <class T>
Prvek<T>* vytvorObraceny(Prvek<T>* s)
{
   Prvek<T> *o;
   while(s)
   {
      o=new Prvek<T>(s->hodn,o);
      s=s->dalsi;
   }
   return o;
}

//i)
//napište šablonu funkce, která ze seznamu s odstraní všechny prvky, 
//jejichž hodnota je x a vrátí ukazatel na upravený seznam.
template <class T>
Prvek<T>* odstranX(Prvek<T>* s, T x)
{
  Prvek<T> *pom, *pr=0, *ak=s;
  while (ak!=0)
  {
     if((ak->hodn == x))   
     {
       pom=ak->dalsi;
       delete ak;
       if(pr)
         pr->dalsi=pom;
       else     // když není předchozí prvek
         s=pom;
       ak=pom;
    }
    else
    { 
        pr=ak;
        ak=ak->dalsi; 
    }
  }
  return s;       
}

//j)
//napište šablonu funkce, která vytvoří spojový seznam obsahující jeho 
//prvky s výjimkou těch, které mají hodnotu x. Ukazatel na první prvek nového seznamu je výsledkem funkce.
template <class T>
Prvek<T>* bezX(Prvek<T>* s, T x)
{
   Prvek<T> *o;
   while(s)
   {
      if(s->hodn!=x)
      {
        o=new Prvek<T>(s->hodn,o);
        s=s->dalsi;
      }
   }
   return o;  
}