[C++] [Punteros] Ordenar array de enteros, pesadilla total.

[DarkItachi]

Buenas, estoy intentando, mediante punteros, ordenar los enteros de un array por orden ascendente yendo simultáneamente por los dos extremos del array, algo así:

4 5 1 2 7 8 5 4 3 6

Comparo 4, 5 y 3 y 6.

4 5 1 2 7 8 5 4 3 6

Comparo 5,1 y 4,3

4 1 5 2 7 8 5 3 4 6

etc.

El caso esque creo que me estoy haciendo un lío enorme y creo no estar planteando bien el ejercicio, llevo hecho esto:

Código (cpp) [Seleccionar] Expandir


/* PROBLEMA ->
Implementar en una función el siguiente algoritmo para ordenar un array de enteros.
La idea es recorrer simultáneamente el array desde el principio y desde el final, comparando los elementos. Si los valores comparados no están en el orden adecuado, se intercambian y se vuelve a empezar el bucle. Si están bien ordenados, se compara el siguiente par.
El proceso termina cuando los punteros se cruzan, ya que eso indica que hemos comparado la primera mitad con la segunda y todos los elementos estaban en el orden correcto.
Usar una función con tres parámetros:
void Ordenar(int* vector, int nElementos, bool ascendente);
De nuevo, no se deben usar enteros, sólo punteros y aritmética de punteros. */
#include <iostream>
using namespace std;
//Ej. 4 3 7 8 4 1 0 12 13 5
void Ordenar(int*, int, bool);
void leerarray(int*,int);
int main()
{
   int array[]={4,3,7,8,4,1,0,12,13,5};
   Ordenar(array,10,true);
   leerarray(array,10);
   cin.get(); cin.get();
}
void Ordenar(int *vector,int nElementos, bool ascendente)
{
   int *a, *b;
   a=&vector[0]; b=&vector[nElementos-1];
   while (*(a++) != *(b--))
   {
       int temp;
       if (*(a-1)>*a) { temp=*(a-1); *(a-1)=*a; *a=temp; }
       if (*(b+1)<*b) { temp=*(b+1); *(b+1)=*b; *b=temp; }
   }
}


Alguna idea sobre donde estoy metiendo la pata? Porque de verdad, tantos asteriscos y demás me atormentan.

PD: Aún no he realizado lo de modo ascendente.

Salu2 y gracias =D

[leogtz]

Edit.

[biribau]

No entiendo lo que haces, pero un error que canta a la vista es la condición del while, no estas mirando que se crucen los punteros, tienes que quitar para eso los asteriscos, o sea *(p++) != *(q--) por p++ != q--
Luego si pretendes ordenar, no sé, ordenar un vector requiere un análisis matemático para desarrollar un algoritmo nuevo. Simplemente lo digo porque ese método no funcionará, o imitas burbuja(requieres otro while anidado) o quicksort, no se que intentas, es parecido a ambos, pero no es ninguno. Ya de paso que sepas que casi fijo necesitarás 2 bucles anidados, porque toda ordenación genérica no puede bajar de O(nlog2n), o sea un bucle y algo más.

[DarkItachi]

No entiendo lo que haces, pero un error que canta a la vista es la condición del while, no estas mirando que se crucen los punteros, tienes que quitar para eso los asteriscos, o sea *(p++) != *(q--) por p++ != q--
Luego si pretendes ordenar, no sé, ordenar un vector requiere un análisis matemático para desarrollar un algoritmo nuevo. Simplemente lo digo porque ese método no funcionará, o imitas burbuja(requieres otro while anidado) o quicksort, no se que intentas, es parecido a ambos, pero no es ninguno. Ya de paso que sepas que casi fijo necesitarás 2 bucles anidados, porque toda ordenación genérica no puede bajar de O(nlog2n), o sea un bucle y algo más.

Bien, cambié lo que me dijistes, pero me peta en tiempo de ejecución, supongo que algun indice fuera de lugar, tenía pensado el método burbuja pero el enunciado dice simultáneamente desde los dos extremos, voy a mirar que puede ser y mañana os cuento. Salu2

[biribau]

Claro que te peta, porque mientras uno decrementa otro incrementa, si el numero de elementos es par, ambos se "esquivan", y siguen creciendo to locos, disparados.
Ten en cuenta que un incremento + un decremento, es como avanzar de 2 en 2, a veces no se encontrarán.
edito: Antes no te lo dije porque no creí que pensaras que eso puede ordenar, necesitas otro bucle para hacer más pasadas, si pudieras ordenar ese vector aunque fuera de 5 elementos en una pasada, serías el nuevo Einstein  eh! no digo que no lo seas, era sólo un chiste  .

