kopiec kopiec kopiec kopiec kopiec kopiec

projekt 1/main.cpp

@@ -121,6 +121,95 @@ void eksperyment(void(*funkcja_sortujaca)(int*, int), const std::string& nazwa,
     output.flush();
 }
 
+void wypelnij_posortowane_dane_wejsciowe(int* tablica, int rozmiar, int min = 0, int max = std::numeric_limits<int>::max())
+{
+    for (int i = 0; i < rozmiar; ++i)
+        tablica[i] = i;
+}
+
+/*
+    
+    parametry:
+     - funkcja_sortujaca - wskanik na funkcjącą sortowanie, musi przyjmować dwa parametry: adres początku tablicy (int*) oraz jej rozmiar (int)
+     - nazwa - nazwa testowanej funkcji, tylko w celach wypisania
+     - output - strumien do ktorego beda zapisane wyniki, domyslnie std::cerr, przy ostatnim uruchomieniu warto nadpisac otwartym strumieniem plikowym, aby sobie zebrac wyniki do pliku
+     - dodatkowe_miejsce - liczba dodatkowych elementow tablicy zaalokowanych PRZED poczatkiem tablicy, przykladowo gdy =1, pierwszym indeksem tablicy jest -1, ale dane rozpoczynaja sie od indeksu 0, moze sie przydac do sortowania przez wstawianie z wartownikiem
+*/
+void eksperyment_posortowane_dane_wejsciowe(void(*funkcja_sortujaca)(int*, int), const std::string& nazwa, std::ostream& output = std::cerr, int dodatkowe_miejsce = 0)
+{
+    //ustawienia
+    const double limit_czasu = 5.0; //sekund
+    const int powtorzen = 3;
+    const int rozmiar_poczatkowy = 1 << 10;
+    /////////////////////////////////////////
+    const int szerokosc = 100;
+    int gwiazdek = szerokosc - nazwa.length() - 2;
+    if (gwiazdek < 0)
+        gwiazdek = 0;
+    int i = 0;
+    output << " ";
+    for (; i < gwiazdek / 2; ++i)
+        output << '*';
+    output << " " << nazwa << " ";
+    for (; i < gwiazdek; ++i)
+        output << '*';
+    output << "\n\n";
+    output.flush();
+
+    output << std::setw(9) << "N";
+    output << std::setw(1) << "";
+    for (int nr = 0; nr < powtorzen; ++nr)
+        output << std::setw(9) << nr + 1 << " ";
+    output << std::setw(12) << "średna" << " ";
+    output << "\n";
+    for (int rozmiar = rozmiar_poczatkowy; ; rozmiar *= 2)
+    {
+        output << std::setw(9) << rozmiar << ": ";
+        output.flush();
+        int* pamiec = new int[dodatkowe_miejsce + rozmiar];
+        int* tablica = pamiec + dodatkowe_miejsce;
+        double czas = 0.0;
+
+        int* pattern = new int[rozmiar];
+
+
+        for (int nr = 0; nr < powtorzen; ++nr)
+        {
+            wypelnij(tablica, rozmiar);
+            for (int i = 0; i < rozmiar; ++i)
+                pattern[i] = tablica[i];
+            std::sort(pattern, pattern + rozmiar);
+            double c = mierz_czas(tablica, rozmiar, funkcja_sortujaca);
+            if (!jest_posortowane(tablica, rozmiar))
+            {
+                output << "Tablica nieposortowana!!\n";
+                if (&output != &std::cerr)
+                    std::cerr << "Tablica nieposortowana!!\n";
+                return;
+            }
+            if (!std::equal(pattern, pattern + rozmiar, tablica, tablica + rozmiar))
+            {
+                output << "Tablica zawiera inne wartosci niz powinna!!\n";
+                if (&output != &std::cerr)
+                    std::cerr << "Tablica zawiera inne wartosci niz powinna!!\n";
+                return;
+            }
+            czas += c;
+            output.precision(6);
+            output << std::fixed << c << "  ";
+            output.flush();
+        }
+        czas /= powtorzen;
+        output << std::setw(12) << std::fixed << czas << "\n";
+        output.flush();
+        delete[] pamiec;
+        delete[] pattern;
+        if (czas > limit_czasu || rozmiar >= 67108864)
+             break;
+    }
+    output << "\n";
+    output.flush();
+}
 
 void sortowanie_wybieranie(int* tablica, int rozmiar){
     for (int i = 0;  i < rozmiar - 1; i++) {
@@ -222,6 +311,44 @@ void qs(int* tab, int d, int g){
 	}
 }
 
+void kopiec_w_dol(int* tablica, int i, int rozmiar_kopca){
+    int lewy = ((i+1) * 2)-1;
+    int prawy = (i+1) * 2 ;
+    int największe;
+    if (lewy < rozmiar_kopca && tablica[lewy] > tablica[i]) {
+        największe=lewy;
+    } else {
+        największe=i;
+    }
+    if (prawy < rozmiar_kopca && tablica[prawy] > tablica[największe]){
+        największe=prawy;
+    }
+    if (największe !=i){
+        swap(tablica[i], tablica[największe]);
+        kopiec_w_dol(tablica,największe,rozmiar_kopca);
+    }
+}
+
+void buduj_kopiec(int* tablica, int rozmiar){
+int rozmiar_kopca = rozmiar;
+for (int i = rozmiar/2; i >= 0; i--) {
+  kopiec_w_dol(tablica, i, rozmiar_kopca);
+}
+}
+
+void sortowanie_kopcowanie(int* tablica, int rozmiar){
+ int rozmiar_kopca = rozmiar;
+    buduj_kopiec(tablica, rozmiar);
+ for (int i = rozmiar-1; i >= 1; i--) {
+   swap(tablica[0], tablica[i]);
+   rozmiar_kopca--;
+   kopiec_w_dol(tablica,0, rozmiar_kopca);
+ }
+}
+
+void sortowanie_std(int* tablica, int rozmiar){
+    std::sort(tablica, tablica+ rozmiar);
+}
 
 void sortowanie_szybkie(int* tablica, int rozmiar){
     qs(tablica, 0, rozmiar-1);
@@ -261,11 +388,13 @@ int main()
     std::ostream& output = std::cerr; // Wypisanie na ekran
     //eksperyment(sortowanie_shella, "Sortowanie shella", output);
     //eksperyment(sortowanie_szybkie, "Sortowanie szybkie", output);
-    eksperyment(sortowanie_szybkie_mod, "Sortowanie szybkie z modyfikacją", output);
+    //eksperyment(sortowanie_szybkie_mod, "Sortowanie szybkie z modyfikacją", output);
     // eksperyment(ulepszone_sortowanie_babelkowe, "Ulepszone sortowanie bąbelkowe", output);
     // eksperyment(sortowanie_babelkowe, "Sortowanie bąbelkowe", output);
     // eksperyment(sortowanie_wstawianie, "Sortowanie przez proste wstawianie", output);
     // eksperyment(sortowanie_wybieranie, "Sortowanie przez proste wybieranie", output);
 
+    eksperyment(sortowanie_kopcowanie, "Sortowanie przez kopcowanie", output);
+    eksperyment(sortowanie_std, "Sortowanie std::sort", output);
    return 0;
 }