Bloqueo del algoritmo de C++ Quicksort [cerrado]

Estoy trabajando en un algoritmo de ordenación rápida de C++ que cuenta el número de operaciones significativas durante la ordenación. Ordenará correctamente 100 valores, pero luego se atascará en un bucle sin fin. ¡Cualquier ayuda sería muy apreciada!

//QuickSort.cpp

#include "QuickSort.h"
#include <algorithm>

using namespace std;

QuickSort::QuickSort(int max) : SortData(max)
{
    /*
    maxSize = max;
    theData = new long[max];
    */
    SortData::randomize(12);

}

QuickSort::~QuickSort(void)
{

}

_int64 QuickSort:: sort()
{
    numops = 0;
    quicksort(theData, 0, (size()-1));
    return(numops);
}

//Include counting number of operations
void QuickSort::quicksort(long theData[], int left, int right)
{
    //Default variables

    if (size() <= 1 || left >= size() || right >= size()) return; //Bounds checking

    if (left < right)
    {
        long pivot = partition(theData, left, right);

        quicksort(theData, left, pivot-1);
        quicksort(theData, pivot+1, right);
    }
}

int QuickSort::partition(long theData[], int left, int right)
{
    long pivot = theData[left];
    while (true)
    {
        while (theData[left] < pivot) left++;
        numops ++;

        while (theData[right] > pivot) right--;
        numops ++; 

        if (left < right)
        {
            swap(theData[left], theData[right]);
            numops+=3;
        }

        else
        {
            return right;
        }
    }
}

//QuickSort.h

#pragma once
#include "SortData.h"

class QuickSort : public SortData
{

public:
    QuickSort(int max = 100);
    ~QuickSort(void);
    _int64 sort();
private:
    _int64 numops;
    void QuickSort::quicksort(long theData[], int left, int right);
    int partition(long theData[], int left, int right);
}; 

preguntado el 22 de mayo de 12 a las 21:05

¿Qué aspecto tiene SortData? ¿Está realmente asignando una matriz de tamaño máximo en el constructor? -

Tus partition Parece que la función entrará en un bucle infinito si encuentra dos elementos iguales al pivote (podría estar equivocado, no estudié su código de cerca). Si esto no es tarea, simplemente use std::partition. -

También tenga en cuenta que su numops omite gran parte de la lógica de partición. -

Aquí hay una esencia para sortdata gist.github.com/2771303 -

numops solo debe contar el número de operaciones significativas en la clasificación. -

2 Respuestas

En tu función de partición el

 if (left < right)

siempre es verdad Por lo tanto, está obteniendo el ciclo infinito while (true).

Y puede haber un problema en su función size() de SortData.h que aún no podemos ver.

Dado que los datos son aleatorios, verá el problema de vez en cuando en algunos conjuntos de entrada.

Una ligera modificación debe ayudar:

if (left <= right) {
         if (left < right) {
             swap(theData[left], theData[right]);
             numops += 3;
         }
         left++;
         right--;
}
else {
    return right;
}

Lo siento por la doble verificación :)

contestado el 22 de mayo de 12 a las 21:05

Estoy bastante seguro de que la condición está bien, ya que la intención es left sigue aumentando, y right sigue disminuyendo, y se detiene cuando se encuentran. - Pato morando

@Mooing Duck: algo dice esencialmente lo mismo - Viktor Latipov

partition se atasca si left < right y theData[left] == theData[right].

contestado el 24 de mayo de 12 a las 23:05

Entonces, ¿cuál sería la forma más fácil de arreglar eso? - user1411112

@user1411112: vea mi adición para su caso de esquina - Viktor Latipov

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.