Forum Pasja Informatyki - Najnowsze z tagiem quicksort

sortowanie quicksort i mergesort

Tue, 15 Nov 2022 20:53:02 +0000

Witam, mam do wykonania takie zadanie "Napisz program, który losuje 2 tablice n-elementowe , sortuje je dowolną metodą, która wykorzystuje metodę „quicksort", a następnie tworzy trzecią tablicę n-elementową,
składającą się z uporządkowanych n najmniejszych liczb z dwóch pierwszych tablic". Mianowicie mam napisana taka część kodu, ze wyświetla tylko jedna tablice posortowana, a reszty już nie. Macie pomysł jak to uzupełnić?

#include <iostream>
#include <stdlib.h>
#include <time.h>
using namespace std;
const int N=20;

void Losuj (int A[]) 
{
for (int i=0;i<N;i++)
A[i]=1+rand () % 99;
}

void Wypisz (int A[]) 
{
for (int i=0;i<N;i++)
{
    cout <<A[i] <<" ";
} 
{ 
    cout<<endl;
}}
void Merge(int A[], int p, int s, int k)
{
int i=p, j=s+1, m=p;
int B[N];
while (i<=s && j<=k)
{
if (A[i]<A[j])
{
B[m]=A[i]; i++;
}
else
{
B[m]=A[j]; j++;
}
m++;
}
while (i<=s)
{
B[m]=A[i]; i++;m++;
}
while (j<=k)
{
B[m]=A[j]; j++;m++;
}
for (i=p;i<=k; i++) A[i]=B[i];
}
void MergeSort(int A[], int p, int k)
{
if (p<k)
{
int s=(p+k)/2;
MergeSort(A,p,s);
MergeSort(A,s+1,k);
Merge(A,p,s,k);
}

}

void Quicksort (int A[], int p, int k)
{
int i=p, j=k, m =A[(p+k)/2];
while (i<=j)
{
while (A[i] <m) i++;
while (A[j]>m) j--;
if (i<=j)
{
swap (A[i],A[j]);
i++;j--;
}
}
if (p<j) Quicksort (A, p, j);
if (i<k) Quicksort (A, i, k);
}

int main()
{
int A[N]; 
srand (time (NULL));
Losuj (A);
Wypisz (A);
MergeSort(A,0,N-1);
Merge(A,0,N-1,0);
Quicksort(A,0,N-1);
Wypisz (A);
return 0;
}

piwot ustawiony na pierwszy element

Sun, 26 Dec 2021 16:58:54 +0000

W quicksort, jeśli chcę ustawić piwot na pierwszy element w jakiejś tablicy np. 15,12,13,11,20,15,22,14 to jest to 15.

i teraz gdy rozbijam na dwa podproblemy (ustawiam i na pierwszy element i j na ostatni element tablicy i sprawdzam większość oraz mniejszość i ewentualnie zamieniam elementy). W ten sposób dostałem dwa podproblemy:

14 12 13 11 15(piwot) 15 22 20

i tutaj znowu dzieliłbym na dwa kolejne podproblemy i w efekcie dostałbym uporządkowaną tablicę.

Pytanie, dlaczego powinno być

13 12 14 11 15 20 15 22, bo taka jest poprawna odpowiedź.

Mógłby mi ktoś wytłumaczyć, jak posortować tablicę gdy ustawiamy ten piwot na pierwszy element np. na przykładzie tej tablicy?

Quicksort w konsoli C++

Mon, 26 Jul 2021 17:32:45 +0000

Witam,

po wielu trudach zrozumiałem działanie algorytmu sortowania szybkiego, jednak nie potrafię dostrzec błędu w moim kodzie:

#include <iostream>
#include <time.h>

using namespace std;

void quicksort(int *tablica, int poczatek, int koniec) {
	int pivot = tablica[(poczatek - koniec) / 2];
	int i, j, x;
	i = poczatek;
	j = koniec;
	do {
		while (tablica[i] < pivot) i++;
		while (tablica[j] > pivot)  j--;
		if (i <= j) {
			x = tablica[i];
			tablica[i] = tablica[j];
			tablica[j] = x;
		}
		} while (i <= j);
		if (j > poczatek) quicksort(tablica, poczatek, j);
		if (i < koniec) quicksort(tablica, i, koniec);
	}

int main() {
	srand(time(NULL));
	int ile;
	cout << "Ile liczb:";
	cin >> ile;
	int* tablica = new int[ile];
	cout << "\n Przed sortowaniem: ";
	for (int i(0); i < ile; i++) {
		tablica[i] = rand() % 100;
		cout << endl << tablica[i];
	}
	quicksort(tablica, 0, ile - 1);
	cout << endl << "Po sortowaniu:";
	for (int i(0); i < ile; i++) {
	
		cout << endl << tablica[i];
	}
	return 0;
}

Konsola wypisuje liczby z pierwszego for'a, następnie program zawiesza się. Wiele wskazuje na to, że dzieje się to w linijce wywołującej funkcję quicksort().

Zadanie - Algorytm QuickSort

Wed, 06 Jan 2021 13:49:29 +0000

Witajcie,

Prosiłbym o pomoc, gdyż męczę się już z tym kupę czasu i nie mogę dojść do winy problemu. Zadanie polega na implementacji algorytmu QuickSort, który zwróci nam posortowaną tablicę, nie zmieniając nic w tabeli wejściowej. Mógłby ktoś spojrzeć i powiedzieć mi gdzie popełniłem błąd? Algorytm w tym przypadku sortuje prawidłowo do pewnego momentu, lecz z niewiadomych mi przyczyn nie przerywa w tym momencie i próbuje jeszcze kilkukrotnie dalej sortować dając na wyjściu zły wynik. O dziwo problem nie występuje, gdy nie próbuję zrobić wewnątrz funkcji kopii listy i operuję na oryginalnej tablicy.

Z góry bardzo dziękuję :)

from typing import List
Y = [2, 25, 9, 14, 1, 3, 10]  #tablica do posortowania

