1. Qu son los tipos de datos?

Tipos de datos
Programacin en C/Tipos de datos

Primer programa en C

Tipos de datos

Contenido
[ocultar]

1 Historia 2 Enteros 3 Flotantes 4 Caracteres

Historia[editar]
En el lenguaje C estandarizado como C89, existan cuatro tipos de datos bsicos que son: los nmeros enteros, los nmeros reales, los caracteres, y los punteros. A partir del estndar C99 se agregan: los valores lgicos (verdadero o falso) y los nmeros complejos. Estos tipos de datos son parte del lenguaje, y por ello se los considera primitivos. Ms adelante veremos que con el uso de estructuras y uniones es posible crear tipos compuestos de datos a partir de estos tipos primitivos. En este captulo veremos los enteros, los reales y los caracteres. Ms adelante se vern otros tipos de datos ms complejos, como son los vectores, las cadenas de caracteres, y los punteros en general.

Enteros[editar]
Los enteros son el tipo de dato ms primitivo en C. Se usan para representar nmeros enteros. Pero siempre se pueden encontrar otras aplicaciones para los nmeros enteros. En general se pueden usar para representar cualquier variable discreta. Los tipos de datos enteros son: short, int, long y long long, cada uno representando un nmero entero de un tamao o capacidad determinado. Segn el compilador y la plataforma de hardware, cada uno de estos tipos de dato puede ocupar desde 1 byte hasta 8 bytes en memoria (para ms detalles busca en la referencia).

Adems, el lenguaje C hace la distincin de si el entero es con signo (signed) o sin signo (unsigned). En caso de que no se declare si es con signo o sin signo, se toma con signo. Algunos ejemplos de declaraciones de enteros: int a; unsigned int a; signed long a; signed long long a = 10000000; Todos los nmeros son representados en memoria mediante una cadena de bits. En el caso de los nmeros con signo, el bit ms significativo es el que se usa para representar el signo. La representacin de los nmeros negativos se realiza mediante el complemento a dos, que es una tcnica que permite operar con los nmeros negativos de forma lgica. A modo de ejemplo, la representacin en memoria del nmero -8 en una variable de 2 bytes, entera, con signo, sera la siguiente:

1111111111111000

Flotantes[editar]
Se denomina flotantes a los tipos de datos que representan a los nmeros reales, ya que utilizan un sistema de representacin basado en la tcnica de coma flotante, que permite operar con nmeros reales de diversas magnitudes, mediante un nmero decimal llamado mantisa y un exponente que indica el orden de magnitud. El tipo de dato flotante en lenguaje C slo tiene dos tamaos: el float y el double, que son 4 bytes y 8 bytes respectivamente. Se los puede utilizar tanto para representar nmeros decimales, como para representar nmeros enteros con un orden de magnitud muy grande. La forma de declarar una variable flotante es escribiendo en una lnea uno de los tipos de datos flotantes y a continuacin el nombre de la variable y tal vez algn valor que se les quiera dar. Algunos ejemplos: float a; double a = 1e23; double a = 3.1416; float a = 4e-9; double a = -78; Hay que tener en cuenta que aunque los valores flotantes son ms convenientes para algunas aplicaciones, hay casos en los que se prefieren los enteros. Esto se debe a que los nmeros flotantes

no necesariamente tienen soporte de hardware, en particular en las plataformas integradas. Una alternativa que se utiliza en estas situaciones es interpretar los enteros como decimales de forma que 150 se interprete como 1.5 y 2345 como 23.45. Para el caso de los flotantes de 4 bytes, se utiliza 1 bit para el signo, 8 bits para el exponente y 23 bits para el valor del nmero. El procedimiento para almacenar un nmero en una variable flotante es el siguiente: 1. Se convierte a binario la parte entera. 2. Se coloca el signo en el bit ms significativo de la misma manera que en los enteros (1 para el y 0 para el +). 3. Se mueve la coma (en la representacin binaria de la parte entera) hasta que est a la derecha del primer uno y ste se descarta (el uno ms significativo). El valor del exponente ser el nmero de posiciones que se movi la coma. El exponente usa la representacin de un entero con complemento a dos. 4. Se convierte en binario la parte decimal del nmero. Esto usando el peso de los bits. el bit decimal ms significativo vale 1/2, el siguiente vale 1/4, el otro 1/8, el otro 1/16 y as hasta completar lo que falta para los 23bits del valor. 5. Se concatena todo y ese es el valor flotante representado en memoria.

