View difference between Paste ID: MKu2c4mL and 3Y61EhAg

-								------------------------------------STOS---------------------------------------------
+								------------------------------------STOS------------------------------------------
 struct stos{ int data; stos* next;};
-#include <iostream>
+
-#include <time.h>
+
     else{return st == nullptr;}}
-using namespace std;
+
 {stos* st_2 = nullptr;
-struct stos
+    *ilosc=0;float suma =0; float sre=0;
-{
+
-    int data;
+    {suma =suma+st->data; (*ilosc)++; push(st_2, st->data); st=st->next;}
-    stos* next;
+
-};
+    {push(st, st_2->data); st_2=st_2->next;}
     float x=static_cast<float>(*ilosc);
     sre=suma/x;return sre;}
 void push (stos* &st, int new_data){
 stos* dodana_wartosc = new stos; dodana_wartosc -> data = new_data;
-    else{
+dodana_wartosc -> next = st; st = dodana_wartosc;}
-    cout << " W stosie cos jednak bylo" << endl;
+void pop(stos* &st){if(st != nullptr){
-    return st == nullptr;
+    stos* temp = st; st = st -> next; delete temp;}
-    }
+    else cout << "Usuwanie nie powiodlo sie, stos jest pusty" << endl; }
-}
+
 if (st == 0) cout << "stos jest pusty" << endl;
-{
+else{ cout << "na gorze stosu jest liczba :" << st -> data << endl;}}
-    stos* st_2 = nullptr;
+
-    *ilosc=0;
+
-    float suma =0;
+struct element {int x; element* nast;};
-    float sre=0;
+struct kolejka {element* poczatek; element* koniec;};
 kolejka stworz_kolejke ()
-    {
+{kolejka nowa_kolejka; nowa_kolejka.poczatek = nullptr;
-        suma =suma+st->data;
+ nowa_kolejka.koniec = nullptr; return nowa_kolejka;}
-        (*ilosc)++;
+
-        push(st_2, st->data);
+{element* nowy = new element; nowy -> x = rd; nowy -> nast = nullptr;
-        st=st->next;
+    if(q.koniec != nullptr) q.koniec -> nast = nowy; q.koniec=nowy;
-    }
+    if(q.poczatek == nullptr) q.poczatek = nowy;}
 void usun_elem_pocz (kolejka &q)
-    {
+{if (q.poczatek == nullptr) return; element* temp = q.poczatek;
-        push(st, st_2->data);
+ q.poczatek = q.poczatek -> nast; delete temp;
-        st_2=st_2->next;
+ if(q.poczatek == nullptr) q.koniec == nullptr;}
-    }
+
  {while (q.poczatek != nullptr)
-    sre=suma/x;
+    {cout << q.poczatek -> x << endl; usun_elem_pocz(q);}}
-    return sre;
+
-}
+
 struct element {int data; element* next;};