def quicksort(I: List[int], start: int, stop: int) -> List[int]:
    copy_I = I[:]  #kopia listy na której będę operował
    i = start
    j = stop
    pivot = copy_I[(start + stop) // 2]

    while i <= j:
        while copy_I[i] < pivot:
            i += 1
        while copy_I[j] > pivot:
            j -= 1
        if i <= j:
            copy_I[i], copy_I[j] = copy_I[j], copy_I[i]
            i += 1
            j -= 1

    if start < j:
        quicksort(copy_I, start, j)
    if i < stop:
        quicksort(copy_I, i, stop)
    return copy_I

print(quicksort(Y,0,len(Y)-1))

sortowanie c++ quick sort

Thu, 22 Oct 2020 18:19:19 +0000

Cześć uczę się ostatnio algorytmów sortowania i napisałem quick sorta chciałbym się dowiedzieć czy algorytm działa poprawnie a jeśli tak czy da się go w jakiś sposób udoskonalić oto kod:

#include <iostream>
#include <fstream>
#include <vector>

using namespace std;

int rozdzielanie(int *tab, int l, int r) {

    int q = r - 1;

    while (l != q) {
        if (tab[l] > tab[r]) {
            while (tab[q] > tab[r] && q > l) q--;
            if (q > l) swap(tab[l],tab[q]);
        }
        if (q > l) l++;
    }
    if (tab[l] > tab[r]) {
        swap(tab[l],tab[r]);
        return l;
    }
    return l+1;
}

void sortowanie_szybkie(int *tab, int l, int r) {

    if (l < r) {
        int q = rozdzielanie(tab,l,r);
        sortowanie_szybkie(tab,l,q-1);
        sortowanie_szybkie(tab,q+1,r);
    }
}

int main()
{
    int n,l = 0;

    cin >> n;

    int *tab = new int[n];

    for (int i = 0; i < n; i++) cin >> tab[i];
    sortowanie_szybkie(tab,l,n-1);
    for (int i = 0; i < n; i++) cout << tab[i] << "\n";
    cout << "\n";

    return 0;
}

implementacja quicksort.

Sat, 27 Jun 2020 12:12:46 +0000

Witam!

Chciałbym dowiedzieć się jaki problem występuje w tym kodzie. W build log nie ma żadnych błędów.Chodzi o to, że po wypisaniu tablicy nie uporządkowanej konsola się zamyka.

#include <iostream>
#include <time.h>
#include <windows.h>
using namespace std;

void sortowanie(int *tab, int lewy, int prawy)
{
    int S = tab[(lewy+prawy)/2];
    int bufor;
    int l=lewy;
    int p=prawy;

    do
    {
        while(tab[l]<S)
            l++;
        while(tab[p]>S)
            p++;

        if(l<=p)
        {
            bufor=tab[l];
            tab[l]=tab[p];
            tab[p]=bufor;
            l++;
            p--;
        }
    }
    while(l<=p);

    if(p>lewy)
        sortowanie(tab,lewy, p);
    if(l<prawy)
        sortowanie(tab, l, prawy);
}


int main()
{
    srand(time(0));

    int ile;
    cout<<"ile liczb: ";
    cin>>ile;

    int* tab;
    tab= new int[ile];

    for(int i=0; i<=ile-1; i++)
    {
        tab[i]=rand()%100+1;
    }

    for(int i=0; i<=ile-1; i++)
    {
        cout<<tab[i]<<" ";
    }

    sortowanie(tab, 0, ile-1);

    for(int i=0; i<=ile-1; i++)
    {
        cout<<tab[i]<<" ";
    }

    delete [] tab;
    return 0;
}

Algorytm quicksort

Thu, 23 Apr 2020 12:20:13 +0000

Mam pewne pytanie.

Znalazłem w internecie taki schemat sortowania przez scalanie. Otóż zastanawiam się czy quicksort wykorzystuje scalanie dwóch ciągów uporządkowanych. W quicksort występuje "dzielenie" problemu na mniejsze. Ale czy quicksort wykorzystuje scalanie posortowanych ciągów?

Sortowanie- Bubble, Quick, Insertion- porówanie czasów

Thu, 02 Apr 2020 09:32:07 +0000

Witam, porównuję czasy sortowania poszczególnych algorytmów i z tego co się orientuję to QuickSort powinno być najszybsze .. natomiast u mnie najlepiej wypada Insertion Sort. Może mam coś nie tak z algorytmem Quick?

import java.util.Random;

public class Main {

    public static void main(String[] args) {
        Random random = new Random();
        int[] arrayToSort = new int[10000];
        int[] unsortedArray;
        for (int i = 0; i < 10000; i++) {
            arrayToSort[i] = random.nextInt(10000);
            System.out.print(arrayToSort[i] + ", ");
        }
        unsortedArray = arrayToSort;
        System.out.println(" ");
        System.out.println("---------------");
        long timeBeforeBubbleSort = System.nanoTime();
        arrayBubbleSort(arrayToSort);
        long timeAfterBubbleSort = System.nanoTime();
        System.out.println("Bubble sort: ");
        for (int sort : arrayToSort) {
            System.out.print(sort + ", ");
        }
        System.out.println(" ");
        System.out.println("Czas sortowania bąbelkowego: " + calculateTimeOfSorting(timeBeforeBubbleSort, timeAfterBubbleSort)
        );
        arrayToSort = unsortedArray;
        System.out.println("---------------");
        long timeBeforeInsertionSort = System.nanoTime();
        arrayInsertionSort(arrayToSort);
        long timeAfterInsertionSort = System.nanoTime();
        System.out.println("Insertion sort: ");
        for (int sort : arrayToSort) {
            System.out.print(sort + ", ");
        }
        System.out.println(" ");
        System.out.println("Czas sortowania przez  wstawianie: " + calculateTimeOfSorting(timeBeforeInsertionSort, timeAfterInsertionSort));
        arrayToSort = unsortedArray;
        System.out.println("---------------");
        long timeBeforeQuickSort = System.nanoTime();
        arrayQuickSort(arrayToSort, 0, arrayToSort.length - 1);
        long timeAfterQuickSort = System.nanoTime();
        System.out.println("Quick sort: ");
        for (int sort : arrayToSort) {
            System.out.print(sort + ", ");
        }
        System.out.println(" ");
        System.out.println("Czas sortowania szybkiego: " + calculateTimeOfSorting(timeBeforeQuickSort, timeAfterQuickSort));


    }

    public static void arrayBubbleSort(int[] arrayToSort) {
        for (int i = 0; i < arrayToSort.length; i++) {
            for (int j = 0; j < arrayToSort.length - 1; j++) {
                if (arrayToSort[j] > arrayToSort[j + 1]) {
                    int temp = arrayToSort[j];
                    arrayToSort[j] = arrayToSort[j + 1];
                    arrayToSort[j + 1] = temp;
                }
            }
        }
    }

    public static void arrayInsertionSort(int[] arrayToSort) {
        int currentNumber, otherIndex;
        for (int i = 1; i < arrayToSort.length; i++) {
            currentNumber = arrayToSort[i];
            otherIndex = i;
            while (otherIndex > 0 && currentNumber < arrayToSort[otherIndex - 1]) {
                arrayToSort[otherIndex] = arrayToSort[otherIndex - 1];
                otherIndex--;
            }
            arrayToSort[otherIndex] = currentNumber;
        }
    }

    public static void arrayQuickSort(int[] arrayToSort, int left, int right) {
        if (left >= right) {
            return;
        }
        int pivotValue = arrayToSort[right];
        int border = left - 1;
        int i = left;

        while (i < right) {
            if (arrayToSort[i] < pivotValue) {
                border++;
                if (border != i) {
                    int temp = arrayToSort[border];
                    arrayToSort[border] = arrayToSort[i];
                    arrayToSort[i] = temp;
                }
            }
            i++;
        }
        border++;
        if (border != right) {
            int temp = arrayToSort[border];
            arrayToSort[border] = arrayToSort[right];
            arrayToSort[right] = temp;
        }

        arrayQuickSort(arrayToSort, left, border - 1);
        arrayQuickSort(arrayToSort, border + 1, right);
    }

    public static long calculateTimeOfSorting(long timeBefore, long timeAfter) {
        long difference = timeAfter - timeBefore;
        long timeOfSortingToMicroseconds = (long) (difference* 0.001);
        return timeOfSortingToMicroseconds;

    }
}

Sortowanie quicksort

Sat, 28 Mar 2020 17:14:51 +0000

Słyszałem, że quicksortem nie można posortować 1e9 i większych liczb. Czy to prawda? Jeśli tak to jakie inne szybkie sortowanie jest jeszcze dostępne.

sortowanie quicksort 3 podanych przed uzytkownika cyfr w języku c

Sat, 09 Nov 2019 20:40:51 +0000

Jak ma wyglądać algorytm sortowania quicksort 3 podanych przez uzytkownika calkowitych liczb w jezyku c?

Proszę nie krzyczeć jestem poczatkujący :))

co tu trzeba pozmieniać żeby algorytm działał:

