Capittulos Del 1 Al 3 EDA

Algoritmos y Estructuras de Datos I
CAPITULO 1: ANLISIS DE ALGORITMOS

Un algoritmo es un conjunto de instrucciones claramente
especificadas que el ordenador debe seguir para resolver un
problema. Una vez que se ha dado un algoritmo para resolver un
problema y se ha probado que es correcto, el siguiente paso es
determinar la cantidad de recursos, tales como tiempo y espacio,
que el algoritmo requerir para su aplicacin. Este paso se llama
anlisis de algoritmos. Un algoritmo que necesita varios
gigabytes de memoria principalmente no es til en la mayora de
las maquinas actuales.
1.1 Complejidad de Algoritmos
Algoritmo: Instrucciones I
1
,I
2
,.,I
k
.
Complejidad de Tiempo: El tiempo que se demora en llevar a
cabo todas las instrucciones.
Complejidad de espacio: Espacio que requiere el algoritmo.
Tiempo: Tiempo de las instrucciones t
1
,t
2
,..,t
k
Frecuencia: Veces que se ejecuta la instruccin f
1
, f
2
,, f
k.
En general, para un algoritmo la complejidad se calcular
recorriendo todas las instrucciones, obteniendo la frecuencia de
ella.
=
=
k
i
i i T
t f C
1
1
Simplificacin: t
1
=t
2
=.t
k
=cte=1
pasos de Nro f C
k
i
T
= =
=1
Para un algoritmo
Entrada : Datos que se ingresan al algoritmo
Instancia: Valor particular de la entrada.
Paso: Instruccin simple
Instruccin simple: calculo de variables simples.
Ejemplo1: Suma de Matrices
Entrada: ( ) n m n m B A , , , M e
Salida: ( ) n m B A C M e + =
ij ij ij
b a c + =
Para i=1 hasta m hacer
Para j=1 hasta n hacer
ij ij ij
b a c + =
Fin Para
Fin Para
Complejidad de tiempo: m*n*t
1
Complejidad del peor caso: Tiempo necesario para la entrada
ms desfavorable siendo E
1
, E
2
,.,E
k
todas las posibles
entradas al algoritmo. ( ) | |
PC
k j
j
C E t =
s s 1
max
2
Complejidad del mejor caso: ( ) | |
k j
j MC
E t C
s s
=
1
min
Complejidad del Caso Medio: ( )
=
=
k
j
j j CM
E t p C
1
Ejemplo 2: Factorial
Entrada: n
Salida : n!
Si n=0 entonces
nfactorial =1
Caso contrario
aux =1
Para i=1 hasta n hacer
aux = aux * i
Fin Para
nfactorial = aux
Fin Si
Complejidad Peor Caso: C
PC
= n+4
Complejidad Mejor Caso: C
MC
=2
Complejidad Caso Medio:
( )
j
n
j
n
j
j j CM
p j p p t C + + = =

= = 1
0
0
3
n j
n
p
j
, , 1 , 0
1
1
=
+
=
3
( )
( ) ( ) n O
n
n
n
C
n
n n n
n n
C
n
j
n n
C
n
j
n n
C
CM
CM
n
j
CM
n
j
n
j
CM
~
2
3 1
1
1
1
3
2
1
1
1
1
1
1
1
3
1
1
1
1
3
1
1
1
1
1
1
1
1 1
+ +
+
=
+
+
+
+
+
+
=
+
+
+
+
+
=
+
+
+
+
+
=