Caracteres[editar]
Los caracteres se representan utilizando el tipo char, que tiene slo 1 byte de tamao. Este tipo se utiliza para representar los 256 caracteres de la tabla de caracteres del sistema. El tipo char es tambin un tipo entero, ya que puede tomar valores de 0 a 255. Por lo tanto tambin puede ser signed o unsigned. En cuanto a la forma de declarar variables de tipo char es la misma forma que con los otros tipos. char a; char a = 's'; unsigned char a = 48; Como puedes ver, se le puede asignar un nmero a una variable char, ya que se trata de un tipo entero. En muchas situaciones se utiliza el tipo char para almacenar nmeros pequeos, ya que ocupa en memoria slamente un byte. Es importante notar que con la llegada de la codificacin UTF-8, los caracteres de los diversos idiomas pueden ocupar 1, 2, 3 o 4 bytes, de modo que el tipo char ya no alcanza para la representacin de todos los caracteres posibles. Por ello, el estndar C99 introduce el tipo wchar que puede ocupar ms de 1 byte, segn sea necesario para la codificacin utilizada por el sistema.

2. Qu son las estructuras de datos?

clase-i-estructura-de-datos-1194357531161281-3

3. Cules son los tipos de datos utilizados en los lenguajes de programacin

clase08

4. Qu es el mtodo de ordenacin en un vecto

3.1 Algoritmos de Ordenamiento Lineal
Por ordenar se entiende el proceso de reorganizar un conjunto de objetos en una cierta secuencia de acuerdo a un criterio especificado. En general, el objetivo de este proceso es facilitar la posterior bsqueda de elementos en el conjunto ordenado. Existen mltiples ejemplos reales de conjuntos que requieren ser ordenados: la gua telefnica, ndices de libros, ficheros de bibliotecas, diccionarios, ficheros de diverso tipo en oficinas , actas de exmenes, etc. A continuacin se describen algunos de los algoritmos de ordenacin lineal ms conocidos.

3.1.1 BubleSort
La idea de este mtodo es ir tomando los elementos de a dos e ir comparndolos e intercambindolos de ser necesario, hasta que todos los elementos sean comparados. for { for { if(V[i]>V[j]) { aux V[i] V[j] } } } = = = V[i]; V[j]; aux; (i=0; (j=i+1; i<n-1; j<n; i++) j++)

El bucle externo establece un desplazamiento secuencial dentrodel vector desde el primer elemento hasta el penltimo , el bucle interno realiza un recorrido del vector desde el elemento i+1 hasta el ltimo elemento del vector y va reduciendo en cada iteracin del bucle externo el nmero de elementos a comparar, ya que los elementos anteriores ya debieron ordenarse en las iteraciones anteriores. Ahora bien, lo que se quiere es ordenar todos los valores , para lo cual se compara el elemento i con los subsiguientes elementos del vector e intercambindolo cuando sea mayor que alguno de los elementos ubicado en alguna posicin inferior del vector, en este intrecambio es que se genera la burbuja, donde los elementos ms pequeos van subiendo y los ms grandes se van ubicando en las posiciones inferiores del vector. Ejemplo 9 3.1. 7 Supongamos 6 que 5 un 4 paso del vector de 3 10 elementos 11 tiene 8 estos 10 valores: 2 mtodo. manera:

A continuacin se describe Representando cada estado

por paso la evolucin del vector de la siguiente

i,j->V[0]V[1]V[2]V[3]V[4]V[5]V[6]V[7]V[8]V[9] 0,1->7 0,2->6 0,3->5 0,4->4 0,5->3 0,6->3 0,7->3 0,8->3 0,9->2 1,2->2 1,3->2 1,4->2 1,5->2 1,6->2 1,7->2 1,8->2 1,9->2 2,3->2 2,4->2 2,5->2 2,6->2 2,7->2 2,8->2 2,9->2 3,4->2 3,5->2 3,6->2 3,7->2 3,8->2 3,9->2 4,5->2 4,6->2 4,7->2 4,8->2 4,9->2 5,6->2 9 9 9 9 9 9 9 9 9 7 6 5 4 4 4 4 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 6 7 7 7 7 7 7 7 7 9 9 9 9 9 9 9 9 7 6 5 5 5 5 4 4 4 4 4 4 4 4 4 4 4 4 4 5 5 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 9 9 9 9 9 9 9 7 6 6 6 6 5 5 5 5 5 5 5 4 4 4 5 5 5 5 5 5 5 5 6 6 6 6 6 6 6 7 7 7 7 7 7 9 9 9 9 9 9 7 7 7 7 6 6 3 3 3 3 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 6 6 6 6 6 6 7 7 7 7 7 9 9 9 9 9 9 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 5 5 5 5 5 5 6 6 6 6 6 7 7