To jest w języku c++ o którym nic nie mam pojęcia:(

int partition(int tablica[], int p, int r) // dzielimy tablice na dwie czesci, w pierwszej wszystkie liczby sa mniejsze badz rowne x, w drugiej wieksze lub rowne od x
{
int x = tablica[p]; // obieramy x
int i = p, j = r, w; // i, j - indeksy w tabeli
while (true) // petla nieskonczona - wychodzimy z niej tylko przez return j nie wiem co tu zmienic
{
while (tablica[j] > x) // dopoki elementy sa wieksze od x
j--;
while (tablica[i] < x) // dopoki elementy sa mniejsze od x
i++;
if (i < j) // zamieniamy miejscami gdy i < j
{
w = tablica[i];
tablica[i] = tablica[j];
tablica[j] = w;
i++;
j--;
}
else // gdy i >= j zwracamy j jako punkt podzialu tablicy
return j;
}
}

void quicksort(int tablica[], int p, int r) // sortowanie szybkie
{
int q;
if (p < r)
{
q = partition(tablica,p,r); // dzielimy tablice na dwie czesci; q oznacza punkt podzialu
quicksort(tablica, p, q); // wywolujemy rekurencyjnie quicksort dla pierwszej czesci tablicy
quicksort(tablica, q+1, r); // wywolujemy rekurencyjnie quicksort dla drugiej czesci tablicy
}
}

int main()
{
int ilosc_liczb, i;
cout << "Podaj ilosc licz do posortowania: ";
cin >> ilosc_liczb;
int *tablica = new int [ilosc_liczb]; // utworzenie dynamicznej tablicy na 'ilosc_liczb' elementow

for (i = 0; i < ilosc_liczb; i++) // wczytywanie liczb do tablicy
{
cout << "Podaj liczba: ";
cin >> tablica[i];
}

quicksort(tablica,0,ilosc_liczb-1); // wywolanie funkcji sortujacej

for (i = 0; i < ilosc_liczb; i++) // wypisanie posortowanej tablicy
cout << "tablica[" << i << "] = " << tablica[i] << endl; nie wiem co tu zmienic

delete [] tablica; // zwolnienie tablicy zaalokowanej dynamicznie

return 0;
}

Quicksort źle segreguje tablicę z losowych liczb C++

Thu, 12 Sep 2019 12:30:18 +0000

Cześć,

Uczę się programowania i mam problem, którego nie mogę rozwiązać. Chciałem napisać program na zasadzie Totolotka. Program pobiera 6 liczb od użytkownika. Sam też generuje 6 liczb losowych. Wyniki są zapisane w dwóch oddzielnych tablicach, a następnie są sortowane i wyniki z obu tablic są porównywane. Program bez problemu generuje liczby losowe. Jednak gdy ma je posortować to się wykrzacza. Nie wiem czemu ale gdy robię to samo dla liczb podanych przez użytkownika to wszystko jest ok. Z góry dzięki za pomoc.

#include <iostream>
#include <time.h>
#include <cstdlib>

using namespace std;

void quicksort(int *tablica, int lewy, int prawy)
{
	int v = tablica[(lewy + prawy) / 2];
	int i, j, x;
	i = lewy;
	j = prawy;
	do
	{
		while (tablica[i] < v) i++;
		while (tablica[j] > v) j--;
		if (i <= j)
		{
			x = tablica[i];
			tablica[i] = tablica[j];
			tablica[j] = x;
			i++;
			j--;
		}
	} while (i <= j);
	if (j > lewy) quicksort(tablica, lewy, j);
	if (i < prawy) quicksort(tablica, i, prawy);
}

int main()
{
	srand(time(NULL));
	int tablica[6];
	int tablica2[6];

	cout << "Witam wszystkich na losowaniu duzego lottka." << endl;
	cout << "Podaj prosze 6 liczb z zakresu od 1 do 49 i zobaczymy czy to tobie sprzyja dzis szczescie." << endl;
	cout << "Pierwsza liczba:";
	cin >> tablica2[0];
	cout << "Druga liczba:";
	cin >> tablica2[1];
	cout << "Trzecia liczb:";
	cin >> tablica2[2];
	cout << "Czwarta liczba:";
	cin >> tablica2[3];
	cout << "Piata liczba:";
	cin >> tablica2[4];
	cout << "Szosta liczba:";
	cin >> tablica2[5];
	for (int i = 0; i < 6; i++)
	{
		do
		tablica[i] = rand() % 49 + 1;
		while (tablica[0] == tablica[1] == tablica[2] == tablica[3] == tablica[4] == tablica[5]);
		quicksort(tablica, 0, 5);


		cout << tablica[i] << " ";
	}
	cin.get();
	return 0;
}

Quicksort - błąd wykonania

Fri, 08 Feb 2019 15:10:01 +0000

Witam. Mam problem z moją implementacją quicksorta. Jak odpalam u siebie wszystko jest ok, nie udało mi się znaleźć zestawu danych, który powoduje wysypanie się programu. Na SPOJu dostaję jednak komunikat "błąd wykonania (SIGSEGV)". Co może być nie tak w tym kodzie? Wpatruję się w niego dłuższy czas i nie widzę co powoduje błąd.

(Kod jest częścią większego zadania, wiem że błąd jest gdzieś w tym miejscu bo po podmianie na InsertionSort SPOJ akceptuje rozwiązanie)

void QuickSort(int* arr, int l, int r){
	if(l >= r) return;
	int
		i = l - 1,
		j = r + 1,
		pivot = arr[(l + r) / 2];

	while(true){
		while(arr[++i] < pivot);
		while(arr[--j] > pivot);

		if(i <= j) swap(arr[i], arr[j]);
		else break;
	}

	if(j > l) QuickSort(arr, l, j);
	if(i < r) QuickSort(arr, i, r);
}

Pokazanie kroków algorytmu quicksort

Fri, 02 Nov 2018 17:51:56 +0000

Witam, otóż studiuję matematykę stosowaną i na przedmiocie algorytmy i struktury danych dostałem do napisania algorytm quicksort, program jednak oprócz zwykłego sortowania ma pokazywać każdy krok jaki algorytm ten wykonuję więc muszę wyświetlać oprócz gotowego i posortowanego zbioru również podzbiory na jakie główny zbiór zostaje podzielony. Niestety nie mam pojęcia jak to zrobić, sam algorytm udało mi się napisać i działa chyba poprawnie, niestety gdy próbuję modyfikować go tak aby wyświetlał pojedyńcze podzbiory to nie wyświetla je w postaci nieskładnego ciągu cyfr, próbuję wstawić cout w miejscu gdzie dokonuję dzielenia na partycję ale to nie działa tak jak myślałem,Próbowałem już różnych rozwiązań ale nie potrafię nic wykombinować,Wklejam kod działającego programu

#include <iostream>

using namespace std;

void Sortowanie( int tab[], int left, int right )
{
    int i = left;
    int j = right;
    int x = tab[( left + right ) / 2 ];
    do
    {
        while( tab[ i ] < x )
             i++;

        while( tab[ j ] > x )
             j--;


        if( i <= j )
        {
            swap( tab[ i ], tab[ j ] );

            i++;
            j--;
        }
    }
    while( i <= j );

    if( left < j )  Sortowanie( tab, left, j );
        cout << tab[i];
    if( right > i )  Sortowanie( tab, i, right );
        cout << tab[j];
}
int main()
{

    int ilosc_liczb, i;
cout << "Podaj ilosc licz do posortowania: ";
cin >> ilosc_liczb;
int *tablica = new int [ilosc_liczb]; // utworzenie dynamicznej tablicy na 'ilosc_liczb' elementow

for (i = 0; i < ilosc_liczb; i++) // wczytywanie liczb do tablicy
{
cout << "Podaj liczbe ";
cin >> tablica[i];
}
cout << "TABLICA PRZED SORTOWANIEM" << endl;
 for(i = 0; i<ilosc_liczb; i++)
{
  cout << tablica[i] << " ";
}
cout << endl;
Sortowanie(tablica,0,ilosc_liczb-1);
cout << "TABLICA POSORTOWANA" << endl;
for (i = 0; i < ilosc_liczb; i++) // wypisanie posortowanej tablicy
cout  << tablica[i] << "  ";

delete [] tablica; // usuniecie tablicy zaalokowanej dynamicznie

return 0;
}

Quicksort - sortowanie struktury

Sun, 24 Jun 2018 12:21:49 +0000

Musze wykonać sortowanie struktury za pomocą Quicksorta. Jest to struktura z książkami (tytuł, autor, rok wydania, cena). Wiem, że istnieje w C funkcja qsort, ale niestety nie mogę nią zrobić tego zadania, bo potrzebuje zliczyć liczbę porównań oraz zamian.

Na jakiej zasadzie powinienem podstawiać zmienną pivot? Teraz mam to zrobione tak i niestety wywala błędy w kompilatorze

int partition(struct daneks X[], int low, int high)
{
    char pivot[MAX_TYTUL] = X[low];
    char tytul[MAX_TYTUL];
    int i = low-1, j = high+1;

    while(i<j) {
        while(X[--j]>pivot[MAX_TYTUL])
            ;
        while(X[++i]<pivot[MAX_TYTUL])
            ;
        if(i<j)
        {
           strcpy(tytul, X[i].tytul);
           strcpy(X[i].tytul, X[j].tytul);
           strcpy(X[j].tytul, tytul);
        }
    }
    return j;
}

void quicksort(struct daneks X[], int low, int high)
{
    if(low<high) {
        int partition_index = partition(X,low,high);
        quicksort(X, low, partition_index);
        quicksort(X, partition_index+1, high);
    }
}

Quicksort i Heapsort jak pokazać że są niestabilne?

Sun, 24 Jun 2018 10:38:01 +0000

Mam za zadanie aby stworzyć strukturę przechowująca książki (tytuł, autor, rok wydania, cena), później posortować dane algorytmem quicksort oraz heapsort (alfabetycznie po tytułach), a następnie tak dobrać dane, aby pokazać, że są one niestabilne. Podpowie mi ktoś w jaki sposób mogę to zrobić?

quicksort - liczniki

Thu, 07 Jun 2018 17:15:22 +0000

Cześć mam pytanie. Czy liczniki które mam w kodzie dobrze liczą ilość zamian i porównań?

int counter,changes;

void quicksortMW(int_array_type array, int low, int high)
{
    if(low<high) {
        int partition_index = partitionMW(array,low,high);
        quicksortMW(array, low, partition_index);
        quicksortMW(array, partition_index+1, high);
    }
}

int partitionMW(int_array_type array, int low, int high)
{
    int pivot = array[low];
    int i = low-1, j = high+1;

    while(i<j) {
        while(array[--j]>pivot)
           ;
        while(array[++i]<pivot)
            ;counter++;
        if(i<j){
            swap(&array[i],&array[j]);
            changes++;

        }
    }
    return j;
}

quicksort rekurencja

Wed, 06 Jun 2018 17:40:28 +0000

Witam, muszę zadać to pytanie bo pogubiłem się w zrozumieniu wywołań rekurencyjnych.

Wszystko do tej pory rozumiem, ale nie potrafie zrozumieć dlaczego skąd bierze się ostatnie wywołanie rekurencyjne dla algorytmu quick sort. Kod zamieszczam poniżej, służy on do nauki krok po kroku co się dzieje w kodzie, mam nadzieje że, kod jest w miare czytelny.

(A dokładniej skąd w ostanim wywołaniu rekurencyjnym bierze się wartość dla prawy = 3, i = 2 ) ???

#include <iostream>                 //KOD DO NAUKI
#include <cstdio>

using namespace std;

void quicksort(int *tablica, int lewy, int prawy)
{
    int pivot = tablica[(lewy + prawy)/2];
    int i,j;
    i=lewy;
    j=prawy;

    cout << "---------------------------------------------------" << endl;
    cout << "lewy;                                   = " << lewy  << endl;
    cout << "prawy;                                  = " << prawy << endl;
    cout << "int pivot = tablica[(lewy + prawy)/2];  = " << pivot << endl;
    cout << "int i=lewy;                             = " << i     << endl;
    cout << "int j=prawy;                            = " << j     << endl;
    cout << "---------------------------------------------------" << endl <<endl;

    int counter = 1;
    do
    {
        cout << "Dzialanie petli do...while(i<=j);" << endl;
        cout << "---------------------------------------------------" << endl;

        while(tablica[i] < pivot) i++;
        cout<<"while(tablica[i]<pivot) i++;      i = "<< i <<endl;
        while(tablica[j] > pivot) j--;
        cout<<"while(tablica[j]>pivot) j--;      j = "<< j <<endl << endl;

        cout<<"warunek if(i<=j) wewnatrz petli do...while   "<<endl;
        if(i <= j)
        {
            swap(tablica[i],tablica[j]);
            cout<<"swap(tablica[i],tablica[j]);         = ("<<tablica[i]<<","<<tablica[j]<<")"<<endl;

            i++;
            j--;
            cout<<"i++;                               i = "<< i <<endl;
            cout<<"j--;                               j = "<< j <<endl;

        }

        cout<<'\n'<<"***Po posortowaniu nr."<<counter <<endl;
        for(int i=0; i<6; i++)
        {
            cout<<tablica[i]<<" ";
        }
        cout << "\n---------------------------------------------------" << endl;
        counter++;
        getchar();

    }
    while(i <= j);
   
    cout << endl << "[ i = " << i << "]" << "[prawy = " << prawy <<"]"<< endl;
    if(j>lewy)
    {
        cout <<endl<< "REKURENCJA" << endl;
        cout <<endl<< "lewy = "<< lewy << endl;
        cout << "j = "         << j << endl << endl;
        cout << "if(j>lewy)  quicksort(tablica,lewy, j);" << endl;
        quicksort(tablica,lewy, j);
    }
    cout << endl << "[ i = " << i << "]" << "[prawy = " << prawy <<"]"<< endl;
    if(i<prawy)
    {
        cout <<endl<< "REKURENCJA" << endl;
        cout <<endl<< "prawy = "<< prawy << endl;
        cout << "i = "          << i << endl<<endl;
        cout << "if(i<prawy) quicksort(tablica, i, prawy);" << endl;
        quicksort(tablica, i, prawy);
    }
}

int main()
{
    int tablica[] = {6, 3, 11, 3, 3, 9};

        cout<<"Przed posortowaniem: "<<endl;
        for(int i=0; i<6; i++) {

            cout<<tablica[i]<<" ";
        }

    cout<<endl<<"Sortuje teraz algorytmem quicksort. Prosze czekac!"<<endl << endl;
    cout << "quicksort (tablica, 0, 5);\nvoid quicksort(int *tablica, int lewy, int prawy)" << endl << endl;

    quicksort(tablica, 0, 5);

        cout<<"Po posortowaniu: "<<endl;
        for(int i=0; i<6; i++){

            cout<<tablica[i]<<" ";
        }

    return 0;
}

Wywala program podczas rekurencji - QuickSort

Wed, 30 May 2018 18:32:22 +0000

Cześć, potrzebuje zaimplementować QuickSorta. Oglądałem film z pewnego kanału odnośnie jak działa i była tam też również implementacja, którą po całkowitym zrozumieniu postanowiłem przekopiować.

void quick_Sort(int *tab, int left, int right)
{
    int border = right-1;
    int pivot = tab[right];
    int i = left;

    if(left>=right)
    {
        return;
    }


    while(i < right)
    {
        if(tab[i] < pivot)
        {
            border++;
            if(border != i)
            {
                swap(tab, border, i);
            }
        }
        i++;
    }

    border++;
    if(border != right)
    {
        swap(tab, border, right);
    }
    quick_Sort(tab,left,border-1);
    quick_Sort(tab,border+1,right);

    for(i=0; i<5; i++)
    {
        printf("%d  ",tab[i]);
    }
}

Niestety program wywala na końcu funkcji, gdy ma zostać wywołana rekurencja.

Wie ktoś o co chodzi?

C++ quick sort nie rekurencyjnie

Tue, 13 Mar 2018 20:13:40 +0000

Ma ktoś program quick sort nie rekurencyjnie i mógłby wysłać kod?

quicksort nierekurencyjnie

Tue, 13 Mar 2018 17:28:46 +0000

Witam

Mam probłem, jestem początkujący i mam za zadanie zrobić quicksort rekurencyjnie co już zrobiłem i quicksort nie rekurencyjnie. Co sprawia mi duży problem. Niestety nawet nie wiem jak zacząć :/ Jakieś rady jak zacząć czy coś?

Quick sort (szybkie wyszukiwanie)

Wed, 24 Jan 2018 09:15:50 +0000

Dzień dobry, dla Szybkiego wyszukiwania potrzebna parzysta ilość liczb? I jak w tedy kiedy jest nie parzysta ilość, dzielić na pół taką tablice?(jeżeli można z jakimś kodem przykładowym lub pseudo-kodem) Dziękuję z góry!

C++ odcinek 14 - problem ze zrozumieniem

Fri, 29 Dec 2017 13:10:26 +0000

Witam

Bez owijania w bawełnę jak w temacie, kod jest zerżnięty 1:1 z filmu Pana Mirosława

#include <iostream>
#include <time.h>
#include <windows.h>

using namespace std;

int ile;
clock_t start,stop;
double czas;

void quicksort(int *tablica, int lewy, int prawy)
{
    int v=tablica[(lewy+prawy)/2];
    int i,j,x;
    i=lewy;
    j=prawy;
    do
    {
        while(tablica[i]<v) i++;
        while(tablica[j]>v) j--;
        if(i<=j)
        {
            x=tablica[i];
            tablica[i]=tablica[j];
            tablica[j]=x;
            i++;
            j--;
        }
    }
    while(i<=j);
    if(j>lewy) quicksort(tablica,lewy, j);
    if(i<prawy) quicksort(tablica, i, prawy);
}

int main()
{
    cout << "Porownanie czasow sortowania v.1" << endl;

    cout<<"Ile losowych liczb w tablicy: ";
    cin>>ile;

    //dynamiczna alokacja tablicy
    int *tablica;
    tablica=new int [ile];

    //inicjowanie generatora
    srand(time(NULL));

    //wczytywanie losowych liczb do tablicy
    for(int i=0; i<ile; i++)
    {
        tablica[i] = rand()%100000+1;
    }

    //przepisanie tablicy do tablicy2
    for(int i=0; i<ile; i++)
    {
       tablica[i]=tablica[i];
    }


    cout<<endl<<"Sortuje teraz algorytmem quicksort. Prosze czekac!"<<endl;
    start = clock();
    quicksort(tablica, 0, ile-1);
    stop = clock();
    czas = (double)(stop-start) / CLOCKS_PER_SEC;
    cout<<endl<<"Czas sortowania quicksort: "<<czas<<" s"<<endl;


       cout<<"Po posortowaniu: "<<endl;
        for(int i=0; i<ile; i++)
        {
            cout<<tablica[i]<<" ";
        }


    delete [] tablica;

    return 0;
}

    cout << "Porownanie czasow sortowania v.1" << endl;

    cout<<"Ile losowych liczb w tablicy: ";
    cin>>ile;

    //dynamiczna alokacja tablicy
    int *tablica;
    tablica=new int [ile];

    //inicjowanie generatora
    srand(time(NULL));

    //wczytywanie losowych liczb do tablicy
    for(int i=0; i<ile; i++)
    {
        tablica[i] = rand()%100000+1;
    }

    //przepisanie tablicy do tablicy2
    for(int i=0; i<ile; i++)
    {
       tablica[i]=tablica[i];
    }


    cout<<endl<<"Sortuje teraz algorytmem quicksort. Prosze czekac!"<<endl;
    start = clock();
    quicksort(tablica, 0, ile-1);
    stop = clock();
    czas = (double)(stop-start) / CLOCKS_PER_SEC;
    cout<<endl<<"Czas sortowania quicksort: "<<czas<<" s"<<endl;


       cout<<"Po posortowaniu: "<<endl;
        for(int i=0; i<ile; i++)
        {
            cout<<tablica[i]<<" ";
        }


    delete [] tablica;

    return 0;
}

