1. Ordenación de vectores en C: burbuja, selección directa y quicksort
22 abril 2008 in ...en lenguaje C, ...para estudiantes, Programación
(Este artículo forma parte del Curso de Programación en C)
Ya hemos hablado de la definición de vectores y de las operaciones básicas con
vectores. Ahora nos detendremos en uno de los problemas clásicos de la programación
de vectores: la ordenación de sus elementos.
Ordenar los elementos de un vector mediante algún criterio es una operación típica y en
absoluto trivial. Por ejemplo, un vector de números enteros puede ordenarse de menor a
mayor. Si el vector original es este:
0 1 2 3 4
+---+---+----+---+---+
| 5 | 3 | 14 | 9 | 8 |
+---+---+----+---+---+
…si lo ordenamos de forma creciente (de menor a mayor), nos quedará este otro vector:
0 1 2 3 4
+---+---+---+---+----+
| 3 | 5 | 8 | 9 | 14 |
+---+---+---+---+----+
Del mismo modo, se pueden ordenar los elementos con cualquier otro criterio: de mayor
a menor, primero los pares y luego los impares, o cualquier otro que nos resulte útil para
resolver un problema.
Métodos de ordenación de vectores hay muchos, desde los más simples (e ineficientes)
hasta los más elaborados, y constituyen un área de estudio muy interesante dentro de la
algorítmica.
A continuación mostraremos tres métodos de ordenación muy populares:
El método de la burbuja (o de intercambio directo), un método sencillo de
entender pero bastante lento
El método de selección directa, otro método simple e ineficiente.
El método rápido o quicksort, un algoritmo elegante y recursivo que ordena
vectores con asombrosa rapidez.
Cualquier estudiante de programación debe leer los tres algoritmos detenidamente y
tratar de comprenderlos. Dibuje en un papel un vector desordenado de pocos elementos
y haga un traceo de cada función de ordenación para comprender cómo actúa. Debería
ser capaz de entender el funcionamiento de, al menos, el método de la burbuja y el de
selección directa.
(Nota: en lo que sigue, LONGITUD_VECTOR es una constante que se supone definida
en alguna otra parte del programa)

2. Ordenación por INTERCAMBIO DIRECTO (burbuja)
El método de la burbuja es muy ineficiente, es decir, tarda mucho tiempo
en ordenar un vector si éste es muy largo. Pero es fácil de entender, así que
vamos a comenzar por aquí.
La idea general es simple: tomaremos los dos primeros elementos y los
compararemos. Si están desordenados, intercambiamos sus posiciones. Si
están ordenados, los dejamos como están.
Después haremos lo mismo con los elementos segundo y tercero (comparar
y, si es necesario, intercambiar). Luego, con el tercero y el cuarto. Después
con el cuarto y el quinto, y así sucesivamente hasta recorrer el vector
completo.
Cuando lleguemos al final, el vector no estará todavía ordenado, pero el
elemento más grande del vector habrá subido hasta la última posición,
igual que una burbuja de aire en el agua.
Si volvemos a repetir el proceso desde el principio, el segundo elemento
más grande habrá subido hasta la penúltima posición del vector. Y, la
siguiente vez, el tercer elemento más grande subirá hasta la antepenúltima
posición. Y así hasta que ordenemos todos los elementos.
Si el vector tiene N elementos, hay que repetir el recorrido N veces, aunque
en cada repetición podemos quedarnos una posición más abajo del final, ya
que sabemos con seguridad que los últimos elementos están colocados en
su sitio.
El algoritmo funciona exactamente igual si recorremos el vector desde el
final hacia el principio, sólo que, en ese caso, son los elementos más
pequeños los que van descendiendo y colocándose en su posición definitiva
en cada iteración del algoritmo.
En la siguiente implementación, usamos este segundo enfoque: repetimos
el proceso tantas veces como elementos tenga el vector
(LONGITUD_VECTOR) y, en cada repetición, recorremos el vector desde
el final hacia atrás, comparando e intercambiando pares adyacentes de
elementos.
(Aviso importante: la plantilla de WordPress muestra automáticamente dos
caracteres “-” consecutivos cómo si fueran un guión largo “–”. Si desea
usar esta implementación, recuerde que debe deshacer ese cambio)