5,7->2 3 5,8->2 3 5,9->2 3 6,7->2 3 6,8->2 3 6,9->2 3 7,8->2 3 7,9->2 3 8,9->2 3 4 5 6 7 8

4 4 4 4 4 4 4 4 9 10 11

5 5 5 5 5 5 5 5

6 6 6 6 6 6 6 6

8 8 7 7 7 7 7 7

11 11 11 9 9 8 8 8

9 9 9 11 11 11 10 9

10 10 10 10 10 10 11 11

7 7 8 8 8 9 9 10

La evolucin del mtodo muestra que cada elemento del vector desde el primer elemento hasta el penltimo se van comparando con los subsiguientes (no con los anteriores), ya que los elementos se han comparado en las iteraciones anteriores La falencia de este mtodo es que como s o s va a hacer n - 1 pasadas, muchas veces puede hacer pasadas inclusive con el vector ya ordenado. Por lo tanto, una mejora para este mtodo consiste en establecer un mecanismo para que verifique cuando el vector este ya ordenado. Si queremos ordenar el vector descendente cambiamos el signo en la condicin del SI por V[i]< V[j]. Anlisis del algoritmo. Estabilidad: Este algoritmo nunca intercambia registros con claves iguales. Por lo tanto es estable. Requerimientos de Memoria: Este algoritmo slo requiere de una variable adicional para realizar los intercambios sin importar qu tan grande sea el vector. Requerimiento constante. Tiempo de Ejecucin: El ciclo interno se ejecuta (n-1)*n/2 veces para una lista de n elementos. El ciclo externo se ejecuta n veces. Es decir, la complejidad es n * n = O(n2). El comportamiento del caso promedio depende del orden de entrada de los datos, pero es slo un poco mejor que el del peor caso, y sigue siendo O(n2). Ventajas A) Fcil implementacin B) No requiere memoria adicional. C) Realiza numerosos intercambios. Desventajas A) Muy lento B) Realiza numerosas comparaciones

Este algoritmo es uno de los ms pobres en rendimiento. No es recomendable usarlo. Tan slo est aqu para que sea conocido, y porque su sencillez lo hace bueno para empezar.

3.1.2 SelectionSort
Entre los mtodos elementales de ordenacin de vectores se encuentra el algoritmo de seleccin: for { (i=0; i<n; i++)

imin=i; for { if(V[j]<V[imin]) imin=j; } aux V[i] V[imin] }

(j=i+1;

j<n;

j++)

= = =

V[i]; V[imin]; aux;

Es decir, el mtodo se basa en buscar en cada iteraccin el mnimo elemento del subvector situado entre el ndice i y el final del vector e intercambiarlo con el de ndice i. Tomando la dimensin del vector n como tamao del problema es inmediato que el bucle se repite n veces y por tanto la funcin que da el nmero de repeticiones es de tipo lineal (O(n)). La operacin interior al bucle se puede desarrollar a su vez como: imin:=i; para j desde si V[j]<V[imin] fpara intercambiar(V[i],V[imin])

i+1 entonces

hasta

n imin:=j

hacer fsi