Mam tu problem ze zrozumieniem

        if(i<=j)
        {
            x=tablica[i];
            tablica[i]=tablica[j];
            tablica[j]=x;
            i++;
            j--;
        }

Dlaczego mam zamieniać się tymi zmiennymi, jak bym dał po prostu i-- i j++ to na pierwsze oko nie trzeba by było tego zamieniać. Jednak jak coś tam szperam w tym miejscu to zawsze program dostaje "laga". Wyjaśni ktoś czemu trzeba zamieniać a nie działa od razu?

Quick sort pomoc w wytłumaczeniu 2 linijek kodu.

Mon, 27 Nov 2017 18:38:51 +0000

void sortowanie(int *liczby, int lewy, int prawy)
{
    int v=liczby[(lewy+prawy)/2];

    int i,j,x;
    i=lewy;
    j=prawy;
    do
    {
        while(liczby[i]<v) i++;
        while(liczby[j]>v) j--;

        if(i<=j)
        {
            x=liczby[i];
            liczby[i]=liczby[j];
            liczby[j]=x;
            i++;
            j--;
        }

    }
    while (i<=j);

    if(j>lewy) sortowanie(liczby,lewy, j);
    if(i<prawy) sortowanie(liczby, i, prawy);

}

Witam mógłby mi ktoś wyjaśnić te 2 ostatnie czerwone linijki kodu, czemu nie może być np i zamiast lewy lub j zamiast prawy, bo nie działa takto funkcja. Dziękuje z góry za odpowiedź.