-    cout << new_data << endl;
+struct lista {element* head; element* tail; int el_count;};
-stos* dodana_wartosc = new stos;
+lista create_list (){lista new_list; new_list.head = nullptr; new_list.tail = nullptr;
-dodana_wartosc -> data = new_data;
+new_list.el_count = 0; return new_list;}
-dodana_wartosc -> next = st;
+void add_tail(lista &l, int r_d){ element* n_tail = new element; n_tail -> data = r_d; n_tail -> next = nullptr;
-st = dodana_wartosc;
+if(l.tail != nullptr)l.tail -> next = n_tail;
-}
+else l.head = n_tail; l.tail = n_tail; l.el_count ++;}
-void pop(stos* &st){
+
-    if(st != nullptr){
+element* n_head = new element; n_head -> data = r_d; n_head -> next = l.head; l.head = n_head;
-        stos* temp = st;
+if(l.tail == nullptr) l.tail == n_head; l.el_count ++;}
-        st = st -> next;
+
-        delete temp;
+void add_position(lista &l, int r_d, int posit){ if(posit <0 or posit > l.el_count) return; if(posit == 0)
-        cout << "Usuwanie powiodlo sie" << endl;
+    {add_head(l, r_d); return;}
-        }
+if(posit == l.el_count){ add_tail(l, r_d); return;}
-    else
+
-        cout << "Usuwanie nie powiodlo sie, stos jest pusty" << endl;
+for(int i=0; i < posit -1; i++) temp = temp -> next;
-}
+element* n_e = new element; n_e -> data = r_d; n_e -> next = temp -> next;
 temp -> next = n_e; l.el_count ++;}
 void delete_tail(lista &l){ if(l.tail == nullptr) return; element* temp = l.tail;
-if (st == 0)
+if(l.el_count == 1) {l.tail == nullptr; l.head == nullptr;}
-    cout << "stos jest pusty" << endl;
+else{ element * tempor = l.head;
-else{
+for (int i =1; i< l.el_count -1; i++) {tempor = tempor -> next;}
-    cout << "na gorze stosu jest liczba :" << st -> data << endl;
+l.tail = tempor; l.tail -> next = nullptr;}
-}
+l.el_count --; delete temp;}
-}
+void delete_head(lista &l){if(l.tail == nullptr) return; element* temp = l.head; l.head = l.head -> next;
-int main()
+delete temp; if(l.head  == nullptr) l.tail = nullptr; l.el_count--;}
-{
+
-    float sre;
+if (posit < 0 or posit > l.el_count){cout << "Podano niewlasciwa pozycje" << endl;return;}
-    int *ilosc;
+if (posit == 0){delete_head(l);return;}
-    ilosc= new int;
+if(posit == l.el_count){delete_tail(l);return;}
-    int w;
+element* temp = l.head; for (int i =1; i< l.el_count -1; i++) {temp = temp -> next;}
-    stos* st = nullptr;
+element* temp_delete = temp -> next; temp -> next = temp_delete -> next;
-    srand(time(NULL));
+delete temp_delete; l.el_count --;}
-    while (w!=6){
+void delete_list(lista &l){ while(l.head != nullptr) {delete_head(l);}}
-    cout << " 1 - sprawdzenie czy stos jest pusty" << endl;
+void show_list(lista l){element* temp = l.head; while (temp)
-    cout << " 2 - dodanie elementu na stos" << endl;
+    {cout << temp -> data << endl; temp = temp -> next;}}
-    cout << " 3 - usuniecie ze stosu" << endl;
+int parzyste(lista l){int i=0; element* temp = l.head;
-    cout << " 4 - pobranie elementu ze stosu" << endl;
+while (temp){if(temp->data%2==0) i++; temp = temp -> next;} return i;}
-    cout << " 5 - obliczyc srednia elementow" << endl;
+void show_on_position(lista l, int posit){
-    cout << " 6 - wyjscie z programu" << endl;
+int c = 0; if (posit < 0 or posit > l.el_count) {return;}
-    cout << " Co chcesz zrobic?" << endl;
+
-    cin >> w;
+while(l.el_count != 0){c++; if (c == posit) cout << temp -> data << endl; temp = temp -> next; l.el_count --;}}
 ---------------------------------------------LISTA DWUKIERUNKOWA------------------------------------------
-    switch (w)
+
-    {
+struct element {int data; element* next; element* prev; };
-    case 1: is_Empty(st); break;
+struct dlist {element* head; element* tail; int el_count; };
-    case 2: push (st,rand()%20); break;
+dlist create_empty_dlist(){ dlist dl; dl.head = nullptr; dl.tail = nullptr; dl.el_count = 0; return dl;}
-    case 3: pop(st); break;
+element* create_element(int n_d){element* n_e = new element; n_e -> data = n_d;
-    case 4: take_element(st); break;
+n_e -> next = nullptr; n_e -> prev = nullptr; return n_e;}
-    case 5: sre=srednia(st ,ilosc);
+void add_tail(int n_d, dlist &dl){ element* n_e = create_element(n_d);
-            cout<< "wartosc srednia wynosi :" << sre << endl;
+if (dl.el_count == 0) dl.head = n_e; else{ dl.tail -> next = n_e; n_e -> prev = dl.tail;}
-           break;
+dl.tail = n_e; dl.el_count ++;} if (dl.el_count == 0) dl.tail = n_e;
-    case 6:  cout << "juz nic nie mozesz zrobic " << endl; break;
+else{ dl.head -> prev = n_e; n_e -> next = dl.head; } dl.head = n_e; dl.el_count ++;}
-    default: cout << " Bledny wybor" << endl;
+element* find_position(dlist dl, int posit){if (posit < 0 or posit > dl.el_count-1) return nullptr;
-    }
+element* temp = dl.head; for (int i =0; i < posit; i++) temp = temp -> next; return temp;}
-    }
+void add_position(int n_d, dlist &dl, int posit){if (posit < 1 or posit > dl.el_count){return;}
-    return 0;
+if (posit == 1) {add_head(n_d, dl); return;}
-}
+if( posit == dl.el_count) {add_tail(n_d, dl); return;}
 element* temp = dl.head; for(int i=0; i < posit -1; i++) temp = temp -> next;
 element* n_e = new element; n_e -> data = n_d; n_e -> next = temp -> next;
 temp -> next = n_e; dl.el_count ++;}