3. void ordena_vector(int v[LONGITUD_VECTOR])
{
int i, j, elem;
for (i = 1; i < LONGITUD_VECTOR; i++)
{
for (j = LONGITUD_VECTOR - 1; j >=i; j--)
{
if (v[j-1] > v[j])
{
elem = v[j-1];
v[j-1] = v[j];
v[j] = elem;
}
}
}
}
El método de la burbuja necesita muchos pasos para completarse (y por eso
tarda tanto y se dice que es un algoritmo ineficiente). En concreto, si vector
tiene N elementos, hay que ejecutar alrededor de N*N pasos para
completar la ordenación. El tiempo de ejecución es proporcional al número
de pasos necesarios y, por lo tanto, crecerá exponencialmente (al ritmo de
N2
) con el tamaño del vector. Por eso no es un método práctico cuando se
trata de vectores muy grandes.
El método de la burbuja admite varias mejoras de rendimiento, como se
explica aquí.
Ordenación por SELECCIÓN DIRECTA
El algoritmo de selección directa también parte de un concepto bastante
simple: recorrer todo el vector para buscar el elemento más pequeño y, una
vez localizado, colocarlo en la primera posición. El elemento que estuviera
ocupando la primera posición debe ser movido al lugar donde estaba el
elemento más pequeño, claro, o de lo contrario se sobreescribiría y se
perdería para siempre.
Después, haremos lo mismo buscando el segundo elemento más pequeño,
moviéndolo a la segunda posición del vector. Luego buscamos el tercer
elemento más pequeño, el cuarto, etc. Repitiendo esta búsqueda tantas
veces como elementos tenga el vector, habremos conseguido ordenarlo.
A continuación se presenta una posible implementación en C. Observe que
también se necesitan dos bucles anidados para culminar el proceso, por lo

4. que el número de pasos necesarios es alrededor de N2
y, por lo tanto, el
tiempo de ejecución también crece exponencialmente, como en el caso de
la burbuja.
void ordena_vector(int v[LONGITUD_VECTOR])
{
int i, j, minimo, posicion_minimo;
for (i = 0; i < LONGITUD_VECTOR; i++)
{
minimo = v[i];
posicion_minimo = i;
for (j=i; j < LONGITUD_VECTOR; j++)
{
if (v[j] < minimo)
{
minimo = v[j];
posicion_minimo = j;
}
}
v[posicion_minimo] = v[i];
v[i] = minimo;
}
}
Ordenación rápida (QUICKSORT)
El algoritmo Quicksort (u ordenación rápida) es un método de ordenación mucho más
elaborado que los dos anteriores y, por lo tanto, más difícil de comprender. Fue
desarrollado en 1960 por C. R. Hoare. La versión que presentamos es recursiva, pero
existen implementaciones equivalentes iterativas, más difíciles (todavía) de comprender,
pero más rápidas.
La idea es la siguiente: tomemos un elemento cualquiera del vector (generalmente el
elemento central), que llamaremos pivote. Buscamos a la derecha del pivote todos los
elementos que deberían estar a la izquierda (porque sean más pequeños que el pivote) y,
a la izquierda, todos los que deberían estar a la derecha (por ser más grandes) e
intercambiémoslos.
El proceso de intercambio de pares se repetirá hasta que alcancemos el pivote.
Entonces, sabremos que todos los elementos de la derecha del pivote son mayores que
éste, y, los de la derecha, son menores.
Ahora dividimos el vector en dos mitades: a la izquierda del pivote y a la derecha del
pivote. Procesaremos cada mitad con el mismo procedimiento: buscar un nuevo pivote e
intercambiar elementos de la izquierda y de la derecha.
Repetiremos el proceso hasta que los vectores sean triviales (es decir, hasta que el
pivote coincida con los extremos izquierdo y/o derecho).