Problem ze zrozumieniem kodu quicksort

Sat, 25 Nov 2017 15:38:11 +0000

void quicksort(int *tablica, int lewy, int prawy)
{
int v=tablica[(lewy+prawy)/2];
int i,j,x;
i=lewy;
j=prawy;
do{
while (tablica[i]<v) i++;
while (tablica[j]>v) j--;
if (i<=j){
       x=tablica[i];
       tablica[i]=tablica[j];
       tablica[j]=x;
       i++; j--;
         }
}while(i<=j);

if (j>lewy) quicksort(tablica,lewy, j);
if (i<prawy) quicksort(tablica, i, prawy);
}

Witam, jest to kod z odcinka 14 z kursu c++ przedstawiający sortowanie quicksort zaznaczyłem na czerwono linijki kodu ktorych nie rozumiem, mógłby mi je ktoś wyjaśnić. Dziekuje z góry za pomoc.

Quick sort problem

Sat, 03 Jun 2017 11:12:53 +0000

Witam. Piszę własnie Quick sorta, przy zastosowaniu algorytmu Horea do wyznaczenia pivota. Niestety program po uruchomieniu zostaje przerwany, z niewiadomego mi powodu. Bardzo proszę Was o pomoc. Sam nie potrafię już znaleźć błędu.

#include <iostream>
#include <algorithm>
#include <vector>

void Quicksort(std::vector<int> & iTabWithDatas, int iFirst, int iLast);
int PartitionHorae(std::vector<int> & iTabWithDatas, int iFirst, int iLast);

int main()
{
	std::vector<int>ae{ 5,3,2,6,7,13,7,4};

	Quicksort(ae, 0, ae.size()-1 );

	for (int i = 0; i < ae.size() ; ++i)
	{
		std::cout << ae[i] << "," ;
	}

	return 0;
}

int PartitionHorae(std::vector<int> & iTabWithDatas, int iFirst, int iLast)
{
	int i = iFirst;
	int iPivot = iTabWithDatas[iFirst];
	int j = iLast;

	while (i <= j)
	{
		while (iTabWithDatas[j] < iPivot)
		{
			--j;
		}

		while (iTabWithDatas[i] > iPivot)
		{
			++i;
		}

		if (i <= j)
		{
			std::swap(iTabWithDatas[i], iTabWithDatas[j]);
			++i;
			--j;
		}
	}
	return j;

}

void Quicksort(std::vector<int> & iTabWithDatas, int iFirst, int iLast)
{
	if (iFirst < iLast)
	{
		int q = PartitionHorae(iTabWithDatas, iFirst, iLast);

		Quicksort(iTabWithDatas, iFirst, q);
		Quicksort(iTabWithDatas, q + 1, iLast);
	}

}

Z góry dziekuje za pomoc.

Pozdrawiam

Quicksort. Jak działa ten algorytm?

Thu, 19 Jan 2017 19:08:30 +0000