=
= =
1.2 Notacin : Cota Superior de Funciones O
Sea
+
R R f : y
+
R N h : f es del orden de h ( ) si
constantes y tales que
( ) h f O ~
- 0 > c 0
0
> n ( ) ( )
0
n n n ch n f > s
A partir de un punto, h
siempre ser mayor que
f. Siempre la velocidad
de crecimiento de h es
mayor que f.
ch h
f
4
Ejemplos:
( )
( )
( )
( ) m n O m n
nm O nm
n O n n
n O n
n n
+ + +
+
O +
~ 10 4 3
~ 5
~
) ( ~ 5
~ 5 3
3 3
3 3
2 2
Propiedades
( ) ( ) ( )
( ) ( ) ( )
( ) ( ) ( )
( ) ( ) ( )
( ) ( ) h O h g O g h
g O f g O h h O f
f O f kO kf O cte k
g f O g O f O
g f O g O f O
= + >
= = >
=
+ = +
) 5
~ ~ , ~ ) 4
0 ) 3
) 2
) 1
Algoritmo Eficiente: Si su complejidad del peor caso es un
polinomio en la entrada.
C
pc
= O(p(entrada))
Ejemplo: Suma de Matrices ~ O(mn)
Es intratable si est acotado por una funcin de crecimiento ms
rpido que polinomial.
Jerarqua de rdenes de crecimiento
( ) ( ) ( ) ( ) ( ) ( ) ( ) etc O n O n O n n O n O n O O
n
... 2 log log 1
3 2
< < < < < <
5
1.3 Notacin : Cota Inferior de Funciones O
( ) h f O ~ si tales que N n c e -
0
, ( ) ( )
0
n n n ch n f > >
h
f
Lmite inferior de un problema es un valor tal que cualquier
algoritmo que resuelva ese problema, tendr una complejidad
mayor o igual a ese valor (L).
L C
C orit A tq L
>
O ~ lg
Dado un problema P con lmite inferior L, A un algoritmo que
resuelve P tal que ( ) ( ) L O A C
pc
~ entonces A es ptimo.
Aplicacin 1: Bsqueda
Problema: Dado un conjunto de n elementos { }
n
x x x S , , ,
2 1
= y
un elemento x. Determinar si x pertenece a S.
Algoritmo1: Bsqueda lineal
Entrada: n, S, x
Salida: SI, NO
6
Para j=1 hasta n hacer
Si x
j
=x entonces
Devolver SI, j
Fin Si
Fin Para
Devolver NO
Complejidad Mejor Caso
( )
2 ) (
1 ~
1
=
=
n T
O C
x x
MC
Complejidad Peor Caso
( ) n O C
S x o x x
PC
n
=
e =
Complejidad Caso Medio
Entradas
{ }
{ }
{ }
{ }
( ) ( )
( )
( )( )
qn
n q
C
qn
n n
n
q
C
qn j
n
q
qn j
n
q
C
E t E p C
S x q
S x q Sea
S x E
n j x x E
CM
CM
n
j
n
j
CM
n
j
j j CM
n
j j
+
+
=
+
+
=
+
= +
=
=
e =
e =
e
= =

= =
+
=
+
2
1 1
2
1 1
1 1
Pr 1
Pr
:
, , 1 :
1 1
1
1
1
7
Si q~0 , si se est seguro que el elemento que exista
2
n
C
CM
=
Si q~1, si es muy probable que el elemento no pertenezca
n C
CM
=
Si q~1/2 , es igual de probable que pertenezca y que no
pertenezca
4
3n
C
CM
=
1.4 Complejidad de Algoritmos Recursivos
Funcin Recursiva: Es una funcin f que se define en trminos
de ella misma.
Ejemplo 1: Factorial
Def.
n! = 1 si n=0
n!= 1*2*3*4*(n-1) * n, N e n
Prop: n!=n*(n-1)!
Algoritmo Recursivo: Es un procedimiento que se invoca a s
mismo, modificando sus argumentos.
Recursin: Mtodo de descomposicin de un problema en
subproblemas de la misma naturaleza que son ms simples de
resolver. La solucin del problema original se obtiene
combinando las soluciones de los subproblemas.
8
Ejemplo 1: Factorial Recursivo
Entrada: N n e
Salida: n!
Procedimiento FACTO(k)
Si k<=1 entonces
fact =1
Caso contrario
fact =k*FACTO(k-1)
Fin Si
Fin Procedimiento
Complejidades
Sea T(n)= tiempo en calcular n!
T(n) = T(n-1)+1
=[T(n-2)+1]+1= T(n-2)+2
=[T(n-3)+1]+2= T(n-3)+3
.
.
.
=T(n-i)+i si i=n-1
=T(1)+n-1
=1+n-1
=n
9
Dado que el algoritmo recursivo se invoca a s mismo, al expresar
el orden T(n) de su complejidad se obtiene una ecuacin de
recurrencia.
Reduccin por Sustraccin: Si el tamao n del problema decrece
en una cantidad constante b en cada llamada, se realizan a
llamadas recursivas y las operaciones correspondientes a la parte
no recursiva del algoritmo toman un tiempo O(n
k
) entonces:
( ) ( ) ( ) b n si n O b n aT n T
k
> + =
La solucin de esta ecuacin de recurrencia es de la forma:
( )
>
=
<
=
+
1
1
1
/
1
a si a
a si n
a si n
n T
b n
k
k
En factorial
T(n)=T(n-1)+1
Tenemos
a=1
b=1
k=0
O(n)=n
k+1
Reduccin por Divisin: Si el algoritmo con un problema de
tamao n realiza a llamadas recursivas con subproblemas de
tamao n/b y las operaciones correspondientes a la parte no
10
recursiva (que corresponde a descomponer el problema en los
subproblemas y luego combinar las soluciones de stos), toman
un tiempo O (n
k
) entonces:
( ) ( ) ( ) b n si n O b n aT n T
k
> + = /
La solucin de esta ecuacin de recurrencia es de la forma:
( )
>
=
<
=
k a
k k
k k
b a si n
b a si n n
b a si n
n T
b
log
log
Ejemplo:
T(n)=T(n/2)+1
a=1
b=2
k=0
T(n)~O(log n)
El algoritmo recursivo sirve si la descomposicin es eficiente, es
decir, cuando un subproblema ya se resolvi no se vuelve a
resolver.
11
Estructuras de Datos Marcela Muoz Claudio Henrquez

1
CAPITULO 2: TIPOS DE DATOS ABSTRACTOS

Definicin: Modelo matemtico con una coleccin de operadores definidos sobre
dichos modelos.

Beneficios de los TDA:

Encapsulamiento; define en un solo lugar todas las instrucciones relevantes a
ciertos aspectos del programa.
Desacoplamiento de la programacin; ya que los operadores estn predefinidos,
igual que los tipos de datos ms complejos.

Formalmente el TDA es una tripleta (D,F,A) con las siguientes componentes:

1. Un conjunto de dominios D.
2. Un conjunto de funciones sobre los dominios F.
3. Un conjunto de axiomas o propiedades definidas a partir de las funciones y
elementos de los dominios A.

2.1 Tipo de datos abstracto Lista

Las listas se componen de una coleccin de elementos organizados en secuencia que
pueden crecer y decrecer libremente y a cuyos elementos se puede acceder, insertar y
eliminar en cualquier posicin.

a
1
, a
2
, a
3
,., a
n
con n>=0

La principal propiedad de las listas se debe a su estructura lineal, los elementos pueden
ser linealmente ordenados de acuerdo con su respectiva posicin en la lista.

2.1.1 Definicin del TDA Lista

Se definirn a continuacin los dominios, las operaciones y axiomas que interesan para
manejar las listas.


2
Dominio

Se tiene los siguientes tipos de datos:
L: Lista de objetos del tipo elemento.
x: Objeto del tipo elemento.
p: Objeto de tipo posicin (depende de la implementacin, usualmente es un entero).

El conjunto de dominios es:
D={Lista, dato, num_nat}

Donde:
LLista.
x dato (tipo elemento).
p num_nat

Funciones

Se definen las siguientes funciones:
1. Insertar (x,p,L) => L : Insertar el elemento x en la posicin p de la lista L,
poniendo los elementos siguientes a continuacin.
2. Localizar (x,L)=>p : Entrega la posicin de x en la lista L.
3. Recuperar(p,L)=>x : Entrega el elemento que est en la posicin p en la lista L.
4. Eliminar(p,L)=>L: Elimina el elemento de la posicin p de la lista L.
5. Siguiente(p,L)=p y Anterior(p,L)=>p : Devuelve las posiciones siguientes y
anterior respectivamente a p de L.
6. Anular(L)=>L: Vaca la lista.
7. Primero(L)=>p: Entrega la primera posicin de L.
8. Fin(L)=>p: Entrega la posicin despus del ltimo elemento (n+1).

Axiomas

Algunos axiomas que se pueden mencionar son:
Localizar(x,Insertar(x,p,L))=if(xL) entonces retornar p
Recuperar(p,Insertar(x,p,L))=x
Recuperar(Fin(L),L)=error

3
Eliminar(Fin(L),L)=error
Anterior(Primero(L),L)=error

2.1.2 Implementaciones de las Listas

Existen 3 formas principales de implementar el tipo de dato abstracto lista: arreglos,
punteros y cursores.

a) Implementacin por arreglos