5. Este algoritmo necesita, por término medio, un número de pasos proporcional a N *
log(N). Puede que no parezca mucho comparado con el N2
que necesita la burbuja,
pero, para tamaños muy grandes, la diferencia de tiempos es enorme.
NOTA: en esta implementación, por simplicidad, el vector v es una variable global
void ordena_vector(int iz, int de)
{
int i, j, x, w; i = iz;
j = de;
x = v[(iz+de) / 2];
do
{
while (v[i] < x) i++;
while (x < v[j]) j--;
if (i <= j)
{
w = v[i];
v[i] = v[j];
v[j] = w;
i++;
j--;
}
}
while (i <= j);
w = v[i];
v[i] = v[de];
v[de] = w;
if (iz < j) ordena_vector(iz, j);
if (i < de) ordena_vector(i, de);
}
(Aviso importante: la plantilla de WordPress muestra automáticamente dos caracteres
“-” consecutivos cómo si fueran un guión largo “–”. Si desea usar esta
implementación, recuerde que debe deshacer ese cambio)
como desarrollar el siguiente vector:
1.- Calcular el promedio de entre 1 y 100 valores almacenados en un vector. Determinar
además, cuántos son mayores que el promedio, imprimir el promedio, el número de
datos mayores que el promedio y una lista de valores mayores que el promedio
Le daré algunas pistas para que usted mismo desarrolle el programa (así es mucho más
divertido).
Supongamos que su vector se llama v y está declarado como:
int v[100];
Primero, introduzca los valores en el vector. Mejor valores aleatorios.
Después, haga un recorrido por el vector mediante un bucle for (desde 0 hasta 99,
ambos incluidos). Supongamos que la variable del bucle es i. Vaya sumando cada
elemento v[i] en una variable acumulador, de manera que, en cada paso, la variable

6. conserve su valor anterior y se incremente en v[i]. Así irá sumando todos los valores del
vector. No olvide inicializar el acumulador.
(Puede ver más sobre acumuladores aquí)
Cuando termine, divida el valor del acumulador entre 100: eso le dará el valor medio.
¡Ya puede imprimirlo!
Ahora inicialice dos contadores, uno para los valores menores que la media y otro para
los mayores.
Haga otro recorrido por el vector desde el 0 hasta el 99, pero ahora no acumule nada:
limítese a ver, con un if, si cada v[i] es menor y mayor que la media. Incremente uno de
los dos contadores en cada caso.
Cuando termine, podrá imprimir lo que tenga en cada contador: uno contendrá la
cantidad de números por debajo de la media, y el otro la cantidad de números por
encima de la media.
Parece una receta de cocina, ¿eh? Pero así son los algoritmos. Ánimo.
quisiera saber que funcion cumple el metodo burbuja en c++….
El método burbuja (o de intercambio directo) es uno de los muchos que existen para
ordenar vectores según algún criterio. En el artículo, ordenábamos vectores de números
enteros de menor a mayor, pero cualquier método puede alterarse para ordenar de mayor
a menor o de cualquier otra manera, así como para ordenar vectores de cualquier tipo de
elemento.
¿Y para que sirve esto? Bueno, las aplicaciones prácticas son ilimitadas. En cualquier
situación en la que se necesite ordenar una lista de datos cualesquiera, será necesario un
método de ordenación de vectores.
Por cierto: como se menciona en el artículo, el de la burbuja es popular sólo porque es
sencillo de entender y recordar, pero resulta muy ineficiente si el volumen de datos que
hay que ordenar es elevado.
hola ayuda por favorr si fuera tan amable
un programa en c ++ que implemente el metodo de la burbuja para ordenar 100 000 000 000
000 de numeros enteros
…bye
Supongo que alguien le habrá propuesto esa actividad como un ejercicio para que
aprenda a ordenar vectores. Pero si le proporcionásemos una solución completa, nunca
aprendería, así que no lo haremos.
Tiene usted un poco más arriba una implementación de la burbuja empaquetada en una
función. Trate de adaptarla a su problema. Es mucho más edificante que copiar la
solución de otro.