Może mi ktoś wytłumaczyć jak ten algorytm działa? Krok po kroku

function quicksort(arr) {
 if (arr.length <= 1) {
 return arr;
}

var arrLength = arr.length;
var pivotPosition = Math.floor(arrLength / 2);
var pivotValue = arr[pivotPosition];
var less = [],
    more = [],
    same = [];
for (var i = 0; i < arrLength; i++) {
    if (arr[i] === pivotValue) {
    same.push(arr[i]);
}
    else if (arr[i] < pivotValue) {
    less.push(arr[i]);
 }
    else {
     more.push(arr[i]);
     }
 }
   return quicksort(less).concat(same, quicksort(more));
 }
 quicksort([4,5,2,3,6,7,9,1,8]);

algorytm quicksort a jego implementacja w C++

Tue, 10 Jan 2017 11:15:04 +0000

Witajcie! Jestem na początku drogi jeśli chodzi o programowanie, jest to też moje pierwsze pytanie na forum, dlatego proszę o wyrozumiałość jeśli, pomimo starań, nie uda mi się zrobić wszystkiego zgodnie z regulaminem

Od jakiegoś czasu uczę się programowania (C++) z kursu p. Mirosława Zelenta (uwielbiam i polecam!) jednak jedna rzecz z odcinka 14 (o sortowaniu) nie daje mi spokoju. Dokładnie chodzi o założenia algorytmu quicksort a jego implementację w C++. Poniżej wklejam kod, jaki p. Mirosław podał w swoim filmiku:

void quicksort(int *tablica, int lewy, int prawy)
{
    int v=tablica[(lewy+prawy)/2];
    int i,j,x;
    i=lewy;
    j=prawy;
    do
    {
        while (tablica[i]<v) i++;
        while (tablica[j]>v) j--;
        if (i<=j)
        {
            x=tablica[i];
            tablica[i]=tablica[j];
            tablica[j]=x;
            i++; j--;
        }
    }
    while (i<=j);
    if (j>lewy) quicksort(tablica,lewy, j);
    if (i<prawy) quicksort(tablica, i, prawy);
}

I teraz tak: jeśli dobrze wszystko rozumiem, założeniem quicksortu (sortującego rosnąco) jest takie posortowanie tablicy, aby wszystkie elementy większe od osi znalazły się na prawo od osi, a mniejsze na lewo, po czym następują kolejne sortowania poprzez dalsze dzielenie powstałych "podtablic". Natomiast w podanej implementacji, jeśli dobrze widzę, powstaną raczej dwa zbiory liczb - zbiór liczb większych i mniejszych od osi, w jednym z nich znajdzie się oś, jednak niekoniecznie będzie ona "oddzielała" te dwa zbiory, np. dla tablicy: 29, 36, 2, 12, 53, 4, 70 po pierwszym sortowaniu będziemy mieć sytuację: 4 12 2 36 53 29 70, gdzie oś = 12, a więc pogrubiona przeze mnie liczba 2 leży po jej prawej stronie... Czy ktoś wie, dlaczego ta implementacja tak wygląda? Może ja coś zrozumiałam na opak? Z góry dzięki wielkie za wyjaśnienia, nie ukrywam, że temat trochę spędza mi sen z powiek

Problem z funkcją sortowania Quicksort

Mon, 22 Aug 2016 11:49:05 +0000

#include <iostream>

using namespace std;

void quicksort(int *tablica, int lewy, int prawy)
{
    int v=tablica[(lewy+prawy)/2];
    int i,j,x;
    i=lewy;
    j=prawy;
    do
    {
        while (tablica[i]<v) i++;
        while (tablica[j]>v) j--;
        if (i<=j)
        {
            x=tablica[i];
            tablica[i]=tablica[j];
            tablica[j]=x;
            i++;
            j--;
        }
    }
    while (i<=j);
    if (j>lewy) quicksort(tablica,lewy, j);
    if (i<prawy) quicksort(tablica, i, prawy);
}

int main()
{
int ile;
cout << "Ile liczb chcesz posotowac" << endl;
    cin >> ile;

    //tablica
    int *tablica;
    tablica=new int [ile];
    //tablica

cout << "Napisz te liczby\n" << endl;

    //wczytanie z klawiatury
    for(int i=1; i<ile; i++)
    {
        cin >> tablica[i];
    }
    //wczytanie z klawiatury

    //sortowanie
    quicksort(tablica,0,ile-1);
    //sortowanie

    //wypisanie posortowanej zawartosci
    for(int i=1; i<=ile; i++)
    {
cout << i << ". " << tablica[i] << endl;
    }
    //wypisanie posortowanej zawartosci
}

Witam, to jest część mojego pomysłu na program sortujący z użyciem algorytmu quicksort. Problem w tym, że zamiast posortowanych liczb otrzymuje dziwne liczby których pochodzenia nie rozumiem. Oto przykładowe zrzuty ekranu:

Za wszystkie udzielone odpowiedzi z góry dziękuje.Pozdrawiam

Problem z programem porównującym 2 algorytmy sortujące tak zwany quick sort i algortym sortujący poprzez zliczanie

Tue, 05 Jul 2016 09:31:14 +0000

Mam problem nie wiem czemu te programy dla wartości 10 spokojnie sortują a jeżeli dam im na przykład 32 to nagle zaczynają wariować oczywiście mowie tutaj o rozmiarze tablicy nie wiem czemu ale jeżeli zmienię z tab[32] na tab[33] a wyśle i tak 32 liczby do funkcji to wtedy sortuje poprawnie oczywiście nie wiem tego dla wszystkich wartości jakie istnieją bo jest ich bardzo dużo.Z tego co liczyłem na kartce algorytm się sprawdza, lecz problem jest taki, iż nie wiem czy to co napisałem jest ok proszę o pomoc jeżeli ktoś jest w stanie mi tutaj ogarnąć czemu zmiana tak tablicy powoduję poprawne wykonywanie programu dla większych tablic.
#include <iostream>
#include <windows.h>
#include <time.h>
#include <conio.h>
#include <iomanip>

using namespace std;

int podzielic(int tab[],int lewa,int prawa);
void QSort(int tab[],int lewa,int prawa);
void SortowanieZliczanie(int tab[],int wynik[],int dlugosc_tablicy);
void losownie(int tab1[],int tab2[],int n);

clock_t start,stop;

int main()
{
    int tab1Q[32],tab2Q[64],tab3Q[128],tab4Q[256],tab5Q[512],tab6Q[1024];
    int tab1Z[32],tab2Z[64],tab3Z[128],tab4Z[256],tab5Z[512],tab6Z[1024];
    int tab1Zw[32],tab2Zw[64],tab3Zw[128],tab4Zw[256],tab5Zw[512],tab6Zw[1024];
    double czas,czasQ=0,czasZ=0,Srednia_Q,Srednia_Z;
    srand(time(NULL));

    for(int j=0;j<4;j++)
    {
        losownie(tab1Q,tab1Z,32);
        cout<<endl<<endl<<"tablica dla QuickSort'a:"<<endl;
        for(int i=0;i<32;i++)
        {
            cout<<tab1Q[i]<<", ";
        }
        cout<<endl<<endl<<endl<<"tablica dla Sortowania Przez Zliczanie:"<<endl;
        for(int i=0;i<32;i++)
        {
            cout<<tab1Z[i]<<", ";
        }
        cout<<endl<<endl;
        start = clock();
        QSort(tab1Q,0,32);
        stop = clock();
        czas = (double)(stop-start)/CLOCKS_PER_SEC;
        cout<<"wykonano quicksort w "<<setprecision(100)<<czas<<" s"<<endl<<endl<<endl;
        czasQ+=czas;
        for(int i=0;i<32;i++)
        {
            cout<<tab1Q[i]<<", ";
        }
        cout<<endl<<endl;
        start = clock();
        SortowanieZliczanie(tab1Z,tab1Zw,32);
        stop = clock();
        czas = (double)(stop-start)/CLOCKS_PER_SEC;
        cout<<"wykonano zliczanie w "<<setprecision(100)<<czas<<" s"<<endl<<endl<<endl;
        czasZ+=czas;
        for(int i=0;i<32;i++)
        {
            cout<<tab1Zw[i]<<", ";
        }
    }
    Srednia_Q=czasQ/4;
    Srednia_Z=czasZ/4;
    cout<<endl<<endl<<"Sredni czas liczenia dla tablicy 32 elementy QuickSort "<<Srednia_Q<<" s"<<endl<<endl;
    cout<<"Sredni czas liczenia dla tablicy 32 elementy Zliczanie "<<Srednia_Z<<" s"<<endl<<endl;
    system("pause");
    system("cls");
    return 0;
}