Se trata de una secuencia de tres operaciones, la segunda de las cuales es, a su vez, una iteracin. La primera (asignacin) y la tercera(intercambio) pueden considerarse de coste constante. La segunda es un bucle que internamente incluye una operacin condicional que en el peor caso supone una operacin de coste constante (O(1)) (en el peor caso y en el mejor, puesto que la comparacin se ha de realizar siempre ) y el nmero de repeticiones de esa operacin es de tipo lineal, ya que se realiza n-(i+1) veces, y por tanto, al crecer n, el nmero de veces crece proporcionalmente a n. Luego ser de costeO(n) O(1) = O(n). ste ser entonces el coste de la secuencia completa (sucesin de dos operaciones de coste constante y una de coste lineal) El algoritmo total ser entonces de ordenO(n).O(n) =O(n^2) Es interesante observar que en este algoritmo el contenido de los datos de entrada, no influye en el coste del algoritmo. En efecto se puede comprobar (aplicar el algoritmo sobre varios vectores ejemplo), que se ejecutan de forma completa ambos bucles tanto para vector desordenado como para vector ordenado. Ejemplo 3.2. Supongamos que un vector de 10 elementos tiene estos valores: 9 7 6 5 4 3 11 8 10 2 A continuacin se describe paso por paso la evolucin Representando cada estado del vector de la siguiente manera: del mtodo.

V[i]<->V[imin] =>V[0]V[1]V[2]V[3]V[4]V[5]V[6]V[7]V[8]V[9], igualmente se muestran cada uno de los cambios de la variable imin. imin imin imin imin -> -> -> -> 1 2 3 4

imin imin V[0]<->V[9]=>2 imin imin imin imin V[1]<->V[5]=>2 imin -> 3 imin V[2]<->V[4]=>2 V[3]<->V[3]=>2 V[4]<->V[4]=>2 V[5]<->V[5]=>2 imin V[6]<->V[7]=>2 imin imin V[7]<->V[9]=>2 V[8]<->V[8]=>2 V[9]<->V[9]=>2 3 4 Anlisis del algoritmo.

-> -> 4 -> -> -> -> 4

5 9 3 11 8 10 9 2 3 4 5 7 11 8 10 9

3 3 3 3 3

4 4 4 4 4

5 5 5 5 5

3 4 5 3 4 5 5 6 7 8 9 10 11

-> 6 6 6 6 -> 6 -> -> 6 6

7 7 7 7 7 7 7

11 11 11 11 8 8 8

8 8 8 8 11 9 9

10 10 10 10 10 10 10

4 9 9 9 9 7 9 8 9 11 11

Estabilidad: No es estable. Intercambia registros con claves iguales. Requerimientos de Memoria: Este algoritmo slo requiere de una variable adicional para realizar los intercambios sin importar qu tan grande sea el vector. Requerimiento constante. Tiempo de Ejecucin: El ciclo externo se ejecuta n veces para una lista de n elementos. Cada bsqueda requiere comparar todos los elementos no clasificados. Luego la complejidad es O(n2). Este algoritmo presenta un comportamiento constante independiente del orden de los datos. Luego la complejidad promedio es tambin O(n2).

Ventajas Desventajas A) Fcil implementacin A) Lento B) No requiere memoria adicional. B) Realiza numerosas comparaciones. C) Realiza pocos intercambios. C) Este es un algoritmo lento D) Rendimiento constante: poca diferencia entre el peor y el mejor caso No obstante, ya que slo realiza un intercambio en cada ejecucin del ciclo externo, puede ser una buena opcin para listas con registros grandes y claves pequeas.

3.1.3 InsertionSort
En este procedimiento se recurre a una bsqueda binaria en lugar de una bsqueda secuencial para insertar un elemento en la parte de arriba del arreglo, que ya se encuentra ordenado. El proceso, al igual que en el mtodo de insercin directa, se repite desde el segundo hasta el n-simo elemento.

for(i=1; temp Izq Der while(Izq Medio if Der else Izq } for V[j+1]=V[j]; } V[Izq] }

