Transcript Ordenamiento de Arreglos en C++

Ordenamiento de Arreglos
COMP 242
Ordenamiento de Arreglos
• Bubble Sort
– Manera fácil de organizar datos en orden
ascendente o descendente.
Bubble sort
• Ejemplo:
7
2
3
8
9
1
0
1
2
3
4
5
Bubble sort
7
0
2
3
8
9
1
1
2
3
4
5
El bubble sort comienza comparando los primeros dos elementos en el
arreglo. Si el elemento 0 es mayor que el elemento 1, se intercambian
los valores. Luego del intercambio, el arreglo se mostrará como sigue:
Bubble sort
2
0
7
3
8
9
1
1
2
3
4
5
Este método se repite con los elementos 1 y 2. Si el elemento 1 es mayor
que el elemento 2, estos se intercambian. Entonces el arreglo se mostrará
como sigue:
Bubble sort
2
3
7
8
9
1
0
1
2
3
4
5
Luego, se comparan los elementos 2 y 3. En el arreglo, estos elementos ya
están en orden ascendente, por lo tanto no ocurre intercambio. Al continuar
el ciclo, se comparan los elementos 3 y 4. Una vez más, no ocurre
intercambio. Al compararse los elementos 4 y 5, ocurre intercambio ya que el
contenido del elemento 4 es mayor al elemento 5. Luego de esto, el arreglo
lucirá como a continuación:
Bubble sort
2
3
7
8
1
9
0
1
2
3
4
5
En este punto, todo el arreglo ya ha sido verificado, pero aún su contenido no
está en el orden correcto. El proceso comienza de nuevo comparando los
elementos 0 y el 1. No ocurre intercambio ya que ambos están en el orden
correcto. Se comparan los elementos 1 y 2 y tampoco ocurre intercambio. Se
procede a comparar los elementos 2 y 3, y tampoco ocurre intercambio.
Entonces se comparan los elementos 3 y 4. Aqui ocurre intercambio ya que
no están en orden ascendente. El arreglo lucirá como sigue:
Bubble sort
2
3
7
1
8
9
0
1
2
3
4
5
Todo este proceso se repetirá hasta que no se tengan que realizar más
intercambio, es decir, hasta que todo el arreglo esté organizado de forma
ascendente.
Bubble sort
1
2
3
7
8
9
0
1
2
3
4
5
Al final del proceso, el arreglo lucirá de esta forma.
Bubble sort
• Programación en C++
#include<iostream>
using namespace std;
// Function prototypes
void sortArray(int [], int);
void showArray(int [], int);
int main()
{
// Array of unsorted values
int values[6]= {7, 2, 3, 8, 9, 1};
//Display the values
cout << "The unsorted values are: " << endl;
showArray(values, 6);
// Sort the values.
sortArray(values, 6);
//Display them again.
cout << "The sorted values are: " << endl;
showArray(values, 6);
system("pause");
return 0;
}
//Definition of function sortArray
void sortArray(int array[], int size)
{
bool swap;
int temp;
do
{
}
swap = false;
for(int count = 0; count < (size - 1); count++)
{
if (array[count] > array[count + 1])
{
temp = array[count];
array[count] = array[count + 1];
array[count + 1] = temp;
swap = true;
}
}
} while (swap);
// Definition of function showArray
void showArray(int array[], int size)
{
for(int count = 0; count < size; count++)
cout << array[count] << " ";
cout << endl;
}
Selection Sort
• El bubble sort es ineficiente para organizar
arreglos que contengan una gran cantidad
de datos porque solo mueve un dato a la
vez. El ordenamiento de selección o
Selection sort usualmente realiza pocos
intercambios porque mueve los datos
inmediatamente a la posición final del
arreglo.
Selection Sort
• Ejemplo:
5
7
2
0
1
2
8
3
9
1
4
5
Se inicia escaneando el arreglo completo comenzando con la posición 0,
hasta localizar el elemento con el valor más pequeño. El contenido de
este elemento se intercambia con el elemento 0. Esto causa que el
arreglo luzca asi:
Selection Sort
1
7
0
1
2
8
2
3
9
5
4
5
El algoritmo repite el proceso, pero como ya el elemento 0 del arreglo
contiene el valor más pequeño, se comienza en esta ocasión con el elemento
1. Aqui el contenido del elemento 1 se intercambia con el elemento 2 (valor
más pequeño de arreglo de los elementos restantes). Luego de esto, el
arreglo luce asi:
1
0
2
1
7
8
9
5
2
3
4
5
Selection Sort
Nuevamente se repite el proceso, pero esta vez comenzando el escaneo del
arreglo en el elemento 2. Tan pronto se localize el valor menor entre los
elementos restantes, se intercambia con el elemento 2. Se sigue repitiendo
el algoritmo hasta que se finalice de escanear todo el arreglo. Al final, lucirá
como sigue:
1
2
5
7
8
9
0
1
2
3
4
5
Selection Sort
• Programación en C++
#include<iostream>
using namespace std;
void selectionSort(int [], int);
void showArray(int [], int);
int main()
{
const int SIZE = 6;
int values[SIZE] = {5, 7, 2, 8, 9, 1};
cout << "The unsorted values are: " << endl; //Display the values
showArray(values, SIZE);
selectionSort(values, SIZE); // Sort the values
cout << "The sorted values are: " << endl; // Display the values again
showArray(values, SIZE);
system("pause");
return 0;
}
void selectionSort(int array[], int size)
{
int startScan, minIndex, minValue;
for(startScan = 0; startScan < (size -1); startScan++)
{
minIndex = startScan;
minValue = array[startScan];
for(int index = startScan + 1; index < size; index++)
{
if(array[index] < minValue)
{
minValue = array[index];
minIndex = index;
}
}
array[minIndex] = array[startScan];
array[startScan] = minValue;
}
}
void showArray(int array[], int size)
{
for(int count = 0; count < size; count++)
cout << array[count] << " ";
cout << endl;
}