void losownie(int tab1[],int tab2[],int n)
{
    for(int i=0;i<32;i++)
    {
        tab1[i]=rand()%100+1;
    }
    for(int i=0;i<32;i++)
    {
        tab2[i]=tab1[i];
    }
}

int podzielic(int tab[],int lewa,int prawa)
{
    int x= tab[lewa];
    int i = lewa, j= prawa, w;// i oraz j to sa indeksy tablicy
    while(true)//petla nieskonczona - wychodzimy z nie tylko przez return j
    {
        while(tab[j]>x)
            j--;
        while(tab[i]<x)
            i++;
        if(i<j) // zamieniamy miejscami w przypadku gdy i mniejszy od j
        {
            w = tab[i];
            tab[i]= tab[j];
            tab[j]=w;
            i++;
            j--;
        }
        else
            return j;
    }
}
void QSort(int tab[],int lewa,int prawa)//sortowanie szybkie
{
int q;
    if(lewa < prawa)
    {
        q = podzielic(tab,lewa,prawa);
        QSort(tab,lewa,q);
        QSort(tab,q+1,prawa);
    }
}
void SortowanieZliczanie(int tab[],int wynik[],int dlugosc_tablicy)
{
    int wartosc_MAX_liczb=100;

    wynik[dlugosc_tablicy];

    int pomoc[wartosc_MAX_liczb];

    for(int i=0;i<wartosc_MAX_liczb;i++)
    {
        pomoc[i]=0;
    }

    for(int j=0;j<dlugosc_tablicy;j++)
    {
        pomoc[tab[j]]=pomoc[tab[j]]+1;
    }
    for(int i=1;i<wartosc_MAX_liczb;i++)
    {
        pomoc[i]=pomoc[i]+pomoc[i-1];
    }
    for(int j=dlugosc_tablicy-1;j>=0;j--)
    {
        wynik[pomoc[tab[j]]-1]=tab[j];
        pomoc[tab[j]]=pomoc[tab[j]]-1;
    }

}

Pozdrawiam famousghost

Wyjaśnienie kodu quicksort (C++)

Wed, 15 Jun 2016 19:05:41 +0000


    int v=tablica[(lewy+prawy)/2];
    int p=lewy;
    int q=prawy;
    int x;
    do
    {
        while (tablica[p]<v) p++; //Wyszukujemy od Lewej strony tablicy element wiekszy od piwota
        while (tablica[q]>v) q--; // Wyszukujemy od prawej strony tablicy element mniejszy od piwota
        if (p<=q)
        {
            x= tablica[p];      //Zamieniamy elementy tak aby wiekszy od piwota podszedl na prawa strone
            tablica[p]=tablica[q];
            tablica[q]=x;    // a mniejszy od piwota poszedl na lewa
            p++;
            q--;
        }
    }   while (p<=q);


    if (q>lewy) quicksort(tablica,lewy,q);
    if (p<prawy) quicksort(tablica,p,prawy);

Witam, czy mógłby mi ktoś wytłumaczyć program Quicksort.

Całą logikę znam, ale ten program jest dla mnie nie zrozumiały.

problem z quick sort

Wed, 06 Apr 2016 19:27:44 +0000

Witam, w celu pocwiczenia programowania postanowilem samemu napisac w/w algorytm, tak dla lepszego zrozumienia tematu. Program dziala jednak nie dla wszystkich konfiguracji liczb, dla liczb: 9,5,7,0,5,7,7,9 program sie juz sypie. Klika dni probuje juz wymyslic co moze byc nie tak i niestety bez skutku. Z gory dziekuje za pomoc. Ponizej kod programu:

#include <iostream>
#include <cstdlib>
#include <time.h>

using namespace std;

void sortowanie(int liczby[], int p, int q)  //posylamy funkcji: tablice, indeks pierwszej liczby, indeks ostatniej liczby
{
    int os,m,w=q,y=p;
    os=liczby[(p+q)/2];
    while(p<q)
    {
        while(liczby[p]<os) p++;
        while(liczby[q]>os) q--;
        if(p<q)
        {
            //zamiana miejscami
            m=liczby[p];
            liczby[p]=liczby[q];
            liczby[q]=m;
            p++;
            q--;
        }
    }
    if(w>y)
    {
        sortowanie (liczby,p,(y+w)/2);
        sortowanie (liczby,(y+w)/2 +1,w);
    }

}

 

int main()
{
    //--WPROWADZENIE I SPRAWDZENIE DANYCH--
    int n;
    cout << "Wprowadz ile liczb chcesz posortowac: ";
    cin>>n;
    //n - ilosc liczb
    while (n<=0)
    {
        cout<<"Liczba musi byc dodatnia!"<<endl;
        cout << "Wprowadz ile liczb chcesz posortowac: ";
        cin>>n;
    }
    int liczby[n];
    //tablica w ktorej beda przechowywane wprowadzone liczby
    //ponizej wprowadzanie liczb
    cout<<"Wprowadz pierwsza liczbe: ";
    cin>>liczby[0];
    for(int i=1; i<n; i++)
    {
        cout<<"Wprowadz kolejna liczbe: ";
        cin>>liczby[i];
    }

 

    //--SORTOWANIE (rosnaco) I MIERZENIE CZASU SORTOWANIA--
    clock_t start,stop;
    int czas;
    czas=(double)(stop-start)/CLOCKS_PER_SEC;

    sortowanie(liczby,0,n-1);

    //--WYPROWADZENIE DANYCH--
    for(int j=0; j<n; j++)
    {
        cout<<liczby[j]<<" ";
    }
    cout<<endl<<"Czas sortowania: "<<czas;

    return 0;
}

Program wywłaszczony - problem z sortowaniem

Thu, 12 Nov 2015 20:05:57 +0000

Witam! Od pewnego czasu zmagam się z zadaniem http://main.edu.pl/pl/archive/oi/4/kaj
Do jego wykonania użyłem na początku sortowania bąbelkowego lecz dostałem komunikat "Program wywłaszczony" i 44 punkty. Postanowiłem przerzucić się na quicksort lecz wtedy było jeszcze gorzej "Program wywłaszsczony" i 0 punktów. W czym jest problem? Nie mam za bardzo pomysłu.
Ktoś już zasugerował mi abym użył funkcji sort z biblioteki algorithm, lecz zastosowanie jej wymaga wiedzy, której nie posiadam, więc póki co chciałbym to wyminąć jeśli to możliwe.
Dołączam mój kod źródłowy. Z góry dziękuję za pomoc. :)

#include <iostream>

using namespace std;
int wagamax, ilosc, licznik=0;

void quicksort(int *tablica, int lewy, int prawy)
{
int v=tablica[(lewy+prawy)/2];
int i,j,x;
i=lewy;
j=prawy;
do
{
while (tablica[i]<v) i++;
while (tablica[j]>v) j--;
if (i<=j)
{
x=tablica[i];
tablica[i]=tablica[j];
tablica[j]=x;
i++;
j--;
}
}
while (i<=j);
if (j>lewy) quicksort(tablica,lewy, j);
if (i<prawy) quicksort(tablica, i, prawy);
}