i<n; = = = <= = (temp = = (j=i-1; = < Medio Medio

i++)

+ j>=Izq;

{ V[i]; 0; i-1; Der){ (Izq+Der)/2; V[Medio]) 1; 1; j--){ temp;

Ejemplo 3.3. Supongamos que un vector de 10 elementos tiene estos valores: 9 7 6 5 4 3 11 8 10 2 A continuacin se describe paso por paso la evolucin Representando cada estado del vector de la siguiente manera: del mtodo.

i->V[0]V[1]V[2]V[3]V[4]V[5]V[6]V[7]V[8]V[9] 1->7 9 6 5 4 3 2->6 7 9 5 4 3 3->5 6 7 9 4 3 4->4 5 6 7 9 3 5->3 4 5 6 7 9 6->3 4 5 6 7 9 7->3 4 5 6 7 8 8->3 4 5 6 7 8 9->2 3 4 5 6 7 8 9 10 11 Anlisis del algoritmo.

11 11 11 11 11 11 9 9

8 8 8 8 8 8 11 10

10 10 10 10 10 10 10 11

2 2 2 2 2 2 2 2

Estabilidad: Este algoritmo nunca intercambia registros con claves iguales. Por lo tanto es estable. Requerimientos de Memoria: Este algoritmo slo requiere de una variable adicional para realizar los intercambios sin importar qu tan grande sea el vector. Requerimiento constante. Tiempo de Ejecucin: Al analizar el mtodo de ordenacin por insercin binaria se advierte la presencia de un caso antinatural. El mtodo efecta el menor nmero de comparaciones cuando el arreglo est totalmente desordenado y el mximo cuando est ordenado.

Es posible suponer que mientras en una bsqueda secuencial se necesitan k comparaciones para insertar un elemento, en una bsqueda binaria se necesitar la mitad de las k comparaciones. Por lo tanto, el nmero de comparaciones promedio en el mtodo de ordenacin por Insercin Binaria puede calcularse como : C= (1/2) + (2/2) + (3/2) + . . . + ((n-1)/2) = ((n(n-1))/4) = ((n2 n) / 4)

ste es un algoritmo de comportamiento antinatural y por lo tanto es necesario ser muy cuidadoso cuando se hace un anlisis de l. Las mejoras producen un efecto negativo cuando el arreglo est ordenado y produce resultados apenas satisfactorios cuando las claves (temp y V[Medio]) estn desordenadas. De todas maneras debe recordarse que no se reduce el nmero de movimientos que es una operacin ms complicada y costosa que la operacin de comparacin. Por lo tanto, el tiempo de ejecucin del algoritmo sigue siendo proporcional a n2. Ventajas A) Fcil implementacin B) No requiere memoria adicional. Desventajas A) Lento. B) En promedio hace numerosas comparaciones.

3.1.4 ShellSort
Denominado as por su desarrollador Donald Shell (1959), ordena una estructura de una manera similar a la del Bubble Sort, sin embargo no ordena elementos adyacentes sino que utiliza una segmentacin entre los datos. Esta segmentacin puede ser de cualquier tamao de acuerdo a una secuencia de valores que empiezan con un valor grande (pero menor al tamao total de la estructura) y van disminuyendo hasta llegar al '1'. Este mtodo funciona de la siguiente manera: Ordena subgrupos de elementos separados K unidades (respecto de su posicin en el arreglo) del arreglo original. El valor K es llamado incremento. Despus de que los primeros K subgrupos han sido ordenados, se escoge un nuevo valor de K ms pequeo, y el arreglo es de nuevo partido entre el nuevo conjunto de subgrupos. Cada uno de los subgrupos mayores es ordenado y el proceso se repite de nuevo con un valor ms pequeo de K. Eventualmente el valor de K llega a ser 1, de tal manera que el subgrupo consiste de todo el arreglo ya casi ordenado. Al principio del proceso se escoge la secuencia de decrecimiento de incrementos; el ltimo valor debe ser 1. "Es como hacer un ordenamiento de burbuja pero comparando e intercambiando elementos." Cuando el incremento toma un valor de 1, todos los elementos pasan a formar parte del subgrupo y se aplica insercin directa. El mtodo se basa en tomar como salto N/2 (siendo N el nmero de elementos) y luego se va reduciendo a la mitad en cada repeticin hasta que el salto o distancia vale 1.

Algoritmo: void { int while { { shellSort(int (h for int int for (j { a[j] (i B = i; (j = j >= a[j] h) && (a[j a[j = h-1; = = - h] = > B); j a[], > i<n; int h) i; 0) i++) a[i]; i; -= h) h];} B;

} h } } Ejemplo 3.4 Para el arreglo a = [6, 1, 5, 2, 3, 4, 0] tenemos el siguiente recorrido: Recorrido Salto Lista 1 3 2,1,4,0,3,5,6 2 3 0,1,4,2,3,5,6 3 4 5 3 1 1 0,1,4,2,3,5,6 0,1,2,3,4,5,6 0,1,2,3,4,5,6 Intercambios (6,2), (5,4), (6,0) (2,0) Ninguno (cuando no hay intercambios se procede a cambiar el valor de K o Salto) (4,2), (4,3) Ninguno = h / 2;

