daily pastebin goal
3%
SHARE
TWEET

Untitled

a guest Aug 10th, 2018 62 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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. /*template <class par1, class par2>
  93. par1 znajdzNumer(par1 wezel, par2 numer) {
  94.     if(wezel->lewy_syn != NULL) return znajdzNumer(wezel->lewy_syn, numer);
  95.     if(wezel->wartosc == numer) {
  96.         return wezel;
  97.     }
  98.     if(wezel->prawy_syn != NULL) return znajdzNumer(wezel->prawy_syn, numer);
  99. }*/
  100.  
  101.  
  102. void dodaj(calkowita* &wezel, int wartosc) {
  103.     if(wezel == NULL) {
  104.         wezel = new calkowita;
  105.         wezel->wartosc = wartosc;
  106.         wezel->lewy_syn = NULL;
  107.         wezel->prawy_syn = NULL;
  108.         licznikcalkowita++;
  109.         wezel->numerRekordu = licznikcalkowita;
  110.         return;
  111.     } else if(wezel->wartosc == wartosc) {
  112.         return;
  113.     } else if(wartosc < wezel->wartosc) {
  114.         dodaj(wezel->lewy_syn, wartosc);
  115.     } else {
  116.         dodaj(wezel->prawy_syn, wartosc);
  117.     }
  118. }
  119.  
  120. void dodaj(zmienno* &wezel, float wartosc) {
  121.     if(wezel == NULL) {
  122.         wezel = new zmienno;
  123.         wezel->wartosc = wartosc;
  124.         wezel->lewy_syn = NULL;
  125.         wezel->prawy_syn = NULL;
  126.         licznikzmienno++;
  127.         wezel->numerRekordu = licznikzmienno;
  128.         return;
  129.     } else if(wezel->wartosc == wartosc) {
  130.         return;
  131.     } else if(wartosc < wezel->wartosc) {
  132.         dodaj(wezel->lewy_syn, wartosc);
  133.     } else {
  134.         dodaj(wezel->prawy_syn, wartosc);
  135.     }
  136. }
  137.  
  138. void dodaj(ciag* &wezel, string wartosc) {
  139.     if(wezel == NULL) {
  140.         wezel = new ciag;
  141.         wezel->wartosc = wartosc;
  142.         wezel->lewy_syn = NULL;
  143.         wezel->prawy_syn = NULL;
  144.         licznikciag++;
  145.         wezel->numerRekordu = licznikciag;
  146.         return;
  147.     } else if(wezel->wartosc.compare(wartosc) == 0) {
  148.         return;
  149.     } else if(wezel->wartosc.compare(wartosc) > 0) {
  150.         dodaj(wezel->lewy_syn, wartosc);
  151.     } else {
  152.         dodaj(wezel->prawy_syn, wartosc);
  153.     }
  154. }
  155.  
  156. template <class par1, class par2>
  157. bool usun(par1* &wezel, par2 wartosc) { // false - nie ma takiego klucza; true - usunięto
  158.     if(wezel == NULL) {
  159.         return false;
  160.     } else if(wezel->wartosc == wartosc) {
  161.         if(wezel->lewy_syn == NULL && wezel->prawy_syn == NULL) { // węzeł jest liściem
  162.             delete wezel;
  163.         } else if(wezel->lewy_syn != NULL && wezel->prawy_syn == NULL) { // węzeł ma tylko lewego syna
  164.             wezel = wezel->lewy_syn;
  165.             delete wezel->lewy_syn;
  166.         } else if(wezel->prawy_syn != NULL && wezel->lewy_syn == NULL) { // węzeł ma tylko prawego syna
  167.             wezel = wezel->prawy_syn;
  168.             delete wezel->prawy_syn;
  169.         } else { // węzeł ma dwóch synów
  170.             par1 *poprzednik = new par1;
  171.             poprzednik = wezel->lewy_syn;
  172.             while(poprzednik->prawy_syn!=NULL) {
  173.                 poprzednik = poprzednik->prawy_syn;
  174.             }
  175.             wezel->wartosc = poprzednik->wartosc;
  176.             usun(poprzednik, poprzednik->wartosc);
  177.         }
  178.     } else if(wartosc < wezel->wartosc) {
  179.         return usun(wezel->lewy_syn, wartosc);
  180.     } else {
  181.         return usun(wezel->prawy_syn, wartosc);
  182.     }
  183. }
  184.  
  185. string przedzial(ciag* wezel, string poczatek, string koniec) { // in order
  186.     ostringstream tmp;
  187.  
  188.     if(wezel->lewy_syn != NULL) tmp << przedzial(wezel->lewy_syn, poczatek, koniec);
  189.     if(wezel->wartosc >= poczatek && wezel->wartosc <= koniec) {
  190.         zmienno* tmp1;
  191.         calkowita* tmp2;
  192.         tmp1 = znajdzPoNumerze(zmiennoprzecinkowe, wezel->numerRekordu);
  193.         tmp2 = znajdzPoNumerze(calkowite, wezel->numerRekordu);
  194.  
  195.         tmp<<tmp2->wartosc<<endl;
  196.         tmp<<tmp1->wartosc<<endl;
  197.         tmp<<wezel->wartosc<<endl;
  198.     }
  199.     if(wezel->prawy_syn != NULL) tmp << przedzial(wezel->prawy_syn, poczatek, koniec);
  200.     return tmp.str();
  201. }
  202.  
  203. void przedzial(calkowita* wezel, int poczatek, int koniec) { // in order
  204.     ostringstream tmp;
  205.     if(wezel->lewy_syn != NULL)  przedzial(wezel->lewy_syn, poczatek, koniec);
  206.     if(wezel->wartosc >= poczatek && wezel->wartosc <= koniec) {
  207.         zmienno* tmp1;
  208.         calkowita* tmp2;
  209.         ciag* tmp3;
  210.         tmp1 = znajdzPoNumerze(zmiennoprzecinkowe, wezel->numerRekordu);
  211.         tmp2 = znajdzPoNumerze(calkowite, wezel->numerRekordu);
  212.         tmp3 = znajdzPoNumerze(ciagi, wezel->numerRekordu);
  213.         if(tmp3 == NULL) cout<<wezel->numerRekordu<<" JEST NULLEM"<<endl;
  214.         cout<<tmp3->wartosc<<endl;
  215.         cout<<tmp2->wartosc<<endl;
  216.         cout<<tmp1->wartosc<<endl;
  217.         delete tmp1;
  218.         delete tmp2;
  219.         delete tmp3;
  220.  
  221.     }
  222.     if(wezel->prawy_syn != NULL)  przedzial(wezel->prawy_syn, poczatek, koniec);
  223.     //return tmp.str();
  224. }
  225.  
  226. template <class par1, class par2, class par3>
  227. void dupa(par1 wezel, par2 poczatek, par3 koniec) {
  228.     ciag* tmp3 = new ciag;
  229.     ostringstream tmp;
  230.     if(wezel->lewy_syn != NULL) dupa(wezel->lewy_syn, poczatek, koniec);
  231.     if(wezel->wartosc >= poczatek && wezel->wartosc <= koniec) {
  232.         cout<<wezel->wartosc<<" "<<wezel->numerRekordu<<endl;
  233.     }
  234.     if(wezel->prawy_syn != NULL) dupa(wezel->prawy_syn, poczatek, koniec);
  235. }
  236.  
  237. void wstaw() {
  238.     int a;
  239.     float b;
  240.     string c;
  241.     cin>>a>>b>>c;
  242.     dodaj(calkowite, a);
  243.     dodaj(zmiennoprzecinkowe, b);
  244.     dodaj(ciagi, c);
  245. }
  246. void usunRekord() {
  247.     int a;
  248.     cin>>a;
  249.     if(a == 0) {
  250.         int dousuniecia;
  251.         cin>>dousuniecia;
  252.         zmienno* tmp1;
  253.         calkowita* tmp2;
  254.         ciag* tmp3;
  255.         tmp2 = znajdzPoKluczu(calkowite, dousuniecia);
  256.         tmp1 = znajdzPoNumerze(zmiennoprzecinkowe, tmp2->numerRekordu);
  257.         tmp3 = znajdzPoNumerze(ciagi, tmp2->numerRekordu);
  258.         cout<<"Chce usunac calkowita "<<tmp2->wartosc<<endl;
  259.         cout<<"Chce usunac zmiennoprzecinkowa "<<tmp1->wartosc<<endl;
  260.         cout<<"Chce usunac ciag "<<tmp3->wartosc<<endl;
  261.         usun(calkowite, dousuniecia);
  262.         usun(zmiennoprzecinkowe, tmp1->wartosc);
  263.         usun(ciagi, tmp3->wartosc);
  264.     } else if(a == 1) {
  265.         float dousuniecia;
  266.         cin>>dousuniecia;
  267.         usun(zmiennoprzecinkowe, dousuniecia);
  268.     } else {
  269.         string dousuniecia;
  270.         cin>>dousuniecia;
  271.         usun(ciagi, dousuniecia);
  272.     }
  273. }
  274. void znajdzRekord() {
  275.     int a;
  276.     cin>>a;
  277.     if(a == 0) {
  278.         int wyszukiwana;
  279.         cin>>wyszukiwana;
  280.         cout<<znajdz(calkowite, wyszukiwana);
  281.     } else if(a == 1) {
  282.         float wyszukiwana;
  283.         cin>>wyszukiwana;
  284.         cout<<znajdz(zmiennoprzecinkowe, wyszukiwana);
  285.     } else {
  286.         string wyszukiwana;
  287.         cin>>wyszukiwana;
  288.         cout<<znajdz(ciagi, wyszukiwana);
  289.     }
  290. }
  291. int main() {
  292.     int n;
  293.     cin>>n;
  294.     wyniki = new string[n];
  295.     for(int i=0;i<n;i++) { 
  296.         int m;
  297.         cin>>m;
  298.         calkowita* calkowite = new calkowita;
  299.         zmienno* zmiennoprzecinkowe = new zmienno;
  300.         ciag* ciagi = new ciag;
  301.  
  302.         for(int j=0;j<m;j++) {
  303.             int x;
  304.             cin>>x;
  305.             switch(x) {
  306.                 case 1: wstaw();
  307.                 break;
  308.                 case 2: usunRekord();
  309.                 break;
  310.                 case 3: znajdzRekord();
  311.                 break;
  312.             }
  313.         }  
  314.     }
  315.     /*calkowita* calkowite = new calkowita;
  316.     zmienno* zmiennoprzecinkowe = new zmienno;
  317.     ciag* ciagi = new ciag;
  318.    
  319.     dodaj(calkowite, 5);
  320.     dodaj(calkowite, 8);
  321.    
  322.     calkowita* tmp  = znajdzNumer(calkowite, 1);
  323.     cout<<tmp->wartosc<<endl;
  324.     */
  325.    
  326.     cout<<przedzial(calkowite, 1, 100)<<endl<<endl<<endl;
  327.    
  328.     cout<<przedzial(ciagi, "a", "zzzz")<<endl;
  329.     /*
  330.     calkowita* element = new calkowita;
  331.     element = znajdzNumer(calkowite, 1);
  332.     cout<<"Test: "<<element->wartosc<<endl;
  333.     for(int i=0;i<n;i++) {
  334.         cout<<wyniki[i]<<endl;
  335.     }*/
  336.     /*cout<<endl<<endl;
  337.     string test;
  338.     dupa(ciagi, "a", "z");
  339.     ciag* testowy = new ciag;
  340.     testowy = znajdzNumer(ciagi, 2);
  341.     cout<<testowy->wartosc<<endl;
  342.     test = przedzial(calkowite, 1, 1000);
  343.     cout<<test<<endl;
  344.     */
  345. return 0;
  346. }
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