Ordenacioncpp 2020

Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería Industrial
10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 1

La búsqueda es uno de los problemas más
comunes en ciencia de la computación y sus
aplicaciones son diversas:
1. Buscar un empleo o practica en una bolsa de
trabajo.
2. Buscar un número telefónico en una guía o
directorio telefónico.
3. Buscar un información sobre un determinado
tema en el Internet

Tipos de Búsqueda
De acuerdo al lugar donde se realiza se clasifica en:
1. Búsqueda interna.- Se realiza en memoria

principal(RAM) utilizando preferentemente
arreglos.
2. Búsqueda externa.- Se realiza en memoria
secundaria(discos u otros periféricos). Se utilizan
arreglos u otras estructuras de datos.

Métodos de Búsqueda
Se presentan dos algoritmos de búsqueda:
1. Búsqueda Lineal o secuencial
2. Búsqueda Binaria
1) Búsqueda Lineal o secuencial.- Consiste en buscar una clave

k dentro de un arreglo, para ello se recorre todo el array,
desde la posición inicial hasta la final. Recorriendo el
arreglo en secuencia y preguntando por la clave hasta
encontrarla (éxito), si no, se considera fracaso en la
búsqueda. El algoritmo devuelve la posición o índice donde
la clave k se encontró caso contrario se devuelve –1 para
indicar fracaso en la búsqueda.

Algoritmo básico para la búsqueda secuencial
while(i<n AND a[i]!= k)
i++;
if(a[i]==k)
return i; //éxito
if(i==n)
return -1; //fracaso
Código C++:
int searchlin(int n, int a[], int x)
{ int i = 0;
while( i<n && a[i]! = x)
i++;
return (i == n)? (–1) : (i);// – 1 indica fracaso
}

Búsqueda Binaria
La búsqueda binaria consiste en dividir el intervalo de
búsqueda en dos partes comparando el elemento
buscado con el central en caso de no ser iguales se
redefinen los extremos del intervalo(según que el
elemento central sea mayor o menor que la llave). Esto
disminuye a la mitad el espacio de búsqueda. El
proceso continua y concluye cuando el elemento es
encontrado o hasta cuando el intervalo de búsqueda se
anule. El pre requisito es que el arreglo este ordenado.

Código C++ para la Búsqueda Binaria – Versión iterativa
int search_bin( int a[], int n, int key)
{ // version iterativa
int izq = 0, der = n - 1, mitad;
while( izq <= der )
{
mitad = (izq + der)/2;
if( a[mitad] < key )
izq = mitad + 1;
else if ( a[mitad] > key )
der = mitad - 1;
else
return mitad; //encontrado
}
return -1; // no encontrado
}

Código C++ para la Búsqueda Binaria, versión recursiva
int search_bin_recursiva(int a[],int key,int izq,int

der)
{ // version recursiva
int mitad;
if( izq > der )
return (-1);
mitad = (izq + der)/2; // division entera
return (key == a[mitad] ? mitad : key<a[mitad] ?
search_bin_recursiva(a, key, izq, mitad - 1):
search_bin_recursiva(a, key, mitad + 1, der));
}

Métodos de Ordenación
Se presentan los siguientes algoritmos de

ordenación:
1. Ordenación burbuja.
2. Ordenación por inserción directa.
3. Ordenación por selección directa.
4. Ordenación por Shell.
5. Ordenación por quicksort.

Algoritmo de la Burbuja:
Método 1:
Burbuja(n, X[])
Begin
for i0 to n-1 do
for j0 to j  n-1 do
if X[j ] > X[j+1] then //intercambiar
auxX[j]
X[j]X[j+1]
X[j+1]aux Para clasificar el vector completo se deben
realizar las sustituciones correspondientes
end if
(n-1)*(n-1) o bien n2-2n +1 veces. Si el
end for vector es de cien elementos, se deben
end for realizar casi 10.000 interacciones.
End // fin de burbuja