Anlisis del algoritmo. Estabilidad: Este algoritmo se considera estable. Requerimientos de Memoria: Una variable adicional para realizar los intercambios. Y una variable para el salto. Requerimiento constante. Tiempo de Ejecucin: Los estudios realizados indican que su complejidad es de O(n^1.2) en el mejor caso y de O(n^1.25) en el caso promedio.

3.2 Algoritmos de ordenamiento Recursivo

Dentro de los algoritmos de ordenamiento recursivo se encuentran los mtodos de MergeSort (Ordenacin por mezclas sucesivas) y QuickSort (Ordenamiento Rpido).

3.2.1 MergeSort
El algoritmo Merge divide el arreglo original en dos arreglos y los coloca en arreglos separados. Cada arreglo es recursivamente ordenado y finalmente se unen los arreglos en un arreglo ordenado. Como cualquiera de los algoritmos de ordenamiento recursivo el algoritmo Merge tiene complejidad de O(n log n). Fue desarrollado por John Von Neumann. Algoritmo void ordenarMezcla(TipoEle A[], int izq, int { if ( izq < der { centro = ( izq + der ) % ordenarMezcla( A, izq, centro ordenarMezcla( A, centro+1, intercalar( A, izq, centro, der } } void intercalar(TipoEle A[], int a, int c, int { k = i = j = c + n = b while ( i < c + 1 ) && ( j < b + { if ( A[i] < A[j] der) ) 2; ); der); ); b ) 0; a; 1; a; ) )

{ i } else { j k }; while { i++; k++; }; while { j++; k++; }; i for { i++; }; }; = ( =

B[k] i B[k] = k i B[k] < c = j

= + = + + + 1

A[i]; 1; A[j]; 1; } 1; ) A[i];

j B[k]

<

b =

) A[j];

= ( k = A[i] 0; k < = n; i++

a; ) B[k];

Este mtodo aplica la tcnica divide-y-vencers, dividiendo la secuencia de datos en dos subsecuencias hasta que las subsecuencias tengan un nico elemento, luego se ordenan mezclando dos subsecuencias ordenadas en una secuencia ordenada, en forma sucesiva hasta obtener una secuencia nica ya ordenada. Si n = 1 solo hay un elemento por ordenar, sino se hace una ordenacin de mezcla de la primera mitad del arreglo con la segunda mitad. Las dos mitades se ordenan de igual forma. Ejemplo: Se tiene un arreglo de 8 elementos, se ordenan los 4 elementos de cada arreglo y luego se mezclan. El arreglo de 4 elementos, se ordenan los 2 elementos de cada arreglo y luego se mezclan. El arreglo de 2 elementos, como cada arreglo slo tiene n = 1 elemento, solo se mezclan. Ejemplo 3.5 Esquema procedimiento Algoritmo MergeSort

Anlisis del algoritmo. Estabilidad: S es estable. Requerimientos de Memoria: Se necesita memoria auxiliar del mismo tamao de los conjuntos a mezclar. Tiempo de Ejecucin: O(n log n). Ventajas A) Rpido B) Especial para datos atmicos o registros con pocos componentes Desventajas A) Implementacin compleja. B) Grandes Requerimientos de Memoria

3.2.2 QuickSort
La ordenacion rapida, inventada y nombrada por C.A.R. Hoare en 1960, esta considerada como el mejor algoritmo de ordenacion disponible actualmente. Esta basada en la ordenacion por el metodo de intercambio. La ordenacion rpida se basa en la idea de las particiones. El procedimiento general es seleccionar un valor llamado COMPARANDO y entonces dividir el array en dos partes. En un lado todos los elementos mayores o iguales al valor de particion y en otro todos los elementos menores que el valor. Este proceso se repite en cada parte restante hasta que el array est ordenado.