En este caso los elementos se almacenan en celdas contiguas de un arreglo. En la parte
no ocupada del arreglo se tiene espacio libre. Se define la constante longitud mxima,
que determina el tamao de la mayor lista que se procesa.

0

1

2

.

.

.
Ultimo-1 Ultimo elemento
ltimo Espacio Libre

Propiedades de la implementacin con arreglos:
Fcil de recorrer
Fcil de agregar y eliminar al final
Complicado insertar y eliminar al medio de la lista.
Tamao mximo prefijado.

Longitud Mxima

4
Declaraciones:
#define long_max 200
struct lista {
tipo_elemt elem[long_max];
int ultimo;
};

Para crear una lista se usa la siguiente funcin, que genera una lista inicialmente vaca:

struct lista *crear(){
struct lista * L=malloc(sizeof(struct lista));
Lultimo=0;
return L;
}

Ejemplo 1: Insertar un elemento x en la posicin p de la lista L

struct lista *insertar(tipo_elem x, int p, struct lista *L){
int q;
if(Lultimo >= long_max)
printf(Lista Llena);
else{
if(p<0 || p>ultimo+1)
printf(Posicin no existe);
else{
for(q=Lultimo;q>=p;q--)
Lelem[q]=Lelem[q-1];
Lultimo=Lultimo+1;
Lelem[p]=x;
}
}
return L;
}