int main()
{
cin>>wagamax>>ilosc;
int *waga;
waga= new int [ilosc];
for(int i=0; i<=ilosc-1; i++)
{
cin>>waga[i];
}
quicksort(waga, 0, ilosc-1);
for(int i=0; i<=ilosc-1; i++)
{
cout<<waga[i]<<endl;
}
int j=0;
for(int i=ilosc-1; i>=0; i--)
{
if(waga[j]!=0 && waga[i]!=0)licznik++;
if(waga[i]+waga[j]<=wagamax)
{
waga[j]=0;
j++;
}
waga[i]=0;
}
delete [] waga;
cout<<licznik;
return 0;
}

Sortowanie quicksort - kilka pytań

Sun, 26 Jul 2015 19:09:16 +0000

Witam serdecznie. Jestem nowym użytkownikiem forum MZ, dlatego, jeśli to możliwe, proszę o wyrozumiałość. ;) Witajcie.

Od kilku godzin analizuję algorytm quicksort. Większość już rozumiem (tak, wiem, szybki nie jestem...), ale mam kilka wątpliwości.

void quicksort(int *tablica, int lewy, int prawy) { 
	int v=tablica[(lewy+prawy)/2]; 
	int i,j,x; 
	i=lewy; 
	j=prawy; 
	do{ 
		while (tablica[i]<v) i++; 
		while (tablica[j]>v) j--; 
		if (i<=j){ 
			x=tablica[i]; 
			tablica[i]=tablica[j]; 
			tablica[j]=x; 
			i++; 
			j--; 
		} 
	} while (i<=j); 
	if (j>lewy) quicksort(tablica,lewy, j); 
	if (i<prawy) quicksort(tablica, i, prawy); 
}

Kod z prezentacji pana Zelenta.

Moje pytania:
- dlaczego w linii 9. i 16. używamy warunku mniejszy bądź równy zamiast mniejszy?
- dlaczego używamy pętli do..while, a nie while; czemu pętla powinna wykonać się raz przed sprawdzeniem warunku?
- dlaczego w 17. i 18. linijce kodu są warunki; co by było bez nich?

Pozdrawiam, z góry dziękuję za odpowiedź.

Dziwne errory (quicksort)

Mon, 01 Jun 2015 22:07:32 +0000

Chciałem zrobić funkcje sortującą elementy vectora. Dodam, że to jest vector obiektów. Niestety wyrzuca mi dziwne błędy. (tak, wiem, że ona sortuje cały wektor i nie mam innej możliwości, tak ma być).

template <class U>
void quicksort(vector<U> &tab,int left, int right)
{
    int os=tab[tab.size()/2].def;
    int p=0,q=tab.size()-1;
    U tmp; //to bedzie dzialac? 
    do
    {
        while(tab[p].def<os) p++;
        while(tab[q].def>os) q--;
        if(tab[p].def<=tab[q].def)
        {
            tmp=tab[p];
            tab[p]=tab[q];
            tab[q]=tmp;
            p++;
            q--;
        }
    }
    while(p<=q);
    if(q>0) quicksort(tab, left, q);
    if(p<tab.size()-1) quicksort(tab, p, right);
}

Błędy:

variable or field `quicksort' declared void
template declaration of `int quicksort' ( przeciez jest void! )
`vector' was not declared in this scope (jest dodana biblioteka - #include <vector> )
expected primary-expression before '>' token
`tab' was not declared in this scope
expected primary-expression before "int"
expected primary-expression before "int" (jaki int?! o_O )

//wszystkie powyższe odnoszą się do pierwszej linii, poniższy do drugiej
expected `;' before '{' token

Niedokładne sortowanie quicksort

Fri, 29 May 2015 19:54:17 +0000

Bardzo proszę o pomoc z poniższym kodem. Niestety sortowanie przebiega niedokładnie, a więc to żadne sortowanie :) ale niestety nie mogę zlokalizować gdzie robię błąd.

void quicksort(int tab[],int poczatek, int koniec){
int punkt_podzialu = (poczatek+koniec)/2;
if(poczatek<koniec){
podzial(tab,poczatek,koniec,punkt_podzialu);
quicksort(tab,poczatek,punkt_podzialu-1);
quicksort(tab,punkt_podzialu+1,koniec);
}
return;
}

void podzial (int tab[], int poczatek,int koniec, int punkt_podzialu)
{
    int i = poczatek;
    int j = koniec;
    int v = tab[poczatek];
    int temp;

    do {
        while (tab[i] <= v)
            i++;
        while (v <= tab[j])
            j--;
        if ( i <= j )
        {
            temp = tab[i];
            tab[i] = tab[j];
            tab[j] = temp;
            i++;
            j--;
        }
    } while (i <= j);

    return;
}

qsort tablicy dwuwymiarowej

Sun, 19 Apr 2015 16:34:38 +0000

Hej.

Wiem jak używać qsorta dla tablicy jednowymiarowej ale problem zaczął się gdy chciałem posortować poszczególne kolumny tablicy dwuwymiarowej. Przekazywanie jednej kolmuny do funkcji qsort za pomocą *(tab+i) nie działa. Zamieszczam fragment kodu:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#define sizex 10
#define sizey 15

char losuj(void);
int my_compare (const void *, const void *);
int main(void)
{
	int i,j;
	char **tab;
	srand(time(NULL));

	//alokuje pamiec na tablice wskaznikow do tablic
	tab=(char**)malloc(sizex*sizeof(char*));
	//alokuje tablice drugiego wymiaru
	for(i=0; i<sizex; i++)
		*(tab+i)=(char*)malloc(sizey*sizeof(char));
	//wypelniam tablice
	for(i=0; i<sizex;i++)
	{
		for(j=0; j<sizey; j++)
		{
			tab[i][j]=losuj();
			printf("%c ", tab[i][j]);
		}
		puts("\n");
	}

	//qsortowanie
	for(i=0; i<sizex; i++)
		qsort(*(tab+i), sizey, sizeof(char), my_compare);

	//wypisanie tablicy posrtowanej
	puts("SORT");
	for(i=0; i<sizex;i++)
	{
		for(j=0; j<sizey; j++)
		{
			printf("%c ", tab[i][j]);
		}
		puts("\n");
	}

	//dokonuje dealokacji
	for(i=0; i<sizex; i++)
		free(*(tab+i));
	free(tab);
	
	return 0;
}

int my_compare (const void * a, const void * b)
{
	const char **ia=(const char **)a;
	const char **ib=(const char **)b;
	return strcmp(*ia, *ib);
}

[C++] Sortowanie szybkie

Thu, 09 Apr 2015 13:06:35 +0000

Witam, proszę Was o uzupełnienie algorytmu sortowania szybkiego o komentarze. Chodzi o to że nie do końca rozumiem działanie samej funkcji.

Wiem że algorytm dzieli tablice na dwie partycje, nastepnie zaczyna dzielić te partycje na kolejne metodą "Dziel i zwyciężaj" jednak nie rozumiem np. tej części kodu, wiem że zapętla on działanie funkcji (rekurencja) partycjując coraz mniejsze zbiory, ale dlaczego np. dane wprowadzane do funkcji 'Sortowanie' są różne od siebie

if (q>lewy) Sortowanie(tablica,lewy,q);         
if (p<prawy) Sortowanie(tablica,p,prawy);

tzn. występuje (tablica,lewy,q), a dlaczego niżej nie ma (tablica,prawy,p) tylko (tablica,p,prawy).

Proszę o pomoc, najlepiej by było gdyby ktoś uzupełnił algorytm o odpowiednie komentarze. Oto kod:

void Sortowanie(int *tablica, int lewy, int prawy)
{
    int v=tablica[(lewy+prawy)/2]; 
    p=lewy;
    q=prawy;
    do
    {
        while (tablica[p]<v) p++;                  
        while (tablica[q]>v) q--;
        if (p<=q)
        {
            swap (tablica[p],tablica[q]);
            p++;
            q--;
        }
    }   while (p<=q);
    if (q>lewy) Sortowanie(tablica,lewy,q);         
    if (p<prawy) Sortowanie(tablica,p,prawy);
}