Como se puede ver, este proceso es esencialmente recursivo por naturaleza y, de hecho, las implementaciones mas claras de la ordenacion rapida es por algoritmos recursivos. La seleccion del valor comparado se puede obtener de dos formas. Se puede seleccionar aleatoriamente o haciendo la media de un pequeno conjunto de valores tomados del array. Para una ordenacion optima es mejor seleccionar un valor que este precisamente en medio del rango de valores. Sin embargo, esto no es facil de hacer en la mayoria de los conjuntos de datos. En el caso peor, el valor escogido esta en un extremo. Incluso en este, la ordenacion rapida todavia funciona bien. La version de la ordenacion rapida que sigue selecciona el elemento mitad del array. Aunque no siempre sera una buena eleccion, la ordenacion sigue funcionando correctamente. Ejemplo 3.6 Ordenamiento por QuickSort Secuencia inicial 8 2 5 3 Elemento comparando: Primer paso 3 2 5 8 Ahora se ordena con el mismo procedimiento los vectores '3 2' y '8 9' Algoritmo: void ordenar (int vect[], int ind_izq, int ind_der) { int i, j; /* variables indice del vector */ int elem; /* contiene un elemento del vector */ i = ind_izq; j = ind_der; elem = vect[(ind_izq+ind_der)/2]; do {while (vect[i] < elem) //recorrido del vector hacia la derecha i++; while (elem < vect[j]) // recorrido del vector hacia la izquierda j--; if (i <= j) /* intercambiar */ { int aux; /* variable auxiliar */ aux = vect[i]; vect[i] = vect[j]; vect[j] = aux; i++; j--; } } while (i <= j); if (ind_izq < j) {ordenar (vect, ind_izq, j);} //Llamadas recursivas if (i < ind_der) {ordenar (vect, i, ind_der);} } Anlisis del algoritmo. Estabilidad: No es estable. Requerimientos de Memoria: No requiere memoria adicional en su forma recursiva. Tiempo de Ejecucin: o Caso promedio. La complejidad para dividir una lista de n es O(n). Cada sublista genera en promedio dos sublistas ms de largo n/2. Por lo tanto la complejidad se define en forma recurrente como: f(1) = 1 9 5 9

f(n) = n + 2 f(n/2) La forma cerrada de esta expresin es: f(n) = n log 2n Es decir, la complejidad es O(n log2n). El peor caso ocurre cuando la lista ya est ordenada, porque cada llamada genera slo una sublista (todos los elementos son menores que el elemento 2 de divisin). En este caso el rendimiento se degrada a O(n ). Con las optimizaciones mencionadas arriba puede evitarse este comportamiento.

Ventajas A) Generalmente es el ms rpido B) No requiere memoria adicional

Desventajas A) Implementacin un poco ms complicada B) Mucha diferencia entre el peor (n2) y el mejor caso (log n) C) Intercambia registros iguales

RESUMEN. Tabla comparativa de algoritmos Complejidad Estabilidad 2 O(n ) SI 2 O(n ) NO 2 O(n ) SI 2 O(n ) SI 1.25 O(n ) SI O(n * log(n)) NO O(n * log(n)) SI

Nombre Burbuja Seleccin Insercin Insercin Binaria Shell Rpido (Quicksort) Merge

Memoria adicional NO NO NO NO NO NO SI

Eligiendo el ms adecuado. No existe EL ALGORITMO de ordenamiento. Slo existe el mejor para cada caso particular. Debe conocerse a fondo el problema a resolver, y aplicar el ms adecuado. Aunque hay algunas preguntas que pueden ayudar a elegir: Qu grado de orden tendr la informacin que va a manejar? Si la informacin va a estar casi ordenada y no desea complicarse, un algoritmo sencillo como el ordenamiento burbuja ser suficiente. Si por el contrario los datos van a estar muy desordenados, un algoritmo poderoso como Quicksort puede ser el ms indicado. Y si no puede hacer una presuncin sobre el grado de orden de la informacin, lo mejor ser elegir un algoritmo que se comporte de manera similar en cualquiera de estos dos casos extremos. Qu cantidad de datos va a manipular? Si la cantidad es pequea, no es necesario utilizar un algoritmo complejo, y es preferible uno de fcil implementacin. Una cantidad muy grande puede hacer prohibitivo utilizar un algoritmo que requiera de mucha memoria adicional. Qu tipo de datos quiere ordenar? Algunos algoritmos slo funcionan con un tipo especfico de datos (enteros, enteros positivos, etc.) y otros son generales, es decir, aplicables a cualquier tipo de dato.

Qu tamao tienen los registros de la lista? Algunos algoritmos realizan mltiples intercambios (burbuja, insercin). Si los registros son de gran tamao estos intercambios son ms lentos. El contenido de esta pgina esta basado en el material disponible en: http://allhost.cl/datos/ http://www.fing.edu.uy/inco/cursos/prog1/teorico/