Ejemplo 2: Eliminar el elemento que se encuentra en la posicin p de la lista L

struct lista* eliminar(int p, struct lista *L){
int q;
if(p<0 || p>Lultimo)
printf(Posicin No existe);
else{
Lultimo=Lultimo-1;
for(q=p,q<Lultimo,q++)
Lelem[q]=Lelem[q+1];
}
return L;
}


5
Ejemplo 3: Localizar el elemento x dentro de la lista L. Devolver -1 si no est.

int Localizar(tipo_elem x, struct lista *L){
int q;
for(q=0, q<Lultimo, q++)
if(Lelem[q]==x)
return q;
return (-1);
}

b) Implementacin por Punteros

En esta segunda implementacin se ocupan punteros para unir los elementos sucesivos
de la lista. Cada nodo de la lista, contiene un elemento de la lista (tipo_elem) y un
puntero al siguiente elemento.

Observaciones:
Nodo cabeza (header) no tiene dato y apunta al inicio de la lista.

Declaraciones
Las listas enlazadas estn basadas en la siguiente estructura de nodos:

struct nodo {
tipo_elem elem;
struct nodo *sgte;
};

Creacin de la Lista
Funcin que genera una lista inicialmente vaca, que tiene un solo nodo que corresponde
a la cabeza de la lista.

a
1
a
2
a
3
Cabeza
Puntero

6
struct nodo *crear(void){
struct nodo *L = (struct nodo *)malloc(sizeof(struct nodo));
Lsgte=Null;
return L;
}

Insertar
Funcin que inserta el elemento x, a continuacin del nodo apuntado por p.

void insertar(tipo_elem x, struct nodo *p){
struct nodo * temp;
temp = psgte;
p sgte= (struct nodo *)malloc(sizeof(struct nodo));
psgte elem=x;
psgte sgte=temp;
}

Eliminar
Funcin que elimina el elemento siguiente al apuntado por p.

void eliminar(struct nodo *p){
struct nodo *q;
q=psgte;
psgte=psgte sgte;
free(q) ;
}

Localizar

struct nodo *Localizar(tipo_elem x, struct nodo *L){
struct nodo *p=L;
while (p sgte!=Null){
if (psgte elem==x)
return p;
else
p=psgte; /*Avanza Puntero*/
}
}
a

b

c
H
p
q
a

b

c
H
P
x

7
Comparacin entre las implementaciones de arreglo y punteros
1. La implementacin por arreglos fija el tamao de la lista, por punteros el tamao es
dinmico.
2. En arreglos es difcil la insercin y eliminacin de un elemento al medio de la lista
O(n). Por punteros las operaciones de insertar y eliminar son de O(1).
3. El espacio real en arreglos es menor pero fijo. El espacio ocupado por punteros es
variable, pero ser mayor para lista de igual longitud.
4. Para punteros es complicado acceder al elemento anterior, si no hay doble enlace
hacia atrs O(n).

c) Implementacin por Cursores

Se utilizan 2 arreglos: uno de datos y uno de ndice del siguiente elemento de la lista.
Los arreglos pueden ser compartidos por ms de una lista y se posee una lista de
disponibles.

Declaraciones
struct nodo {
tipo_elem elem;
int sgte;
};
struct nodo cursor[MAX_LARGO];

A continuacin se implementan dos listas M y L adems de la lista disponible, en el
mismo arreglo.

