CARRERA: Software

NOMBRE: Deyvid Paucar

TEMA: Algoritmo de Ordenamiento externo y de búsqueda
FECHA: 22/04/2019
OBJETIVO: Comprender el algoritmo de ordenamiento externo y búsqueda

DESARROLLO
Algoritmo de Ordenamiento externo
Datos más grandes, guardados en dispositivos de memoria externa
Mezcla Directa
Partición con tamaño fijo y Fusión de secuencias ordenadas
1. void mezclar(int arreglo1[], int n1, int arreglo2[], int n2, int arreglo3[])
2. {
3. int x1=0, x2=0, x3=0;
4.
5. while (x1<n1 && x2<n2) {
6. if (arreglo1[x1]<arreglo2[x2]) {
7. arreglo3[x3] = arreglo1[x1];
8. x1++;
9. } else {
10. arreglo3[x3] = arreglo2[x2];
11. x2++;
12. }
13. x3++;
14. }
15. while (x1<n1) {
16. arreglo3[x3] = arreglo1[x1];
17. x1++;
18. x3++;
19. }
20. while (x2<n2) {
21. arreglo3[x3] = arreglo2[x2];
22. x2++;
23. x3++;
24. }
25. }
26.
27. void mezcla(int vector[], int n)
28. {
29. int *vector1, *vector2, n1, n2,x,y;
30. if (n>1)
31. {
32. if (n%2 == 0)
33. n1=n2=(int) n / 2;
34. else
35. {
36. n1=(int) n / 2;
37. n2=n1+1;
38. }
39. vector1=(int *) malloc(sizeof(int)*n1);
40. vector2=(int *) malloc(sizeof(int)*n2);
41. for(x=0;x<n1;x++)
42. vector1[x]=vector[x];
43. for(y=0;y<n2;x++,y++)
44. vector2[y]=vector[x];
45. mezcla(vector1, n1);
46. mezcla(vector2, n2);
47. mezclar(vector1, n1, vector2, n2, vector);
48. free(vector1);
49. free(vector2);
50. }
51. }
52.
53. int main(){
54. int i, vector[] = {2,3,5,7,2,6,1,5,8,3,2};
55.
56. mezcla(vector,12);
57.
58. for(i=0;i<12;i++)
59. printf("%i,\n", vector[i]);
60.
61. return 0;
62. }

Mezcla natural
Partición con máxima longitud y Fusión de secuencias alternadas

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void Mostrar(FILE *fich);

void Mezcla(FILE *fich);
void Separar(FILE *fich, FILE **aux);
int Mezclar(FILE *fich, FILE **aux);

int main()
{
FILE *fichero;

fichero = fopen("mezcla.txt", "r+");

puts("Fichero desordenado\n");
Mostrar(fichero);
puts("Ordenando fichero\n");
Mezcla(fichero);
puts("Fichero ordenado\n");
Mostrar(fichero);
fclose(fichero);
system("PAUSE");
return 0;
}

// Muestra el contenido del fichero "fich"

void Mostrar(FILE *fich)
{
char linea[128];

rewind(fich);
fgets(linea, 128, fich);
 while(!feof(fich)) {
puts(linea);
fgets(linea, 128, fich);
}
}

// Algoritmo de mezcla:
void Mezcla(FILE *fich)
{
int ordenado;
FILE *aux[2];

// Bucle que se repite hasta que el fichero esté ordenado:

do {
// Crea los dos ficheros auxiliares para separar los tramos:
aux[0] = fopen("aux1.txt", "w+");
aux[1] = fopen("aux2.txt", "w+");
rewind(fich);
Separar(fich, aux);
rewind(aux[0]);
rewind(aux[1]);
rewind(fich);
ordenado = Mezclar(fich, aux);
fclose(aux[0]);
fclose(aux[1]);
} while(!ordenado);
// Elimina los ficheros auxiliares:
remove("aux1.txt");
remove("aux2.txt");
}

// Separa los tramos ordenados alternando entre los ficheros