[.:BlackCoder:.]

Ese metodo de ordenacion sirve? 0o? no creo... Pero existen muchos... Esta el metodo por insercion, por seleccion (que es el que mas me gusta), burbuja, quicksort, etc... Mejor usa otro...
Saludos...

[.:BlackCoder:.]

Ademas estas bastante errado con respecto a como entendiste el enunciado... tienes que recorrer el vector comparando el ultimo con el primero... luego el primero+1 con el ultimo-1... Y asi sucesivamente... No el primero con el primero +1 0o?  Y cuando dice que si se cumple la condicion se empieze de nuevo, no tiene sentido porq igual estarias comprando lo mismo... De nuevo...

Saludos...

[DarkItachi]

Ademas estas bastante errado con respecto a como entendiste el enunciado... tienes que recorrer el vector comparando el ultimo con el primero... luego el primero+1 con el ultimo-1... Y asi sucesivamente... No el primero con el primero +1 0o?  Y cuando dice que si se cumple la condicion se empieze de nuevo, no tiene sentido porq igual estarias comprando lo mismo... De nuevo...

Saludos...

Bien, creo que ya lo pillé, esta tarde vuelvo a hacer el argoritmo de la forma que dices tu =D Ya os contaré :p

PD: Gracias

[DarkItachi]

Voy de mal en peor :S

Código (cpp) [Seleccionar] Expandir


}
void Ordenar(int *vector,int nElementos, bool ascendente)
{
    int *a, *b;
    a=&vector[0]; b=&vector[nElementos-1];
    for (int x=0;x<nElementos;x++)
    {
        for (int y=nElementos-1;y>0;y--)
        {
            int *temp;
            if (*(a+x)>*(b-nElementos+y-1)) { temp=a+x; *(a+x)=*(b-nElementos+y-1); *(b-nElementos+y-1)=*temp; }
            if (*(a+x)<*(b-nElementos+y-1)) { temp=b-nElementos+y-1; *(b-nElementos+y-1)=*(a+x); *(a+x)=*temp; }
        }
    }
}


Esto es lo que intenté hacer, pero sigo sin conseguirlo, :s, alguna idea?

[biribau]

Voy de mal en peor :S

Código (cpp) [Seleccionar] Expandir


}
void Ordenar(int *vector,int nElementos, bool ascendente)
{
    int *a, *b;
    a=&vector[0]; b=&vector[nElementos-1];
    for (int x=0;x<nElementos;x++)
    {
        for (int y=nElementos-1;y>0;y--)
        {
            int *temp;
            if (*(a+x)>*(b-nElementos+y-1)) { temp=a+x; *(a+x)=*(b-nElementos+y-1); *(b-nElementos+y-1)=*temp; }
            if (*(a+x)<*(b-nElementos+y-1)) { temp=b-nElementos+y-1; *(b-nElementos+y-1)=*(a+x); *(a+x)=*temp; }
        }
    }
}


Esto es lo que intenté hacer, pero sigo sin conseguirlo, :s, alguna idea?

Es que no sé que intentas hacer...
2 consejos:

• *(a+x) == a
• (y se lee mejor)
• el bucle del interior, y empieza en nElementos -1, pero tú usas -nElementos-1+y == y- nElementos - 1 == (nElementos-1)-nElementos-1 == 0 - 2, esto te cascará pues paras en y = 1 => b -nElementos == (vector+nElementos -1) -nElementos == vector-1(ilegal)

Hay 2 algoritmos parecidos de ordenación conocidos, mergesort y quicksort, ambos de tipo divide y vencerás.
Mergesort(es más parecido al tuyo) - ordena la mitad del vector y luego mezcla ambos vectores ordenados
Quicksort separa los mayores de un pivote de los menores en 2 particiones y ordena ambas mitades por el mismo método.
También tienes la burbuja que tenía una variante que sube y baja.
Yo no sé cómo se diseña un algoritmo de ordenación pero ya lo intenté alguna vez y no es sencillo, seguramente se necesite un desarrollo matemático, o al menos un pensamiento profundo. Si expones tu idea te podremos ayudar pero si estás codeando sin pensarlo es difícil que te salga(al menos has de contemplar todos los casos).