7. Ahora bien, tendrá serias dificultades para alojar en la memoria un vector cien billones
de posiciones. Suponiendo que cada número entero ocupe 4 bytes, necesitaría, haciendo
un cálculo aproximado, varios cientos de Terabytes para almacenarlo. Eso está más allá
de las capacidades de almacenamiento en memoria RAM de cualquier ordenador
convencional, y también más allá de la capacidad de los discos duros. Así que, o bien
exagera usted, o bien su vector no puede ser procesado mediante técnicas
convencionales.
Díganos si esa fabulosa cantidad es cierta y estaremos gustosos de crear un nuevo post
al respecto: “procesando vectores gigantes”.
como ordenaría numeros positivos y números negativos?
#include
#include
void main()
{
int n[4];
int aux[4];
int aux2[4];
int i=0, j=0,h=0;
clrscr();
for(i=0;i<3;i++)
{
printf(“Ingrese un numero: “);
scanf(“%d”,&n[i]);
}
for(i=0;i<=3;i++)
{
if((n[j]%2)==0)
{
aux[j]=n[j];
n[j]=n[j];
n[j]=aux[j];
}
else
{
aux2[j]=n[j];
n[j]=n[j];
n[j]=aux2[j];
}
}
printf(“nEstos son los numeros positivos: n”);
for(h=0;h<=3;h++)
{

8. printf(” %d”,aux[h]);
}
printf(“nEstos son los numeros negativos: n”);
for(j=0;j<=3;j++)
{
printf(” %d”,aux2[j]);
}
getch();
}
Esto es lo que he logrado hacer pero el programa no me muestra los valores ¿por que?
Lo que este programa pretende hacer (sin llegar a conseguirlo) es separar los pares y los
impares en dos vectores diferentes (aux y aux2). Bien, es un primer paso, pero luego
todavía le quedaría ordenar cada uno de los vectores resultantes.
No funciona por diversas razones. Le comento los errores que saltan a la vista de un
primer vistazo:
- Sólo se ingresan 3 números, cuando en el vector n caben 4.
- El bucle que separa los números en pares e impares está construido sobre la variable i
(for i…), pero en su interior utiliza usted la variable j.
- Los vectores aux y aux2 son de longitud 4, como el vector original (n). Pero al separar
pares e impares, los vectores resultantes (aux y aux2) difícilmente tendrán 4 valores
asignados, a menos que los cuatro números ingresados sean pares (y entonces el vector
de impares quedará vacío), o al revés. Eso hace que queden valores “basura” en las
posiciones no usadas de los vectores aux y aux2.
- ¿Qué sentido tiene la asignación n[j] = n[j]? La escribe usted dos veces en su código.
¿Y para qué sirve hacer n[j] = aux[j] justo después?
Function OrdenaFlujos(RangoDatos As Range)
numdatos = RangoDatos.Cells.Count / 2
Dim MatrizSinOrdenar As Variant
ReDim MatrizSinOrdenar(1 To numdatos, 1 To 2)
For n = 1 To numdatos
MatrizSinOrdenar(n, 1) = RangoDatos(n, 1)
MatrizSinOrdenar(n, 2) = RangoDatos(n, 2)
Next
For n = 1 To numdatos
For i = 1 To (numdatos – 1)
If (MatrizSinOrdenar(i, 1) > MatrizSinOrdenar(i + 1, 1)) Then
elementofecha = MatrizSinOrdenar(i, 1)

9. MatrizSinOrdenar(i, 1) = MatrizSinOrdenar(i + 1, 1)
MatrizSinOrdenar(i + 1, 1) = elementofecha
elementoflujo = MatrizSinOrdenar(i, 2)
MatrizSinOrdenar(i, 2) = MatrizSinOrdenar(i + 1, 2)
MatrizSinOrdenar(i + 1, 2) = elementoflujo
End If
Next
Next
OrdenaFlujos = MatrizSinOrdenar
End Function
Hola felicidades por tu pagina y por lo bien explicado que esta, mi pregunta es la
siguiente ¿Como eliminar numero repetido en un vector? lo he estado intentando pero
no he podido hacerlo ya intente crear un vector nuevo copiarlo lo que hice es q lo
ordene de menor a mayor ,el vector lo lleno con numeros aleatorios que el mismo
programa genera , aqui dejo parte de mi codigo ojala me pudieras decir mis errores.
…
//ordeno mi vector
int tem,j,g=0,n[g];
for(i=0;i<20;i++)
{
for(j=i+1;j<20;j++)
{
if(c[j]<c[i])
{
tem=c[j];
c[j]=c[i];
c[i]=tem;
}
}
}
//quito numeros iguales y los convierto cero
for(i=0;i<20;i++)
{
for(j=i+1;j<20;j++)
{
if(c[i]==c[j])
{
tem=c[j];
c[j]=c[i];
c[i]=0;
}
}
}

10. aqui imprimo el vector y si los numeros q se repiten me los marca con 0 lo pero me lo
imprime asi por ejemplo :
0 1 0 2 0 8 0 9
lo que quiero hacer es mandar al final los ceros para q quede asi
1 2 8 9 0 0 0 0
y ya despues imprimir el vector
1 2 8 9
espero me puedas ayudar a darme una idea gracias.