M=1

1 d 7
2 4
3 c 0
4 6
L=5

5 a 8
6 0
7 e 0
8 b 3
Disponible=9

9 10
10 2

8

Luego, se tienen las listas
L={a,b,c} y M={d,e} Disponible= {9,10,2,4,6}

Ejemplo: Insertar el elemento x en la posicin p. El arreglo A contiene las listas.
Almacenar la siguiente posicin a p en una variable (q).
Busca la primera celda disponible para almacenar x.
Siguiente a p, se hace indicar a la posicin q.
Mover disponible a la posicin siguiente.

void Insertar(tipo_elem x, int p, struct nodo *A){
int q;
q=A[p].sgte;
if(Disponible!=0){
A[p].sgte=Disponible;
Disponible=A[Disponible].sgte;
A[A[p].sgte].elem=x;
A[A[p].sgte].sgte=q;
}
else
printf(No queda espacio disponible para la insercin);
}
En L se desea agregar x en la posicin 8.
q=3;

M=1

1 d 7
2 4
3 c 0
4 6
L=5

5 a 8
6 0
7 e 0
8 b 3-9
Disponible=9-10

9 x 10-3
10 2


9
2.2 Aplicaciones de Listas Enlazadas
2.2.1 Listas Circulares

Es una lista en la cual el ltimo nodo va enlazado al primero. De este modo se
aprovecha un puntero que sera nulo de otro modo.

Ejemplo: Funcin que encuentra el Largo de la lista.

int Largo (struct nodo *A){
struct nodo *ptr;
int i=0;
if(A!=NULL) {
ptr=A;
i=i+1;
ptr=ptr sgte;
while(ptr!=A){
i=i+1;
ptr=ptr sgte;
}
}
}
2.2.2 Listas Doblemente Enlazadas

a. Lista Lineal: Posee un puntero hacia la celda siguiente y otro a la celda anterior.

A pesar de que ocupan mayor cantidad de espacio, es eficiente cuando se necesita un
recorrido eficiente en ambos sentidos.

Declaraciones
struct nodo {
tipo_elem elem;
struct nodo *sgte, *ant;
};

Ejemplo: Funcin que elimina el nodo apuntado por p;
void Borrar(struct nodo *p){
if(pant!=NULL) pant sgte=psgte;
if(psgte!=NULL) psgte ant=pant;
free(p) ;
}
a
1
a
2
a
3
A
a
1
a
2
a
3
A

10
b. Lista Circular: En este caso se puede tener una cabeza para facilitar su manejo.

Eficiente para bsqueda de un nodo, se puede seguir el camino ms corto.
2.2.3 Listas Generalizadas

Una lista generalizada, A, es una secuencia finita de n elementos, c
1
, . . . , c
n
, donde cada
elemento es un tomo o un una lista. Si es una lista, se llama sublista de A.
Ejemplos: A = (a,(b,c)) B = (A,A,()) C = (a, C).
Supongamos una implementacin por punteros de modo que se tienen 3 campos:
Tag: (0:tomo, 1: sublista)
Data (Si Tag=0, Data es un dato que se almacena, y si Tag=1, entonces Data es
un puntero a la sublista).
Puntero al siguiente elemento de la lista.
Con esta representacin las listas del ejemplo quedan representadas como:

a
1
a
2
a
3

11
Otro ejemplo de listas generalizadas es la representacin de polinomios.


1
CAPITULO 3: Algoritmos de Ordenamiento

3.1. Ordenamiento Burbuja (Bubblesort)

Consiste en ciclar repetidamente a travs de la lista, comparando
elementos adyacentes de dos en dos. Si un elemento es mayor que
el que est en la siguiente posicin, se intercambian.

for (i=1; i<TAM; i++){
for(j=0; j<TAM-1; j++){
if(lista[j]>lista[j+1]){
temp=lista[j];
lista[j]=lista[j+1];
lista[j+1]=temp;
}
}
}
Ejemplo:
Se desea ordenar la siguiente lista:
4 3 5 2 1
0 1 2 3 4
TAM=5

Comenzamos comparando el primero con el segundo. 4 es
mayor que 3, as que se intercambia.

3 4 5 2 1
0 1 2 3 4


2
Luego se compara el segundo con el tercero, pero como 4 es
menor que 5, no se hace nada.

3 4 5 2 1
0 1 2 3 4

Se compara el tercero con el cuarto, y se intercambian.