Código para la ordenación por burbuja1
void burbuja1(int x[MAX], int n)
{
int aux, i, j;
for (i = 0; i<n; i++)
{ for (j = n - 1; j > i; j--)
{ if ( x[j-1] > x[j] )
{ //intercambiar
aux = x[j-1];
x[j-1] = x[j];
x[j] = aux;
}
}
}
}

Algoritmos de la Burbuja
Método 2
Burbuja(n , X[ ])
Begin Este método mejora la velocidad de
for i0 to n-1 do ejecución del algoritmo. Obsérvese que en
for j0 to n-i do el primer recorrido del vector (cuando el
if X[j]>X[j+1] then i=0), el valor mayor del vector se mueve al
ultimo elemento X[n].`por consiguiente no
auxX[j]
es necesario comparar X[n-1] y X[n]. En
X[j]X[j+1] otras palabras, el limite superior del bucle
X[j+1]aux for puede ser n-2. después de cada paso se
end if puede decrementar en uno el limite superior
end for del bucle for.
end for

Código para la ordenación por burbuja 2
void burbuja2( int x[MAX], int n)
{
int aux, i, j;
for (i = n - 1; i > 0; i--)
{ for (j = 0; j<i; j++)
{ if ( x[j] > x[j+1])
{ //intercambiar
aux = x[j];
x[j] = x[j+1];
x[j+1] = aux;
}
}
}
}

Algoritmos de la Burbuja
Método 3 (Uso de una bandera o indicador lógico)
Burbuja3 ( n , X [ ])
Begin
bandera false Mediante una bandera o indicador
While bandera = False do lógico, se puede detectar la presencia o
bandera True ausencia de una condición. Así,
for k0 to N-1 do mediante la variable bandera se
if X[k]>=X[k+1] then representa la ordenación terminada con
auxX[k] un valor de verdad y no terminada con
X[k]X[k+1] un valor de falso.
X[k+1]aux
bandera false
end if
end for
end while

Código para la ordenación por burbuja 3
void burbuja3( int x[], int n)
{
int aux;
bool Flag = false; //bandera logica
while ( Flag == false )
{ Flag = true;
for (int k = 0; k<n; k++)
{
if ( x[k] > x[k+1])
{ aux = x[k];
x[k] = x[k+1];
x[k+1] = aux;
Flag = false;
}
}
}
}

Algoritmo de Ordenación por inserción
Este algoritmo es usado por los jugadores de cartas cuando

las ordenan y consiste en insertar un elemento en el lugar
que le corresponde dentro de una parte ya ordenada del
arreglo. Por convención se considera que el primer elemento
ya esta ordenado. El algoritmo básico es:
1. Tomar un elemento en la posición i.
2. Buscar su lugar en las posiciones anteriores.
3. Mover hacia la derecha las restantes
4. Insertarlo.

Algoritmo de Ordenación por inserción
Insercion (n, X[ ])
Begin // X[i] ya esta ordenado
for i 0 to n-1 do
temp = X[i] //Garantizar salida del while
j=i-1
while ( j >= 0 && temp < X[i])
X[j+1] = X[j] //movimientos
j=j-1
X[j + 1] = temp // Insercion
end for
End Insercion

Código para la ordenación por inserción
void insercionDirecta( int a[], int n)
{
int i, j;
for( i = 0; i < n; i++)
{
int temp = a[i];
j = i - 1;
while( j >= 0 && temp < a[j])
a[j+1] = a[j--];
a[j+1] = temp;
}
}

EJEMPLO: Sea el arreglo arreglo
A: 27 14 95 38 12 10 47
Se asume que el primer elemento del arreglo ya esta

ordenado.
Primera pasada:
A[1] < A[0] ( 14 < 27 )Si hay intercambio
14 27
A: 27 14 95 38 12 10 47
0 1 2 3 4 5 6
A: 14 27 95 38 12 10 47

Segunda pasada:
A[2] < A[1] ( 95 < 27 ) No hay intercambio
A[1] < A[0] ( 27 < 14 )No hay intercambio
A: 14 27 95 38 12 10 47
0 1 2 3 4 5 6
Tercera pasada:
A[3] < A[2] ( 38 < 95 ) Si hay intercambio
38 95
A: 14 27 95 38 12 10 47
0 1 2 3 4 5 6

Cuarta pasada:
14 27 38
12 12 12 12 95
A: 14 27 38 95 12 10 47
0 1 2 3 4 5 6

Quinta pasada:
12 14 27 38
10 10 10 10 10 95
A: 12 14 27 38 95 10 47
0 1 2 3 4 5 6

Sexta pasada:
47 95
A: 10 12 14 27 38 95 47
0 1 2 3 4 5 6
Al finalizar la pasada 6, el arreglo esta ordenado:
A: 10 12 14 27 38 47 95

Algoritmo de ordenación por inserción: mejorado
Insercion_binaria (n, X[ ])
Begin for i 1 to N-1 do
aux  X[i] El algoritmo de inserción se
P1 //primero
Ui-1 //ultimo mejora recurriendo al método de
while p <= u do búsqueda binaria (en lugar de
cent (p+u)div2 una búsqueda secuencial) para
if aux <= X[cent] then
ucent-1
encontrar más rápidamente el
else lugar de inserciones método es
pcent+1 conocido como inserción
end if
binaria.
end while
for k i-1 to p decremento 1 do
X[k+1] X[k] //desplazamiento
end for
X[p]aux//insercion
end for
End

Ordenación por Selección Directa
El algoritmo consiste en buscar el menor elemento
del array y colocarlo en la primera posición. Luego se
busca el segundo elemento más pequeño del arreglo y
se coloca en la segunda posición. El proceso continua
hasta que todos los elementos del arreglo estén
ordenados.
Pasos del algoritmo:

1. Seleccionar el menor elemento del arreglo.
2. Intercambiar dicho elemento con el primero.
3. Repetir los pasos anteriores con los (n-1), (n-2)
elementos y así sucesivamente hasta que solo quede
el elemento mayor.

Ejemplo: Sea el arreglo A: 27 14 95 38 12 10 47
Aplicar el algoritmo de Selección directa
Se asigna a menor el primer elemento

Primera pasada
Menor = A[0] = 27
Menor < A[1] ( 27 < 14 ) No, entonces Menor = A[1] = 14
Menor < A[2] ( 14 < 95 ) Si
Menor < A[3] ( 14 < 38 ) Si
Menor < A[6] ( 10 < 47 ) Si

Luego de la primera pasada, 10 que es el menor
elemento del arreglo se ubica en la primera posición.
A: 10 14 95 38 12 27 47
Segunda pasada
Menor = A[1] = 14
Menor < A[2] ( 14 < 95 ) Si
Menor < A[3] ( 14 < 38 ) Si
Menor < A[5] ( 12 < 27 ) Si
Menor < A[6] ( 12 < 47 ) Si

Luego de la segunda pasada, el segundo elemento más
pequeño del arreglo que es 12, queda en la segunda
posición del arreglo.
A: 10 12 95 38 14 27 47
Tercera pasada
Menor = A[2] = 95
Menor < A[5] ( 14 < 27 ) Si
Menor < A[6] ( 14 < 47 ) Si

Luego de la tercera pasada, el tercer elemento del
arreglo que es 14 queda en la tercera posición del
arreglo.
A: 10 12 14 38 95 27 47
Cuarta pasada
Menor = A[3] = 38
Menor < A[4] ( 38 < 95 ) Si
Menor < A[5] ( 38 < 27 ) No, Menor = A[5] = 27
Menor < A[6] ( 27 < 47 ) Si

Luego de la cuarta pasada, el cuarto elemento del
arreglo que es 27 queda en la cuarta posición del
arreglo.
A: 10 12 14 27 95 38 47
Quinta pasada
Menor = A[4] = 95
Menor < A[5] ( 95 < 38 ) No, Menor = A[5] = 38
Menor < A[6] ( 38 < 47 ) Si

Luego de la quinta pasada el arreglo queda como:
A: 10 12 14 27 38 95 47
Sexta pasada
Menor = A[5] = 95
Menor < A[6] ( 95 < 47 ) No, Menor = A[6] 95
Luego de la sexta pasada el arreglo queda como:
A: 10 12 14 27 38 47 95

Algoritmo básico para la selección directa.
Seleccion (n , X [ ])
for i 0 to n-1 do
menor  X[i] //selección inicial
k  i
for j  i+1 to n do //buscar en secuencia
if X[j] < menor then
menor  X [j] //selección
Kj
end for
X [k]  X[i]//intercambio
X [i]  menor
end for
End Seleccion

Código para la ordenación por selección directa
void Seleccion_Directa(int a[], int n)
{
int i, j, k;
for (i = 0; i<n; i++)
{
int menor = a[i]; //seleccion inicial
k = i;
for (j =i+1; j < n; j++) //busqueda en secuencia
{
if ( a[j] < menor )
{
menor = a[j]; //seleccion
k = j;
}
}
a[k] = a[i]; //intercambio
a[i] = menor;
}
}

Algoritmo de Ordenación por Shell
Creado por Donald Shell en 1959; es una mejora al algoritmo de inserción directa
y es muy eficaz especialmente cuando el número de elementos a ordenar
es bastante grande. A este método se le conoce también como algoritmo
de inserción con incrementos decrecientes. El método de Shell se basa
en fijar el tamaño de los saltos constantes en más de una posición.
Sea el array 4, 12, 16, 24, 36, 3. (“Tomado de la referencia Nro. 2”)
El método de inserción directa los saltos se hacen de una posición en una posición y
serán necesario cinco comparaciones. En el método de shell, si los saltos son de dos
posiciones, se realizan tres comparaciones.
Tomando como salto N/2 y luego reduciendo a la mitad en cada iteración

hasta que el salto sea 1.
Vector x [x[1], x[2], x[3], ......x[n]]
Vector x1 [x[1], x[1]+ salto, x[2]+salto, ......]
..
..
Vector xn [salto1, salto2, .....]

EJEMPLO:
Ejemplo sea el array : (“Tomado de la referencia Nro. 2”)
A: 6, 1, 5, 2, 3, 4, 0
Aplicando Shell se tiene.
Recorrido Salto Array Ordenado Intercambio
1 3 2, 1, 4, 0, 3, 5, 6 (6,0)(5,4)(6,2)
2 3 0, 1, 4, 2, 3, 5, 6 (2,0)
3 3 0, 1, 4, 2, 3, 5, 6 ninguno
4 1 0, 1, 2, 3, 4, 5, 6 (4,2)(4,3)
5 1 0, 1, 2, 3, 4, 5, 6 ORDENADO

Algoritmo de Shell
Shell (int n, X[ ])
salto  n div 2
while salto>0 do
for i  salto + 1 to n do
j  i- salto
while j>0 do
k  j + salto
if x[j] <= x[k] then
j  0
else
intercambiar( x[j], x[k] )
end if
j  j - salto
end while
end for
salto  salto div 2
end Shell

Código para la ordenación por Shell
void ShellSort( int a[], int n)
{ int i, salto, aux;
salto = n + 1; bool Flag;
while (salto > 0)
{ salto = salto/2; //division entera
Flag = true;
while (Flag == true)
{ Flag = false; i = 0;
while ((i + salto) < n)
{ if (a[i] > a[i + salto])
{ //intercambiar
aux = a[i];
a[i] = a[i + salto];
a[i + salto] = aux;
Flag = true;
} i = i + 1;
}
}
}
}

Peterson y Russel al inicio de los 1970 plantearon unas fórmulas que
mejoran la performance de Shellsort; una de ellas es hi+1 = 3 hi +1 con ht
= 1 y t = [log3n]-1; es decir la secuencia (1,4,13,40,...), también
propusieron otra secuencia (1,3,7,13,31,...2k -1) a esta última secuencia
se le denomina incrementos de Hibbard los cuales evitan múltiplos
de si mismo ya que los incrementos consecutivos no tienen factores
comunes.
Para la secuencia 1,3,7,13,31,...2k –1

se tiene que si n= 8
t = log223 –1
t = 3 – 1=2
De alli h2 = 1
h1 = 2 h2 + 1 = 3. Entonces h = {3, 1}
Idénticamente si n = 16, entonces h={7,3,1}

Ejemplo: Sea el arreglo A: 27 14 95 38 12 10 47 8 56 2
Utilizar el algoritmo de Shell para ordenarlo
Primera pasada
Salto = n div 2 = 10 div 2 = 5
10 8 2 27 95 12
A: 27 14 95 38 12 10 47 8 56 2
La primera pasada con Shell produce:
A: 10 14 8 38 2 27 47 95 56 12

Segunda pasada
Salto = 5 div 2 = 2
2
8 10 27 10 38 12 95
A: 10 14 8 38 2 27 47 95 56 12
La segunda pasada con Shell produce:

A: 8 14 2 27 10 38 47 12 56 95

Tercera pasada
Salto = 2 div 2 = 1; cuando el salto es de tamaño 1 el
algoritmo se convierte en el de la inserción directa.
A: 8 14 2 27 10 38 47 12 56 95
Luego de aplicar la inserción directa la ordenación

produce:
A: 2 8 10 12 14 27 38 47 56 95

Ordenación por QUICKSORT
El método de ordenación rápida o quicksort fue creado por C.A.
HOARE y es un método definitivamente más rápido que cualquiera
visto anteriormente. El método se basa en la estrategia “ Divide y
vencerás”, en el cual la lista o vector a ordenar se divide o parte en
dos subvectores: una con todos los valores menores o iguales que
cierto valor especifico (conocido como pivote)y otra con todos los
valores mayores que ese valor. el valor elegido puede ser cualquier
valor del vector.
X
X[1] X[2]
… X[i]
… X[n]
VI = X[1], . . . , X[i-1] y VD = X[i+1], . . .,X[n]

Donde los vectores VI y VD todavía no están ordenados, excepto en
el caso de reducirse a un elemento.

A:
A[0] A[n-1]
< pivote > pivote

pivote
El algoritmo puede expresarse como:

1. Se elige un elemento cualquiera del arreglo como
pivote.
2. Se recorre el arreglo desde el extremo izquierdo
buscando un valor mayor que el pivote.
3. Se recorre el arreglo desde el extremo derecho
buscando un elemento menor que el pivote.
4. Se intercambian los valores encontrados.
El proceso se repite hasta que todos los elementos a
la izquierda del pivote sean menores o iguales que
él y todos los elementos a su derecha sean mayores
que el pivote.

Ejemplo: Utilizar el algoritmo de quicksort para ordenar el arreglo A.
A: 27 16 95 14 12 10 47 8
Primera pasada
A: 27 16 95 14 12 10 47 8
• Se elige como pivote 14

• Se recorre el arreglo desde el extremo izquierdo y se
busca un elemento mayor que 14, se encuentra el 27.
• Se recorre el arreglo desde el extremo derecho y se
busca un elemento menor que 14, se encuentra 8.
• Se intercambian estos dos elementos obteniéndose
A: 8 16 95 14 12 10 47 27

Segunda pasada
A: 8 16 95 14 12 10 47 27
Nuevamente se recorre el arreglo desde la izquierda en

busca de un elemento mayor que 14, se encuentra el 16.
Ahora se recorre el arreglo desde la derecha en busca de
un elemento menor que 14, se encuentra 10.
Se intercambian ambos valores obteniéndose:
A: 8 10 95 14 12 16 47 27

Tercera pasada
A: 8 10 95 14 12 16 47 27
Se repite nuevamente el proceso encontrándose 95 y 12

intercambiándose ambos valores y se obtiene:
A: 8 10 12 14 95 16 47 27
El intento de un nuevo proceso no ubica ningún valor que este

“fuera de lugar”. Ahora se sabe que todos los valores a la
izquierda del pivote (14) son menores que el y todos los valores a
la derecha son mayores que el pivote; es decir se ha realizado una
partición en el arreglo original que ha quedado dividido en dos
vectores más pequeños.
El proceso de partición se aplica nuevamente a cada sub arreglo hasta
lograr la ordenación completa del arreglo.

El algoritmo inicial para partición
Partición_o_quicksort
{ elegir en X un valor arbitrario del vector: A[i]
while(división o partición no este terminada) do
Recorrer el vector de izquierdo a derecha para valores >=X[i]
Recorrer el vector de derecha a izquierda para valores <= X[i]
if (los valores encontrados no están ordenados) then
Intercambiar los dos valores
endif
end while
}

Refinamiento
El refinamiento al algoritmo es la elección del valor arbitrario A [i],asumiendo
que el valor central del vector es tan bueno como cualquier otro y haciendo que
los extremos sean L(de left) y R( de Rigth) y los índices i,j exploran desde los
extremos.
Partición_o_quicksort
Begin L=1; R=n
iL//extremo izquierdo
JR//extremo derecho
X  A[(L+R) div 2]//pivote
While i <= j do
While A[i] < X do
ii+1
End while
While A[j] > X do
jj-1
End while

Continuación:
if i <= j then
Intercambiar(A[i], A[j])
i  i+1
j  j-1
End if
End while
If L < j then
Partición_o_quicksort(L,j,a)
If i < R
Partición_o_quicksort(i,R,a)
End Partición_o_quicksort

Ejemplo 2:
Utilizar el algoritmo de quicksort para ordenar el arreglo A.
A: 27 14 95 38 12 10 47 8
Pivote = A[0] = 27
Primera pasada
Recorrido de derecha a izquierda
A[7] Pivote ( 8 >= 27 ) si hay intercambio
8 27
A: 27 14 95 38 12 10 47 8
0 1 2 3 4 5 6 7

Recorrido de izquierda a derecha
A[1] Pivote( 14 27 ) no hay intercambio
A[2] Pivote ( 95 27 ) si hay intercambio
27 95
A: 8 14 95 38 12 10 47 27
0 1 2 3 4 5 6 7

Segunda pasada
A[6] Pivote ( 47 27 ) no hay intercambio
10 27
A: 8 14 27 38 12 10 47 95
0 1 2 3 4 5 6 7

27 38
A: 8 14 10 38 12 27 47 95
0 1 2 3 4 5 6 7

Tercera pasada
A[4] Pivote (12 27 ) si hay intercambio
12 27
A: 8 14 10 27 12 38 47 95
0 1 2 3 4 5 6 7

Como el recorrido de izquierda a derecha debe empezar en la
misma posición donde se encuentra el elemento pivote, el
proceso de partición termina ya que el elemento pivote se
encuentra en la posición correcta.
A: 8 14 10 12 27 38 47 95
Sub arreglo Sub arreglo

izquierdo derecho

Note que los elementos del sub arreglo izquierdo son
todos menores o iguales que el pivote, y los elementos
del sub arreglo derecho son mayores o iguales que el
pivote. El proceso de partición se aplica nuevamente a
cada sub arreglo siempre y cuando este formado por dos
o más elementos.
La implementación del algoritmo se puede hacer de

manera recursiva o de manera iterativa. La implementa-
ción recursiva del algoritmo de quicksort, se presenta a
continuación.

Quicksort trabaja “in situ” y necesita(n log (n)) operaciones para
ordenar n elementos. El algoritmo básico es el siguiente:
void ordenRapido(tipodato a[], int izq, int der)

{ int i;
if( i < izq )
{ i = partición(a, izq, der)
ordenRapido(a, izq, i - 1)
ordenRapido(a, i + 1, der)
}
}
Donde el procedimiento de partición, reordena el arreglo para que

se verifiquen las siguientes condiciones:
1. El elemento a[i] esta en su lugar definitivo en el array para algun i.

2. Ninguno de los elementos de a[izq], ....a[i –1] son mayores que a[i]
3. Ninguno de los elementos de a[i+1],. ...a[der] son mayores que a[i]

Código para el ordenamiento por Quicksort:
void QuickSort(int left, int right, int a[])

{ int aux, x, i, j;
i = left; // extremo izquierdo
j = right; // extremo derecho
x = (a[left] + a[right]) / 2; // pivote
do { while ( a[i] < x)
i = i + 1;
while ( x < a[j])
j = j - 1;
if (i < j) // intercambiar
{ aux = a[i];
a[i] = a[j];
a[j] = aux;
i++; j--;
}

else
if (i == j)
i++;
} while(i <= j);
if (left < j)
QuickSort(left, j, a);
if (right > i)
QuickSort(i, right, a);
} // End QuickSort

Referencias:
1. Cairo O. Y Guardati S. “Estructura de datos” 2da.
Ed. Editorial McGrawHill. México 2002.
2. Joyanes Aguilar “Fundamentos de
Programación”, 4ta. Ed. Editorial McGraw Hill.
Madrid 2008.
3. Ruiz Lizama, Edgar “Programación con C++”
Fondo Editorial de la UNMSM. Perú 2009
4. Sedgewick “Algoritmos en C++” 1ra. Ed.
Addison Wesley Iberoamericana U.S.A. 1995.
ERL/2020

Ordenacioncpp 2020

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Ordenacioncpp 2020

Cargado por

Copyright:

Formatos disponibles

Universidad Nacional Mayor de San Marcos

Facultad de Ingeniería Industrial

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 1

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 2

1. Búsqueda interna.- Se realiza en memoria

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 3

1) Búsqueda Lineal o secuencial.- Consiste en buscar una clave

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 4

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 5

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 6

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 7

int search_bin_recursiva(int a[],int key,int izq,int

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 8

Se presentan los siguientes algoritmos de

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 9

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 10

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 11

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 12

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 13

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 14

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 15

Este algoritmo es usado por los jugadores de cartas cuando

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 16

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 17

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 18

Se asume que el primer elemento del arreglo ya esta

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 19

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 20

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 21

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 22

Al finalizar la pasada 6, el arreglo esta ordenado:

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 23

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 24

Pasos del algoritmo:

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 25

Aplicar el algoritmo de Selección directa

Se asigna a menor el primer elemento

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 26

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 27

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 28

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 29

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 30

Luego de la sexta pasada el arreglo queda como:

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 31

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 32

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 33

Tomando como salto N/2 y luego reduciendo a la mitad en cada iteración

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 34

Aplicando Shell se tiene.

Recorrido Salto Array Ordenado Intercambio

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 35

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 36

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 37

Para la secuencia 1,3,7,13,31,...2k –1

Idénticamente si n = 16, entonces h={7,3,1}

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 38

Utilizar el algoritmo de Shell para ordenarlo

La primera pasada con Shell produce:

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 39

La segunda pasada con Shell produce:

10/07/2022 Mg. Edgar Ruiz Lizama - eruizl@unmsm.edu.pe 40

Luego de aplicar la inserción directa la ordenación