¿Cómo puedo ordenar una serie de punteros dobles según los valores a los que apuntan?

Question

Estoy intentando crear una función en C/C++ para ordenar una matriz y reemplazar cada valor con su "puntuación" o clasificación.Toma una matriz de puntero doble para una matriz de enteros y ordena los punteros dobles según el valor desreferenciado de los números enteros.Lo he intentado varias veces para que funcione, pero no puedo lograrlo.Una vez más, debe ordenar los punteros dobles según los valores a los que apuntan.Esto es lo que tengo:

void SortArray( int ** pArray, int ArrayLength )
{
  int i, j, flag = 1;     // set flag to 1 to begin initial pass
  int * temp;             // holding variable orig with no *
  for(i = 1; (i <= ArrayLength) && flag; i++)
  {
    flag = 0;
    for (j = 0; j < (ArrayLength -1); j++)
    {
        if (*pArray[j+1] > *pArray[j])    // ascending order simply changes to <
        { 
            temp = &pArray[j];            // swap elements
            pArray[j] = &pArray[j+1];
            pArray[j+1] = &temp;
            flag = 1;                     // indicates that a swap occurred.
        }
    }
  }
}

Answer 1

Estás cerca.Estás haciendo referencia a la dirección de los elementos de la matriz cuando intercambias, lo cual no es necesario.Los elementos de la matriz son punteros y eso es lo que debe intercambiarse.

Vea abajo:

void SortArray( int ** pArray, int ArrayLength )
{
    int i, j, flag = 1;    // set flag to 1 to begin initial pass
    int * temp;             // holding variable orig with no *
    for(i = ArrayLength - 1; i > 0 && flag; i--)
    {
        flag = 0;
        for (j = 0; j < i; j++)
        {
            if (*pArray[j] > *pArray[j+1])      // ascending order simply changes to <
            { 
                temp = pArray[j];             // swap elements
                pArray[j] = pArray[j+1];
                pArray[j+1] = temp;
                flag = 1;               // indicates that a swap occurred.
            }
        }
    }
}

Además, echa un vistazo esta encantadora publicación de blog sobre Bubble Sorting por si estás interesado (lo siento, complemento descarado :)).Espero que te ayude con tu tarea ;)

---

Editar:Tenga en cuenta la "optimización" sutil en la que cuenta hacia atrás desde la longitud de la matriz y solo incrementa hasta 'i' en el bucle interno.Esto le evita tener que analizar innecesariamente elementos que ya han sido ordenados.

Answer 2

Je, esto no es tarea.

Si ese es el caso, considere usar STL para administrar matrices y ordenar.Es más fácil de desarrollar y mantener y el algoritmo std::sort es asintóticamente más rápido que el tipo burbuja.

Answer 3

Deberías considerar usar std::swap() para hacer tu intercambio.Si es así, llámelo así:

swap( obj1, obj2 );

en vez de:

std::swap( obj1, obj2 );

Como la primera llamada semántica permitirá la búsqueda adecuada del espacio de nombres para encontrar la sobrecarga correcta, si existe.Asegúrese de tener:

using namespace std;

o:

using std::swap;

en algún lugar.

Answer 4

Hmm, no tengo mucha experiencia con el STL.¿Podrías dar un ejemplo?

Este programa crea un vector de enteros, lo ordena y muestra los resultados.

#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;

int main()
{
    vector<int>; vec;
    vec.push_back(7);
    vec.push_back(5);
    vec.push_back(13);
    sort(vec.begin(), vec.end());

    for (vector<int>::size_type i = 0; i < vec.size(); ++i)
    {
        cout << vec[i] << endl;
    }
}

Answer 5

Para completar el post de Brian Ensink, encontrarás el STL lleno de sorpresas.Por ejemplo, el algoritmo std::sort:

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

void printArray(const std::vector<int *> & p_aInt)
{
   for(std::vector<int *>::size_type i = 0, iMax = p_aInt.size(); i < iMax; ++i)
   {
      std::cout << "i[" << static_cast<int>(i) << "] = " << reinterpret_cast<unsigned     int>(p_aInt[i]) << std::endl ;
   }

   std::cout << std::endl ;
}


int main(int argc, char **argv)
{
   int a = 1 ;
   int b = 2 ;
   int c = 3 ;
   int d = 4 ;
   int e = 5 ;

   std::vector<int *> aInt ;

   // We fill the vector with variables in an unordered way
   aInt.push_back(&c) ;
   aInt.push_back(&b) ;
   aInt.push_back(&e) ;
   aInt.push_back(&d) ;
   aInt.push_back(&a) ;

   printArray(aInt) ; // We see the addresses are NOT ordered
   std::sort(aInt.begin(), aInt.end()) ; // DO THE SORTING
   printArray(aInt) ; // We see the addresses are ORDERED

   return EXIT_SUCCESS;
}

La primera impresión de la matriz mostrará direcciones desordenadas.El segundo, después de ordenar, mostrará las direcciones ordenadas.En mi compilador tenemos:

i[0] = 3216087168
i[1] = 3216087172
i[2] = 3216087160
i[3] = 3216087164
i[4] = 3216087176

i[0] = 3216087160
i[1] = 3216087164
i[2] = 3216087168
i[3] = 3216087172
i[4] = 3216087176

Eche un vistazo al encabezado <algoritmo> de STL http://www.cplusplus.com/reference/algorithm/Encontrarás muchas utilidades.Tenga en cuenta que tiene otra implementación de contenedores que podría adaptarse mejor a sus necesidades (std::list?estándar::mapa?).