3 4 2 5 1
0 1 2 3 4

Repitiendo este proceso, vamos obteniendo los siguientes
resultados.

3 4 2 1 5
0 1 2 3 4

3 2 4 1 5
0 1 2 3 4

3 2 1 4 5
0 1 2 3 4

2 3 1 4 5
0 1 2 3 4

2 1 3 4 5
0 1 2 3 4

1 2 3 4 5
0 1 2 3 4


3
Anlisis del Algoritmo

Tiempo de Ejecucin: O(n
2
)
Ventajas: es de fcil implementacin y no requiere memoria
adicional.
Desventajas: Muy lento, realiza numerosas comparaciones e
intercambios.

Mejoras
Si se observa, en cada pasada el elemento mayor va quedando
en la ltima posicin. De esta manera, se puede evitar hacer
comparaciones innecesarias disminuyendo el ciclo como:
for(j=0; j<TAM-i; j++)
Puede que los datos queden ordenados antes de completar el
ciclo externo. Se puede modificar el algoritmo para que
verifique si han existido intercambios, si no se han realizado,
se termina la ejecucin.

3.2. Ordenamiento por insercin

Este algoritmo realiza un ciclo en el cual se van seleccionando los
elementos de la lista uno a uno. Se desplazan todos los elementos
que sean mayores al elemento actual, y luego se almacena el
elemento en el lugar correspondiente.


4
for (i=1; i<TAM; i++){
temp=lista[i];
j=i-1;
while((lista[j]>temp) && (j>=0)){
lista[j+1]=lista[j];
j--;
}
lista[j+1]=temp;
}
Ejemplo:
Se desea ordenar la siguiente lista:
4 3 5 2 1
0 1 2 3 4
TAM=5

Luego temp=3, se compara 3 con el valor 4, como 4 es mayor
que temp, se realiza el cambio.
4 4 5 2 1
0 1 2 3 4

3 4 5 2 1
0 1 2 3 4

El siguiente elemento a comparar es 5, pero como el elemento
de su izquierda es menor, no se realiza ningn cambio.
Se contina con el elemento 2, y se compara con los elementos
que se encuentren a su izquierda. Como todos ellos son
mayores a 2, se desplazan a la derecha de 2.

5
3 4 5 5 1
0 1 2 3 4

3 4 4 5 1
0 1 2 3 4

3 3 4 5 1
0 1 2 3 4

2 3 4 5 1
0 1 2 3 4

Por ltimo, se compara el ltimo elemento que corresponde al
nmero 1. Todos los elementos a la izquierda de 1 son mayores
que l, por tanto son todos desplazados a la izquierda.

2 3 4 5 1
0 1 2 3 4

2 3 4 5 5
0 1 2 3 4

2 3 4 4 5
0 1 2 3 4

2 3 3 4 5
0 1 2 3 4

2 2 3 4 5
0 1 2 3 4
1 2 3 4 5
0 1 2 3 4


6

Tiempo de Ejecucin: Para una lista de n elementos, el ciclo
externo se ejecuta n-1 veces. El ciclo interno se ejecuta como
mximo una vez en la primera iteracin, 2 veces en la segunda, 3
veces en la tercera, etc.

Iteracin 1 2 3 n
Tiempo 3+4*1 3+4*2 3+4*3 3+4*n