-#include <iostream>
+void delete_head(dlist &dl){ if (dl.el_count == 0){ return;}
-#include <time.h>
+else{ element* temp = dl.head;
-#include <stdio.h>
+if (dl.el_count == 1) {dl.head = nullptr; dl.tail = nullptr;}
 else {dl.head = dl.head -> next; dl.head -> prev = nullptr;} delete temp; dl.el_count --;}}
-using namespace std;
+
 if (dl.el_count == 0) {return;}
-struct element {
+else{ element* temp = dl.tail; if (dl.el_count == 1) {dl.tail = nullptr; dl.head = nullptr;}
-int x;
+else{ dl.tail = dl.tail -> prev; dl.tail -> next = nullptr;} delete temp;
-element* nast;
+dl.el_count --;}}
-};
+void delete_position(dlist &dl, int posit){ if (posit < 1 or posit > dl.el_count){ return;}
-struct kolejka {
+if (posit == 1) {delete_head(dl); return;}
-element* poczatek;
+if(posit == dl.el_count){delete_tail(dl); return;}
-element* koniec;
+element* temp = dl.head; for (int i =1; i< posit -1; i++) {temp = temp -> next;}
-};
+element* temp_delete = temp -> next; temp -> next = temp_delete -> next;
 delete temp_delete; dl.el_count --;}
-{
+void show_list(dlist dl){ element* temp = dl.head;
-    kolejka nowa_kolejka;
+while (temp) {cout << temp -> data << endl; temp = temp -> next;}}
-    nowa_kolejka.poczatek = nullptr;
+void delete_list(dlist &dl){ while(dl.head != nullptr){delete_head(dl);}}
-    nowa_kolejka.koniec = nullptr;
+
-    return nowa_kolejka;
+
-}
+{ int x; element* lewy; element* prawy; element* gora;};
 struct drzewo {element* r;};
-{
+
-    cout << rd << endl;
+{ drzewo nowe_drzewo; nowe_drzewo.r = nullptr; return nowe_drzewo;}
-    element* nowy = new element;
+
-    nowy -> x = rd;
+{element *p; element *nowy_element = new element; nowy_element -> gora = nullptr;
-    nowy -> nast = nullptr;
+ nowy_element -> lewy = nullptr; nowy_element -> prawy = nullptr; nowy_element -> x = rd;
-    if(q.koniec != nullptr) q.koniec -> nast = nowy;
+ p = root.r; if(!p) root.r = nowy_element;
-    q.koniec=nowy;
+ else{while (1){if (rd < p -> x){ if (!p -> lewy){p -> lewy = nowy_element; break;}
-    if(q.poczatek == nullptr) q.poczatek = nowy;
+   else p = p -> lewy;} else { if (!p -> prawy){ p -> prawy = nowy_element;break;}
-}
+     else p = p -> prawy;}} nowy_element -> gora = p;}}
 int wys_drzewo(element *root)
