2. ESTRUCTURA DE DATOS RONALD BARRERA L. ROLANDO QUIJIJE

3. El método de sacudida es una optimización del método de intercambio directo o burbuja . En este algoritmo cada pasada tiene dos etapas. En la primera etapa "de derecha a izquierda" se trasladan los elementos más pequeños hacia la parte izquierda del arreglo, almacenando en una variable la posición del último elemento intercambiado. Ordenamiento ESTATICO I método de sacudida (Shaker sort)

4. En la segunda etapa "de izquierda a derecha" se trasladan los elementos más grandes hacia la parte derecha del arreglo,almacenando en otra variable la posición del último elemento intercambiado. El algoritmo termina cuando en una etapa no se producen intercambios o bien,cuando el contenido de la variable que almacena el extremo izquierdo del arreglo es mayor que el contenido de la variable que almacena el extremo derecho.

5. void sacudida (itemType a[], int N){ int i, j, izq, der, aux; izq = 2; der = N; j = N; do { for(i = der; i >= izq; i--) if (a[i - 1] > a[i]) { swap (a, i, i -1); j = i; } izq= j + 1; for(i = izq; i <= der; i++) if (a[i -1] > a[i]) { swap (a, i, i -1) j = i; } der= j - 1; } while (izq <= der); } de sacudida (Shaker sort)

6. Ordenamiento ESTATICO II Ordenamiento por el El método Shell es una versión mejorada del método de inserción directa . Este método también se conoce con el nombre de inserción con incrementos decrecientes. En el método de ordenación por inserción directa cada elemento se compara para su ubicación correcta en el arreglo, con los elementos que se encuentran en la parte izquierda del mismo. Si el elemento a insertares más pequeño que el grupo de elementos que se encuentran a su izquierda,es necesario efectuar entonces varias comparaciones antes de su ubicación. método Shell

7. Shell propone que las comparaciones entre elementos se efectúen con saltos de mayor tamaño pero con incrementos decrecientes, así, los elementos quedarán ordenados en el arreglo más rápidamente. void shellsort (itemType a[], int N) { int i, j, h; itemType v; for (h = 1; h <= N/9; h = 3 * h + 1); for (i = h +1; i <= N; i += 1) { v = a[i]; j = i; while (j > h &&a[j- h] > v) { a[j]= a[j - h]; j -= h;} a[j] = v; } }

10. void quicksort (itemType a[], int left, int right) { int i; Stack<int> sf(50); for (;;) { while (right > left) { i = partition (a, left, right); if (i - left > right - i) { sf.push (left);sf.push (i - 1); left = i + 1; } else { sf.push (i + 1); sf.push (right); right = i - 1; } } if (sf.empty ()) break; right = sf.pop (); left = sf.pop (); } }

11. El ordenamiento por fusión consiste en combinar dos estructuras de datos ordenadas para crear una estructura ordenada de mayor tamaño. En muchas aplicaciones de procesamiento de información se almacena un archivo ordenado al que se le añaden nuevos elementos de manera regular. Normalmente se juntan cierta cantidad de entradas nuevas que posteriormente se agregan al archivo principal para proceder finalmente a reordenar todo el archivo. Este tipo de aplicaciones están especialmente hechas para fusión: Una estrategia mejor consiste en ordenar el conjunto de entradas nuevas y entonces fusionarlo con el archivo principal. Ordenamiento DINAMICO II por fusión (Mergesort)

12. Fusión Para comenzar, supongamos que contamos con dos arreglos de enteros ordenados a[1], ..., a[M] y b[1], ..., b[N] y deseamos fusionarlos en un tercer arreglo c[1], ..., c[M+N]. Entonces podemos utilizar el siguiente algoritmo: i = 1; j = 1; a[M+1] = itemMAX; b[N+1] = itemMAX; for (k = 1; k <= M + N; k++) c[k] = (a[i] < b[j]) ? a[i++] : b[j++];

13. Fusión con listas encadenadas Sería deseable contar con un método que ordenara las listas en sitio, en vez de utilizar espacio extra proporcional a el tamaño del archivo fusionado. Realizar esto es factible pero resulta muy complicado lograrlo con una estructura de datos de arreglo por lo que optaremos por una lista encadenada que se adapta mejor a las exigencias de este algoritmo. struct node {itemType key; struct node *next; }; struct node *z;

14. struct node *merge( struct node *a, struct node *b) { struct node *c; c = z; do if (a->key <= b->key) {c->next = a; c = a; a = a->next; } else {c->next = b; c = b; b = b->next; } while (c->key != z->key); c = z->next; z ->next = z; return c; } Se asume que las listas cuentan con un nodo cola centinela denominado z y que el elemento siguiente de este nodo apunta a sí mismo y el valor de su llave es igual a itemMAX;

15. Ordenamiento por fusión con listas struct node *mergesort( struct node *c) { struct node *a, *b; if (c->next != z) { a = c; b= c->next->next->next; while (b != z) {c = c->next; b = b->next->next;} b = c->next; c->next = z; return merge( mergesort (a), mergesort (b)); } return c; }

16. F I N