( )
) ( ~ 2 3 2 2 3
2
1
4 3 4
2 2 2
1
n O n n n n n n
n n
i TE
n
i
+ = + - = +
-
= + =
=

Ventajas: Fcil implementacin, requerimientos de memoria
mnimos.
Desventajas: Lento, realiza numerosas comparaciones.
Algoritmo lento, pero puede ser de utilidad para listas que estn
ordenadas o semi ordenadas, por que en ese caso realiza pocos
desplazamientos.

7
3.3. Quicksort

Quicksort es el algoritmo de ordenamiento ms rpido conocido.
Su tiempo de ejecucin promedio es de O(n log n) y en su peor
caso es O(n
2
) pero es estadsticamente improbable.
El algoritmo Quicksort(L) es recursivo y consta de los siguientes
pasos:

1. Si el nmero de elementos de L es 0 o 1, terminar.
2. Escoger un elemento cualquiera v de L. Este elemento
se denominar pivote.
3. Hacer una particin de L {v} (el resto de elementos de
L) en dos grupos disjuntos: I = {x L {v} x v} y D =
{x L {v} x v}. De manera que queden todos los
elementos menores a un lado de v y todos los elementos
mayores al otro lado.
4. Devolver el resultado de Quicksort (I), seguido de v y
seguido del resultado de Quicksort(D).

A continuacin, se presenta el cdigo del algoritmo, el cual
selecciona como pivote el ltimo elemento de la lista, luego
recorre la lista simultneamente con i y j: por la izquierda con i y
por la derecha con j. Cuando la lista[i] sea mayor que el pivote y
la lista [j] sea menor, se intercambian. Se repite lo anterior hasta
que se crucen los ndices.

8
El punto en que se cruzan los ndices es la posicin adecuada para
colocar el pivote, as sabremos que hacia el lado izquierdo del
pivote todos los elementos sern menores a l, en cambio al lado
derecho todos los elementos sern mayores.

Parmetros:
Lista a ordenar: lista.
ndice Inferior: inf (elemento inferior de la lista)
ndice Superior: sup (elemento superior de la lista)

void Quicksort(lista, inf, sup){
//Inicializacin de variables
pivote=lista[sup];
i=inf-1;
j=sup;
cont=1;
//Verificar que no se crucen los lmites
if(inf>=sup)
return;
//Clasificamos la sublista
while(cont){
// Se avanza por la izquierda
while(lista[++i]<pivote);
//Se avanza por la derecha
while(lista[--j]>pivote);

9
if(i<j){ //Se intercambian
temp=lista[i];
lista[i]=lista[j];
lista[j]=temp;
}
else
cont=0;
}
//Copiamos el pivote en su posicin final
temp=lista[i];
lista[i]=lista[sup];
lista[sup]=temp;
//Aplicamos recursivamente a cada sublista
Quicksort(lista,inf,i-1);
Quicksort(lista,i+1,sup);
}

Ejemplo:
Se desea ordenar la siguiente lista. sup=6 y inf=0
5 3 7 6 2 1 4
0 1 2 3 4 5 6

El pivote ser el nmero 4, que se encuentra en la ltima
posicin.
Se compara 5 por la izquierda y 1 por la derecha, como 5 es
mayor que 4 y 1 es menor que 4, se intercambian.

10
1 3 7 6 2 5 4
0 1 2 3 4 5 6

Se avanza por la izquierda y por la derecha, como 3 es menor
que 4 y 2 es menor que 4, el elemento 3 se encuentra en el lado
que le corresponde, por tanto solo se avanza por la izquierda.
Ahora se compara 7 y 2, y se realiza el intercambio ya que 7 es
mayor que 4 y 2 es menor.
1 3 2 6 7 5 4
0 1 2 3 4 5 6

Se avanza por ambos lados. En este momento se termina el
ciclo principal, porque los ndices se cruzaron. Ahora se copia
el pivote en la separacin de ambos grupos.
1 3 2 4 5 7 6
0 1 2 3 4 5 6

Ahora se aplica recursivamente a la sublista de la izquierda
1 3 2
0 1 2

1 es menor que 2, y 3 es mayor que 2, por tanto slo se avanza
y no se intercambian.
Se avanza por izquierda y derecha, pero se cruzan los ndices,
as que se detiene y se copia el pivote.
1 2 3
0 1 2


11
Similarmente la sublista de la derecha queda ordenada.
5 7 6
4 5 6

5 6 7
4 5 6
Finalmente, al retornar la primera llamada se tiene el arreglo
ordenado.
1 2 3 4 5 6 7
0 1 2 3 4 5 6


Ventajas: Muy rpido, no requiere memoria adicional.
Desventajas: Implementacin un poco ms complicada,
Recursividad (utiliza muchos recursos), mucha diferencia entre el
mejor y peor caso.
Mejoras
Eleccin del pivote, a travs de un algoritmo. El mejor pivote
sera el que tenga el valor medio de la lista.
Realizar una versin Iterativa.
Cuando el largo de las sublista va disminuyendo, es mejor
llamar quizs a otro algoritmo que termine la labor. El
indicado, sera uno que se comporte bien con listas semi
ordenadas, por ejemplo, el algoritmo de ordenamiento por
insercin.

Capittulos Del 1 Al 3 EDA

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Capittulos Del 1 Al 3 EDA

Enviado por

Direitos autorais:

Formatos disponíveis

Algoritmos y Estructuras de Datos I

CAPITULO 1: ANLISIS DE ALGORITMOS

Você também pode gostar