auxiliares:
void Separar(FILE *fich, FILE **aux)
{
char linea[128], anterior[2][128];
int salida = 0;

// Volores iniciales para los últimos valores

// almacenados en los ficheros auxiliares
strcpy(anterior[0], "");
strcpy(anterior[1], "");
// Captura la primero línea:
fgets(linea, 128, fich);
while(!feof(fich)) {
// Decide a qué fichero de salida corresponde la línea leída:
if(salida == 0 && strcmp(linea, anterior[0]) < 0) salida = 1;
else if(salida == 1 && strcmp(linea, anterior[1]) < 0) salida
= 0;
// Almacena la línea actual como la última añadida:
strcpy(anterior[salida], linea);
// Añade la línea al fichero auxiliar:
fputs(linea, aux[salida]);
// Lee la siguiente línea:
fgets(linea, 128, fich);
}
}

// Mezcla los ficheros auxiliares:

int Mezclar(FILE *fich, FILE **aux)
{
 char ultima[128], linea[2][128], anterior[2][128];
int entrada;
int tramos = 0;

// Lee la primera línea de cada fichero auxiliar:

fgets(linea[0], 128, aux[0]);
fgets(linea[1], 128, aux[1]);
// Valores iniciales;
strcpy(ultima, "");
strcpy(anterior[0], "");
strcpy(anterior[1], "");
// Bucle, mientras no se acabe ninguno de los ficheros
auxiliares (quedan tramos por mezclar):
while(!feof(aux[0]) && !feof(aux[1])) {
// Selecciona la línea que se añadirá:
if(strcmp(linea[0], linea[1]) <= 0) entrada = 0; else entrada
= 1;
// Almacena el valor como el último añadido:
strcpy(anterior[entrada], linea[entrada]);
// Añade la línea al fichero:
fputs(linea[entrada], fich);
// Lee la siguiente línea del fichero auxiliar:
fgets(linea[entrada], 128, aux[entrada]);
// Verificar fin de tramo, si es así copiar el resto del otro
tramo:
if(strcmp(anterior[entrada], linea[entrada]) > 0) {
if(!entrada) entrada = 1; else entrada = 0;
tramos++;
// Copia lo que queda del tramo actual al fichero de
salida:
do {
strcpy(anterior[entrada], linea[entrada]);
fputs(linea[entrada], fich);
fgets(linea[entrada], 128, aux[entrada]);
} while(!feof(aux[entrada]) && strcmp(anterior[entrada],
linea[entrada]) <= 0);
}
}

// Añadir tramos que queden sin mezclar:

if(!feof(aux[0])) tramos++;
while(!feof(aux[0])) {
fputs(linea[0], fich);
fgets(linea[0], 128, aux[0]);
}
if(!feof(aux[1])) tramos++;
while(!feof(aux[1])) {
fputs(linea[1], fich);
fgets(linea[1], 128, aux[1]);
}
return(tramos == 1);
}

Algoritmo de búsqueda
Busqueda secuencial
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define MAX_SIZE_VISIBLE 100
int main(int argc, char **argv)
{
int *a;
int size, n, i, j;
printf("Entre cuantos números queremos buscar? ");
scanf("%d", &size);
a = malloc(size * sizeof(int));
srand(time(NULL));
for(i=0;i<size;i++)
{
a[i]=rand()/1000;
}
if(size<MAX_SIZE_VISIBLE)
{
for(i=0;i<size;i++)
{
printf("%d: %d\n",i,a[i]);
}
}
printf("Que numero desea buscar ");
scanf("%d", &n);
j = 0;
for(i=0;i<size;i++)
{
if( a[i]==n )
{
printf("%d se encuentra en la posición %d\n",n,i);
j = 1;
return 0;
}
}
// Si no se encontró número al finalizar el ciclo no existe este número en el arreglo.
if(!j)
{
printf("No se encontro el número\n");
}
return 0;
}

BIBLIOGRAFIA
http://c.conclase.net/ficheros/?cap=005

https://pastebin.com/x75dtUvW

http://eenube.com/index.php/ldp/c/28-busqueda-secuencial-en-c-2