Need a unique gift idea?
A Pastebin account makes a great Christmas gift
SHARE
TWEET

Untitled

a guest Aug 10th, 2018 56 Never
Upgrade to PRO!
ENDING IN00days00hours00mins00secs
 
  1. #include <iostream>
  2. #include <string>
  3. #include <sstream>
  4. using namespace std;
  5.  
  6. struct calkowita {
  7.     int wartosc;
  8.     int numerRekordu;
  9.     calkowita* lewy_syn;
  10.     calkowita* prawy_syn;
  11. };
  12.  
  13. struct zmienno {
  14.     float wartosc;
  15.     int numerRekordu;
  16.     zmienno* lewy_syn;
  17.     zmienno* prawy_syn;
  18. };
  19.  
  20. struct ciag {
  21.     string wartosc;
  22.     int numerRekordu;
  23.     ciag* lewy_syn;
  24.     ciag* prawy_syn;
  25. };
  26. int licznikcalkowita = 0;
  27. int licznikzmienno = 0;
  28. int licznikciag = 0;
  29. calkowita* calkowite = NULL;
  30. zmienno* zmiennoprzecinkowe = NULL;
  31. ciag* ciagi = NULL;
  32. string* wyniki;
  33.  
  34. template <class par1, class par2>
  35. int znajdz(par1 wezel, par2 klucz) { // false - znaleziono; true - nie znaleziono
  36.     if(wezel == NULL) {                  
  37.         return 0;
  38.     } else if(wezel->wartosc == klucz) {
  39.         return 1;
  40.     } else if(klucz < wezel->wartosc) {
  41.         return znajdz(wezel->lewy_syn, klucz);
  42.     } else {
  43.         return znajdz(wezel->prawy_syn, klucz);
  44.     }
  45. }
  46.  
  47. template <class par1, class par2>
  48. par1 znajdzPoKluczu(par1 wezel, par2 klucz) { // false - znaleziono; true - nie znaleziono
  49.     if(wezel == NULL) {                  
  50.         return NULL;
  51.     } else if(wezel->wartosc == klucz) {
  52.         return wezel;
  53.     } else if(klucz < wezel->wartosc) {
  54.         return znajdzPoKluczu(wezel->lewy_syn, klucz);
  55.     } else {
  56.         return znajdzPoKluczu(wezel->prawy_syn, klucz);
  57.     }
  58. }
  59.  
  60. int znajdz(ciag* wezel, string klucz) { // false - znaleziono; true - nie znaleziono
  61.     if(wezel == NULL) {                  
  62.         return 0;
  63.     } else if(wezel->wartosc.compare(klucz) == 0) {
  64.         return 1;
  65.     } else if(klucz.compare(wezel->wartosc) < 0) {
  66.         return znajdz(wezel->lewy_syn, klucz);
  67.     } else {
  68.         return znajdz(wezel->prawy_syn, klucz);
  69.     }
  70. }
  71.  
  72. ciag* znajdzPoKluczu(ciag* wezel, string klucz) {
  73.     if(wezel == NULL) {                  
  74.         return NULL;
  75.     } else if(wezel->wartosc.compare(klucz) == 0) {
  76.         return wezel;
  77.     } else if(klucz.compare(wezel->wartosc) < 0) {
  78.         return znajdzPoKluczu(wezel->lewy_syn, klucz);
  79.     } else {
  80.         return znajdzPoKluczu(wezel->prawy_syn, klucz);
  81.     }
  82. }
  83.  
  84. template <class par1, class par2>
  85. par1 znajdzPoNumerze(par1 wezel, par2 numer) {
  86.     if(wezel->lewy_syn != NULL) return znajdzPoNumerze(wezel->lewy_syn, numer);
  87.     if(wezel->numerRekordu == numer) {
  88.         return wezel;
  89.     }
  90.     if(wezel->prawy_syn != NULL) return znajdzPoNumerze(wezel->prawy_syn, numer);
  91. }
  92.  
  93. template <class par1, class par2>
  94. void znajdzWartoscPoNumerze(par1 wezel, par2 numer) {
  95.     if(wezel->lewy_syn != NULL) znajdzWartoscPoNumerze(wezel->lewy_syn, numer);
  96.     if(wezel->numerRekordu == numer) {
  97.         cout<<wezel->wartosc<<endl;
  98.     }
  99.     if(wezel->prawy_syn != NULL) znajdzWartoscPoNumerze(wezel->prawy_syn, numer);
  100. }
  101. /*template <class par1, class par2>
  102. par1 znajdzNumer(par1 wezel, par2 numer) {
  103.     if(wezel->lewy_syn != NULL) return znajdzNumer(wezel->lewy_syn, numer);
  104.     if(wezel->wartosc == numer) {
  105.         return wezel;
  106.     }
  107.     if(wezel->prawy_syn != NULL) return znajdzNumer(wezel->prawy_syn, numer);
  108. }*/
  109.  
  110.  
  111. void dodaj(calkowita* &wezel, int wartosc) {
  112.     if(wezel == NULL) {
  113.         wezel = new calkowita;
  114.         wezel->wartosc = wartosc;
  115.         wezel->lewy_syn = NULL;
  116.         wezel->prawy_syn = NULL;
  117.         licznikcalkowita++;
  118.         wezel->numerRekordu = licznikcalkowita;
  119.         return;
  120.     } else if(wezel->wartosc == wartosc) {
  121.         return;
  122.     } else if(wartosc < wezel->wartosc) {
  123.         dodaj(wezel->lewy_syn, wartosc);
  124.     } else {
  125.         dodaj(wezel->prawy_syn, wartosc);
  126.     }
  127. }
  128.  
  129. void dodaj(zmienno* &wezel, float wartosc) {
  130.     if(wezel == NULL) {
  131.         wezel = new zmienno;
  132.         wezel->wartosc = wartosc;
  133.         wezel->lewy_syn = NULL;
  134.         wezel->prawy_syn = NULL;
  135.         licznikzmienno++;
  136.         wezel->numerRekordu = licznikzmienno;
  137.         return;
  138.     } else if(wezel->wartosc == wartosc) {
  139.         return;
  140.     } else if(wartosc < wezel->wartosc) {
  141.         dodaj(wezel->lewy_syn, wartosc);
  142.     } else {
  143.         dodaj(wezel->prawy_syn, wartosc);
  144.     }
  145. }
  146.  
  147. void dodaj(ciag* &wezel, string wartosc) {
  148.     if(wezel == NULL) {
  149.         wezel = new ciag;
  150.         wezel->wartosc = wartosc;
  151.         wezel->lewy_syn = NULL;
  152.         wezel->prawy_syn = NULL;
  153.         licznikciag++;
  154.         wezel->numerRekordu = licznikciag;
  155.         return;
  156.     } else if(wezel->wartosc.compare(wartosc) == 0) {
  157.         return;
  158.     } else if(wezel->wartosc.compare(wartosc) > 0) {
  159.         dodaj(wezel->lewy_syn, wartosc);
  160.     } else {
  161.         dodaj(wezel->prawy_syn, wartosc);
  162.     }
  163. }
  164.  
  165. template <class par1, class par2>
  166. bool usun(par1* &wezel, par2 wartosc) { // false - nie ma takiego klucza; true - usunięto
  167.     if(wezel == NULL) {
  168.         return false;
  169.     } else if(wezel->wartosc == wartosc) {
  170.         if(wezel->lewy_syn == NULL && wezel->prawy_syn == NULL) { // węzeł jest liściem
  171.             delete wezel;
  172.         } else if(wezel->lewy_syn != NULL && wezel->prawy_syn == NULL) { // węzeł ma tylko lewego syna
  173.             wezel = wezel->lewy_syn;
  174.             delete wezel->lewy_syn;
  175.         } else if(wezel->prawy_syn != NULL && wezel->lewy_syn == NULL) { // węzeł ma tylko prawego syna
  176.             wezel = wezel->prawy_syn;
  177.             delete wezel->prawy_syn;
  178.         } else { // węzeł ma dwóch synów
  179.             par1 *poprzednik = new par1;
  180.             poprzednik = wezel->lewy_syn;
  181.             while(poprzednik->prawy_syn!=NULL) {
  182.                 poprzednik = poprzednik->prawy_syn;
  183.             }
  184.             wezel->wartosc = poprzednik->wartosc;
  185.             usun(poprzednik, poprzednik->wartosc);
  186.         }
  187.     } else if(wartosc < wezel->wartosc) {
  188.         return usun(wezel->lewy_syn, wartosc);
  189.     } else {
  190.         return usun(wezel->prawy_syn, wartosc);
  191.     }
  192. }
  193.  
  194. /*string przedzial(ciag* wezel, string poczatek, string koniec) { // in order
  195.     ostringstream tmp;
  196.  
  197.     if(wezel->lewy_syn != NULL) tmp << przedzial(wezel->lewy_syn, poczatek, koniec);
  198.     if(wezel->wartosc >= poczatek && wezel->wartosc <= koniec) {
  199.         zmienno* tmp1;
  200.         calkowita* tmp2;
  201.         tmp1 = znajdzPoNumerze(zmiennoprzecinkowe, wezel->numerRekordu);
  202.         tmp2 = znajdzPoNumerze(calkowite, wezel->numerRekordu);
  203.  
  204.         tmp<<tmp2->wartosc<<endl;
  205.         tmp<<tmp1->wartosc<<endl;
  206.         tmp<<wezel->wartosc<<endl;
  207.     }
  208.     if(wezel->prawy_syn != NULL) tmp << przedzial(wezel->prawy_syn, poczatek, koniec);
  209.     return tmp.str();
  210. }*/
  211.  
  212. void przedzial(calkowita* wezel, int poczatek, int koniec) { // in order
  213.     if(wezel->lewy_syn != NULL)  przedzial(wezel->lewy_syn, poczatek, koniec);
  214.     if(wezel->wartosc >= poczatek && wezel->wartosc <= koniec) {
  215.         znajdzWartoscPoNumerze(zmiennoprzecinkowe, wezel->numerRekordu);
  216.         znajdzWartoscPoNumerze(calkowite, wezel->numerRekordu);
  217.         znajdzWartoscPoNumerze(ciagi, wezel->numerRekordu);
  218.     }
  219.     if(wezel->prawy_syn != NULL)  przedzial(wezel->prawy_syn, poczatek, koniec);
  220. }
  221.  
  222. template <class par1, class par2, class par3>
  223. void dupa(par1 wezel, par2 poczatek, par3 koniec) {
  224.     ciag* tmp3 = new ciag;
  225.     ostringstream tmp;
  226.     if(wezel->lewy_syn != NULL) dupa(wezel->lewy_syn, poczatek, koniec);
  227.     if(wezel->wartosc >= poczatek && wezel->wartosc <= koniec) {
  228.         cout<<wezel->wartosc<<" "<<wezel->numerRekordu<<endl;
  229.     }
  230.     if(wezel->prawy_syn != NULL) dupa(wezel->prawy_syn, poczatek, koniec);
  231. }
  232.  
  233. void wstaw() {
  234.     int a;
  235.     float b;
  236.     string c;
  237.     cin>>a>>b>>c;
  238.     dodaj(calkowite, a);
  239.     dodaj(zmiennoprzecinkowe, b);
  240.     dodaj(ciagi, c);
  241. }
  242. void usunRekord() {
  243.     int a;
  244.     cin>>a;
  245.     if(a == 0) {
  246.         int dousuniecia;
  247.         cin>>dousuniecia;
  248.         zmienno* tmp1;
  249.         calkowita* tmp2;
  250.         ciag* tmp3;
  251.         tmp2 = znajdzPoKluczu(calkowite, dousuniecia);
  252.         tmp1 = znajdzPoNumerze(zmiennoprzecinkowe, tmp2->numerRekordu);
  253.         tmp3 = znajdzPoNumerze(ciagi, tmp2->numerRekordu);
  254.         cout<<"Chce usunac calkowita "<<tmp2->wartosc<<endl;
  255.         cout<<"Chce usunac zmiennoprzecinkowa "<<tmp1->wartosc<<endl;
  256.         cout<<"Chce usunac ciag "<<tmp3->wartosc<<endl;
  257.         usun(calkowite, dousuniecia);
  258.         usun(zmiennoprzecinkowe, tmp1->wartosc);
  259.         usun(ciagi, tmp3->wartosc);
  260.     } else if(a == 1) {
  261.         float dousuniecia;
  262.         cin>>dousuniecia;
  263.         usun(zmiennoprzecinkowe, dousuniecia);
  264.     } else {
  265.         string dousuniecia;
  266.         cin>>dousuniecia;
  267.         usun(ciagi, dousuniecia);
  268.     }
  269. }
  270. void znajdzRekord() {
  271.     int a;
  272.     cin>>a;
  273.     if(a == 0) {
  274.         int wyszukiwana;
  275.         cin>>wyszukiwana;
  276.         cout<<znajdz(calkowite, wyszukiwana);
  277.     } else if(a == 1) {
  278.         float wyszukiwana;
  279.         cin>>wyszukiwana;
  280.         cout<<znajdz(zmiennoprzecinkowe, wyszukiwana);
  281.     } else {
  282.         string wyszukiwana;
  283.         cin>>wyszukiwana;
  284.         cout<<znajdz(ciagi, wyszukiwana);
  285.     }
  286. }
  287. int main() {
  288.     int n;
  289.     cin>>n;
  290.     wyniki = new string[n];
  291.     for(int i=0;i<n;i++) { 
  292.         int m;
  293.         cin>>m;
  294.         calkowita* calkowite = new calkowita;
  295.         zmienno* zmiennoprzecinkowe = new zmienno;
  296.         ciag* ciagi = new ciag;
  297.  
  298.         for(int j=0;j<m;j++) {
  299.             int x;
  300.             cin>>x;
  301.             switch(x) {
  302.                 case 1: wstaw();
  303.                 break;
  304.                 case 2: usunRekord();
  305.                 break;
  306.                 case 3: znajdzRekord();
  307.                 break;
  308.             }
  309.         }  
  310.     }
  311.     /*calkowita* calkowite = new calkowita;
  312.     zmienno* zmiennoprzecinkowe = new zmienno;
  313.     ciag* ciagi = new ciag;
  314.    
  315.     dodaj(calkowite, 5);
  316.     dodaj(calkowite, 8);
  317.    
  318.     calkowita* tmp  = znajdzNumer(calkowite, 1);
  319.     cout<<tmp->wartosc<<endl;
  320.     */
  321.    
  322.     przedzial(calkowite, 1, 100);
  323.     cout<<endl<<endl;
  324.     przedzial(ciagi, "a", "zzzz");
  325.     /*
  326.     calkowita* element = new calkowita;
  327.     element = znajdzNumer(calkowite, 1);
  328.     cout<<"Test: "<<element->wartosc<<endl;
  329.     for(int i=0;i<n;i++) {
  330.         cout<<wyniki[i]<<endl;
  331.     }*/
  332.     /*cout<<endl<<endl;
  333.     string test;
  334.     dupa(ciagi, "a", "z");
  335.     ciag* testowy = new ciag;
  336.     testowy = znajdzNumer(ciagi, 2);
  337.     cout<<testowy->wartosc<<endl;
  338.     test = przedzial(calkowite, 1, 1000);
  339.     cout<<test<<endl;
  340.     */
  341. return 0;
  342. }
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
 
Top