-{
+{if(root==nullptr) return 0; wys_drzewo(root->lewy);
-    if (q.poczatek == nullptr) return;
+    cout<< root->x <<" "; wys_drzewo(root->prawy);}
-    element* temp = q.poczatek;
+
-    q.poczatek = q.poczatek -> nast;
+{if(root==nullptr) return false; if(root->x==szukana) return true;
-    delete temp;
+else{if (root->x < szukana) czy_istnieje(root->prawy, szukana);
-    if(q.poczatek == nullptr) q.koniec == nullptr;
+        else czy_istnieje(root->lewy, szukana);}}
-}
+---------------------------SORTOWANIE PRZEZ WYBIERANIE-----------------------------
 int find_max_el(int *arr, int n){int maxel = arr[0]; int imax = 0;
- {
+for (int i =0; i<n; i++) if(arr[i] > maxel){ maxel= arr[i]; imax = i;} return imax;}
-    while (q.poczatek != nullptr)
+void selectionsort(int *arr, int n){ int max_in; for(int i = n; i>1; i--){
-    {
+max_in=find_max_el(arr, i); swap(arr[i-1], arr[max_in]);}}
-        cout << q.poczatek -> x << endl;
+-----------------BĄBELKOWE-------------------
-        usun_elem_pocz(q);
+void bublesort(int *arr, int n){ for(int i = n-1; i>0; i-- ){ for( int j = 0; j<i; j++){
-    }
+ if(arr[j]>arr[j+1]) swap(arr[j], arr[j+1]);}}}
- }
+-----------------SORTOWANIE PRZEZ WSTAWIANIE--------------
 void insertionsort(int *arr, int n){ int temp, j; for(int i=n-2; i>=0; i--){ j = i; temp = arr[j];
-int main()
+while(temp > arr[j+1] and j < n-1){ arr[j] = arr[j+1]; j++;} arr[j] = temp;}}
-{
+---------------FLAGA POLSKA----------------
-    kolejka q;
+int flagapolska(struct student x[], short n){ int p=0, k=n-1; int ind;
-    int wybor;
+ while(p<k) {while(p<n-1 && x[p].ocena>=10) p++; while(k>=0 && x[k].ocena < 10) k--;
-    srand(time(NULL));
+ if(p<k){ swap(x[p],x[k]); ind = k;}
-    do
+ if(x[p].ocena > 10) ind=p; else ind=p-1;} return k;}
-        {
+void wys (struct student* x, int p, int k)
-            cout << "co zrobic?" << endl;
+{for(int i=p; i<k; i++){ cout << "imie: " << x[i].imie << " ocena = " << x[i].ocena << endl;}}
-            cout << "1. Stworz nowa, pusta kolejke" << endl;
+------------FLAGA FFRANCUSKA---------------
-            cout << "2. Dodaj losowy element do kolejki" << endl;
+int flagafrancuska(struct student x[], short n, int* ko){int p=-1,s=0 ,k=n;
-            cout << "3. Usuna element z kolejki" << endl;
+ while(s<k){if(x[s].ocena%3 == 0){p++; swap(x[p], x[s]); s++;}
-            cout << "4. wyswietl i usun cala kolejke" << endl;
+ else{ if(x[s].ocena%3==2){ k--; swap(x[k], x[s]);} else s++;}}
-            cout << "5. Wyjscie" << endl;
+*ko=k; return p;}
-            cin >> wybor;
+------------WYSZUKIWANIE LINIOWE------------
-            switch(wybor){
+int linsearch(int *arr, int n, int klucz){ for(int i=0; i<n; i++){ if(arr[i]==klucz)
-            case 1: q=stworz_kolejke(); break;
+return i;} return -1;}
-            case 2: dodaj_element (q, rand()); break;
+---------BISEKCJA Z PĘTLA---------------
-            case 3: usun_elem_pocz (q); break;
+int bis_p(int *arr, int n, int klucz){ int l=0; int p=n-1; int s;
-            case 4: wyswietl_kolejke(q); break;
+while(p>=l){ s=(l+p)/2; if(klucz>arr[s]) l=s+1; else{ p=s-1;} if(arr[s]==klucz){ return s;}}return -1;}
-            case 5: break;
+------------BISEKCJA REKURENCYJNA--------------
-            default : cout << "bledny wybor" << endl; break;
+int bis_rek(int *arr, int a, int b, int klucz){ int srodek=(a+b)/2;
-}
+if(b>a){ if(arr[srodek] != klucz){ if(klucz < arr[srodek])
-        }
+return bis_rek(arr, a, srodek-1, klucz); else{ return bis_rek(arr, srodek+1, b, klucz);}}
-    while (wybor != 5);
+else{ return srodek;}} else { return -1; }}
-    return 0;
+---------------KMP-----------------
-}
+int KMP (int n, int m, int *ind, string tekst, string wzorzec)
 {int *tab; tab = new int[m]; tab[0]=0; tab[1]=0; int t=0; int x=0;
 for(int i=2; i<=m; i++){ while(t>0 and wzorzec[t]!=wzorzec[i-1]) t=tab[t];
 if(wzorzec[t]==wzorzec[i-1])t++; tab[i]=t;}
 int i=1; int j=0; while(i<=n-m+1){ while(wzorzec[j]==tekst[i+j-1] and j<m) j++;
-#include <iostream>
+if(j==m){ ind[x]=i-1; x++; j=m;} i=i+max(1,j-tab[j]); j=tab[j];} return x;}
-#include <time.h>
+---------NAIWNY---------------
-#include <stdio.h>
+int naiwny(int n, int m, string tekst, string wzorzec, int *tab)
 {int x=-1, j=0; for(int i = 0; i < n-1; i++){
-using namespace std;
+ if (wzorzec == tekst.substr(i,m)){tab[j]=i; j++;}} return j;}