LISTAS ENLAZADAS

NOTA:ANTES DE ESTUDIRA VERLO EN PSEUDOCODIGO E INTEnTAR RELACIONARLO CON JAVA

1.DECLARACIN DE LA ESTRUCTURA DE DATOS

struct elemento{
tipo_dato dato;
struct elemento *sgt;
};
typedef struct elemento nodo;
nodo * L
/*Cabeza de la lista*/

2.CREAR LISTA
void crearLista (nodo *cabeza)
{
cabeza=null;
}
/*Llamada desde el main() */
crearLista(L);

3.INSERTAR POR LA CABEZA

void insertarCabeza(nodo **cabeza, tipo_dato dato)
{
nodo *aux;
aux=(nodo*) malloc(sizeof(nodo));
aux->dato=dato;
*cabeza=aux;
}
/*Llamada desde el main*/
insertarCabeza(&L,dato);

4.INSERCCIN EN ORDEN POR DELANTE

void insertarOrdenDelante (nodo** cabeza, tipo_dato entrada)
{
nodo* aux;
/*donde guardate el dato*/
nodo* sucesor;
/*nodo que sigue a auxiliar*/
nodo* predecesor;
/*antecede a auxiliar*/
int encontrado;
/*Si es cierto 1 , si es falso 0 */
if(*cabeza == NULL || entrada<(*cabeza)-->dato)
{
insertarCabeza(&L, entrada);
}
else
{
aux=(nodo*) malloc (sizeof (nodo));
aux -->dato= entrada;
predecesor=*cabeza;
sucesor=(*cabeza)-->sgt;
encontrado=0;
while((sucesor!=NULL) && encontrado==0)
{
if( entrada>sucesor-->dato)
{
predecesor=sucesor;
sucesor=sucesor-->sgt;
}
else
{
encontrado=1;
}
}
/*inserta el nuevo nodo*/
aux-->sgt=aux;
}
}
/*Llamada desde el main*/
insertrOrdenDelante(&L, entrada);
Nota:Si el dato es una cadena de caracteres el algoritmo debe modificarse.
(Escribir el cdigo)

5.INSERCCIN EN ORDEN POR DETRAS.

void insertarOrdenDetras(nodo **cabeza, tipo_dato entrada)
{
int encontrado=0;
nodo *sucesor;
nodo *predecesor;
nodo *aux;
if(*cabeza==NULL || entrada<(*cabeza)-->dato)
{
aux=(nodo*)malloc(sizeof(nodo));
predecesor=*cabeza;
sucesor=(*cabeza)-->sgt;
encontrado=0;
while((sucesor != NULL) && (encotrado==0)
{
if(entrada<sucesor-->dato)
{
predecesor=sucesor;
sucesor=sucesor-->sgte;
}
else
{
aux=sucesor;
sucesor-->sgt=aux;
sucesor-->dato=entrada;
encontrado=1;
}
}
if(encontrado==0)
{
aux-->dato=entrada;
aux-->sgt=NULL;
predecesor-->sgt=aux;
}
}
}

6.INSERTAR UN NODO EN UNA POSICIN DETERMINADA

void insertar (nodo **cabeza, tipo_dato entrada, int p)

{
nodo *predecesor;
nodo *sucesor;
nodo *aux;
int cont;
if(p==1) /*inserto en la primera posicin*/
{
aux=(nodo*) malloc(sizeof(nodo));
aux-->dato=entrada;
aux-->sgt=*cabeza;
*cabeza=aux;
}
else /*localizar la posicin 'p' de inserccin*/
{
predecesor=NULL;
sucesor=(*cabeza);
cont=1;
while ( ( sucesor !=NULL) && (cont !=p) )
{
predecesor=sucesor;
sucesor=sucesor-->sig;
cont++;
}
/*'p' es menor que el nmero de elementos apuntado por 'cabeza'*/
if ( p<cont+1)
{
aux=(nodo*)malloc(sizeof(nodo))
aux-->dato=entrada;
predecesor-->sgt=aux;
if ( ( sucesor==NULL ) || ( ( sucesor==*cabeza ) && (cont==p-1) )
{
/*inserto el dato en la ltima posicin*/
aux-->sgt=NULL;
}
else if (cont == p) /*inserto en la posicion intermedia*/
{
aux-->sgt=sucesor;
}
}
}
}
7.MOSTRAR LISTA

void mostrarLista (nodo *cabeza)

{
nodo *aux;
aux=cabeza;
while (aux != NULL)
{
printf (%s%d,dato:,aux-->dato);
printf (\n);
aux=aux-->sgt;
}
}
/*Llamada desde el main () */
mostrarLista(&L);

f(f(

8.MOSTRAR LISTA RECORRIDA EN ORDEN CONTRARIO

void mostrarListaContrario(nodo *cabeza)

{
if(cabeza!=NULL)
{
mostrarListaContrario(cabeza);
printf(%d,cabeza-->dato);
printf(\n);
else
{
printf(%s,lista vacia\n);
}
}

9.BUSQUEDA EN LISTAS ENLAZADA

El algoritmo devolvera un puntero al elemento buscado.Se declarara un puntero, indice, que recorre la lista nodo a nodo.Cuando lo
encuentre devolvera un puntero al nodo, sino retornara null.
nodo* localizar(nodo *cabeza, tipo_dado entrada)
{
nodo* indice;
for(indice=null;indice!=NULL;indice=indice-->sgt)
if(entrada==indice-->dato)
return (indice);
return (NULL);
}
10.ELIMINACIN DE UN NODO DE UNA LISTA
Debemos enlazar el nodo anterior con el nodo siguiente al que deseamos enlazar y liberar la memoria.
void eliminar(nodo **cabeza,tipo_dato entrada)
{
nodo* actual;
nodo* anterior;
int encontrado=0;
actual=*cabeza;
anterior=NULL;
/*busqueda del nodo y del anterior*/
while(actual != NULL) && (! encontrado)
{
encontrado=(actual-->dato==entrada)
if(!encontrado)
{
anterior=actual;
actual=actual-->sgt;
}
}
/*enlace del nodo anterior con siguiente*/
if(actual !=NULL)
{
if(actual==*cabeza)
*cabeza=actual-->sgt;
else
anterior> sgt = actual > sgt;
free(actual);
}
}

LISTAS DOBLEMENTE ENLAZADAS

Cuando deseamos acceder a los nodos de una lista en cualquier orden empleamos listas enlazadas.Las operaciones bsicas son:
1.
2.
3.
4.
5.
6.
7.

Declaracin de los tipos nodo y puntero a nodo.

Inicializacin o creacin
Insertar elementos en una lista.
Eliminar elementos de una lista.
Buscar elementos de una lista.
Recorrer una lista enlazadas.
Comprobar si la lista esta vacia.

1.DECLARACIN DE UNA LISTA ENLAZADA

struct elemento
{
tipo_dato dato;
struct elemento* sgt;
struct elemento* ant;
};
typedef struct elemento nodo;
2.INICIALIZACIN O CREACIN

nodo* crearNodo(tipo_dado entrada)

{
nodo* aux;
aux=(nodo*)malloc(sizeof(nodo));
/*asigno al nodo 'a' su valor*/
aux--> sgt=NULL;
aux--> atras=NULL;
return aux;
}
3.INSERTAR UN ELEMENTO.

Podemos insertar en la cabeza de la lista o al final de la lista.

a) Insertar en la cabeza
void insertarCabeza (nodo **cabeza, tipo_dato entrada)
{
nodo *nuevo;
nuevo=crearNodo(entrada);
nuevo-->adelante=*cabeza;
nuevo-->atras=NULL;
if (*cabeza != NULL)
(*cabeza)-->atras=nuevo;
*cabeza=nuevo;
}
b) Insertar al final
void insertar ( nodo** cabeza, tipo_dato entrada, nodo* cabeza)
{
nodo *nuevo;
if ((*cabeza)==NULL || anterior ==NULL)
insertarCabeza(&cabeza,entrada);
else
{
nuevo=crearNodo(entrada);
nuevo-->adelante=anterior-->adelante;
if ( anterior-->adelante ! =NULL)
anterior-->adelante-->atras= nuevo;
anterior -->adelante=nuevo;
nuevo -->atras=anterior;
}
}

4.ELIMINAR UN ELEMENTO DE LA LISTA DOBLEMENTE ENLAZADA

void eliminar (nodo ** cabeza, tipo_dato entrada)
{
nodo *actual;
int encontrado=0;
actual=*cabeza;
/*busqueda del nodo*/
while (( actual !=NULL) && (!encontrado))
{
encontrado=(actual -->dato ==entrada);
if(!encontrado)
{
actual=actual-->sgt;
}
}
if(actual == *cabeza)
{
*cabeza=actual -->sgt;
if(actual-->adelante !=NULL)
{
actual-->sgt-->atras=NULL;
}
}
else if ( actual-->sgt != NULL)
{
actual -->atras-->adelante=actual-->adelante;
actual -->adelante-->atras=actual-->atras;
}
else
{
actual -->atras-->adelante =NULL;
}
free(actual);
}

LISTAS CIRCULARES
1.DECLARACIN DE UN NODO
typedef tipo_dato Dato;
struct elemento
{
Dato dato;
struct elemento *sgt;
};
typedef struct elemento Nodo;

2.CREAR UN NODO

Nodo* crearNodo(Dato entrada)

{
Nodo* a;
a=(Nodo*)malloc(sizeof(Nodo));
a-->dato=entrada;
a-->sgt=a;
return a;
}

3.INSERTAR UN NODO
void insertarCircular (Nodo ** lc,tipo_dato entrada)
{
Nodo * nuevo;
nuevo=crearNodo(entrada)
if (*cabeza != NULL)
{
nuevo-->sgt=(*cabeza)-->sgt
(*cabeza)-->sgt=nuevo;
}
*cabeza=nuevo;
}

4.ELIMINAR UN NODO DE UNA LISTA CIRCULAR

void eliminar(Nodo **cabeza, tipo_dato entrada)

{
Nodo *actual;
int encontrado=0;
if ((*cabeza==NULL) return;
actual=*cabeza;
while ((actual>sgt != *cabeza ) && ( ! encontrado))
{
encontrado=(actual -->sgt-->dato==entrada);
if( !encontrado)
{
actual=actual -->sgt;
}
encontrado=(actual-->sgt-->dato==entrada);
if (encontrado)
{
Nodo *p;
p=actual-->sgt;
if(*cabeza ==(*cabeza)-->sgt)
*cabeza=NULL;
else
{
if ( p==*cabeza)
{
*cabeza=actual;
}
actual-->sgt=p-->sgt;
free(p);
}
}
}
}
}

5.OTRAS OPERACIONES
5.1.Buscar
5.2.Mostrar
5.1.Buscar

Nodo *buscar ( Nodo *cabeza, tipo_dato entrada)

{
Nodo *actual;
int encontrado=0;
if ( cabeza == NULL) return NULL;
actual=cabeza-->sgt;
do
{
encontrado = IGUAL( actual dato,entrada);
if (! encontrado)
{
actual=actual -->sgt;
}
}while ( ( actual != cabeza sgt ) && ( !encontrado) )
if(encontrado)
return actual;
else
return NULL;
}
}

5.2.MOSTRAR LISTA

void mostrarLista ( nodo *cabeza)

{
Nodo *p;
int k=0;
if(cabeza != NULL)
{
/*escribir datos */
p=cabeza -->sgt;
do
{
k ++;
<escribir datos>
if ( k% 7 == 0)
{
puts ( );
}
p=p sgt;
}while (p ! = cabeza -->sgt);
}
else
printf(lista vacia);
}

PILAS
Podemos implementarlas con;
A ) ARRAYS
B )LISTAS ENLAZADAS
A ) ARRAYS
Las operaciones que definimos en una pila para manipular su contenido son:
1.
2.
3.
4.
5.
6.
7.

CrearPila.Inicia la pila como PILA VACIA

Insertar (PUSH). Pone un dato en la pila
Quitar (POP). Retira un dato de la pila
PilaLlena.Comprueba que esta llena.
LimpiarPila. Quita todos los elementos de la pila y la deja como PILA VACIA
Cima. Obtiene el elemento cima de la pila
TamaoPila.Proporciona el nmero de elementos de la pila.

1.DECLARACIN DE LA PILA

#define TAMPILA numero_elementos;

struct elementos
{
tipo_dato listaPila[TAMPILA];
int cima;
}
typedef struct elementos Pila;

2.PONER UN ELEMENTO EN LA CIMA DE LA PILA

void insertar (pila *pila, tipoDato elemento)

{
/*Si la pila esta llena termina el programa*/
if(pilaLlena(*pila))
{
puts(Desbordamiento pila);
exit(1);
}
pila-->cima++;
pila-->listaPila[pila-->cima]=elemento;
}

3.QUITAR UN ELEMENTO DE LA PILA

tipoDato quitar (pila *pila)
{
tipoDato elemento;
/*Si la pila esta vacia termina el programa*/
if(pilaVacia(*pila)
{
puts(Se intenta sacar un elemento en pila vacia);
exit(1);
}
elemento=pila-->listaPila[pila-->cima];
pila-->cima - - ;
return elemento;
}

4.CIMA
Devuelve el elemento que se encuentra en la cima
tipoDato cima (Pila pila)
{
if(pilaVacia(pila))
{
puts(Error de ejecucin, pila vacia);
exit(1);
}
return pila.listaPila[pila.cima];
}

5.PILA VACIA
int pila Vacia(pila pila)
{
return pila.cima==1;
}
6.PILA LLENA.
int pilaLlena(pila pila)
{
return pila.cima==-1;
}

7.LIMPIAR PILA
void limpiarPila(pila *pila)
{
pila-->cima=-1;
}

8.CREAR PILA
void crearPila(pila *pila)
{
pila-->cima=-1;
}
B )LISTAS ENLAZADAS
1.
2.
3.
4.
5.
6.

Las operaciones a implementar son:

Creacin de una pila vacia
Verificar el estado de la pila.
Insertar un elemento en la pila.
Eliminacin del elemento cima.
Obtencin y eliminacin del elemento cima.
Vaciado de la pila.

0.DECLARACIN DE LA PILA
struct elemento
{
tipoDato dato;
struct elemento *sig;
}
typedef struct elemento nodo;

1.CREACIN DE UNA PILA VACIA

void crearPila(nodo **pila)
{
*pila=NULL;
}
2.PILA VACIA
int pilaVacia(nodo *pila)
{
return pila==NULL;
}
3.INSERTAR UN ELEMENTO EN UNA PILA
void insertar(nodo **pila, tipoDato entrada)
{
nodo *aux;
aux=(nodo*)malloc(sizeof(nodo));
aux-->dato=entrada;
aux-->sig=aux;
}

4.ELIMINACIN DEL ELEMENTO CIMA

void suprimir(nodo** pila)
{
if(!pilaVacia(*pila))
{
nodo* aux;
aux=*pila;
(*pila)=(*pila)-->sig;
free(aux);
}
}

5.QUITAR
tipoDato quitar(nodo **pila)
{
tipoDato salida;
salida=cima(*pila);
suprimir(pila);
return salida;
}

6.VACIADO DE LA PILA
void limpiarPila(nodo **pila)
{
while(!pilaVacia(*pila));
{
suprimir(pila);
}
}

7.CIMA
tipoDato cima(nodo* pila)
{
if(pilaVacia(pila))
{
puts(Error de ejecucin, pila vacia);
exit(1);
}
return pila-->dato;
}

COLAS
Tipos de implementaciones
A) Implementacin con Arrays
B) Implementacion con Arrays circulares
A) Implementacin con Arrays
Se implementaran las siguientes funciones y estructuras
1. Declaracin de la cola
2. Creacin de una cola vacia
3. Insertar un elemento
4. Quitar un elemento
5. Comprobar si la cola esta vacia
6. Comprobar si la cola esta llena.
7. Devolver el primer elemento de la cola.
1.DECLARACIN DE LA COLA
#define MAXTAMQ <nmero de elementos>
struct elemento
{
tipoDato listaCola[MAXTAMQ];
int frente,final;
};
typedef struct elemento cola;
2.CREAR COLA
void crearCola (cola* cola)
{
cola-->frente=0;
cola-->final=-1;
}
3.INSERTAR
void insertar (cola* cola, tipoDato dato)
{
if(colaLlena(*cola))
{
puts(Desbordamiento. Cola llena);
exit(1);
}
cola-->final ++;
cola-->listaCola[cola-->final]=dato;
}

4. QUITAR
tipoDato quitar (cola* cola)
{
tipoDato dato;
if(colaVacia(*cola))
{
puts(Se intenta sacar un elemento de una cola vacia);
exit(1);
}
dato=cola-->listaCola[cola-->frente];
cola-->frente ++;
return dato;
}

5.COLA VACIA
int colaVacia (Cola cola)
{
return cola.final<cola.frente;
}
6.COLA LLENA
int colaLlena (Cola cola)
{
return cola.final==MAXTAMQ -1;
}

7.FRENTE
tipoDato frente (Cola cola)
{
if( colaVacia (cola))
{
puts (Error de ejecucion, cola vacia);
exits (1);
}
return cola.listaCola[cola.frente];
}

B ) IMPLEMENTACIN CON ARRAYS CIRCULARES.

- La representacin de los elementos se hace igual que con un array lineal.
1) Calculo del indice del siguiente elemento.
int siguiente (int n)
{
return (n+1) % MAXTAM;
}
2 ) Crea una cola.
void crearCola (cola *cola)
{
cola ---> frente =0;
cola ---> final=MAXTAMQ-1;
}
3 ) Insertar
void insertar (Cola *cola, tipoDato dato)
{
if(colaLlena(*cola)(
{
puts(desbordamiento cola);
exit(1);
}
/*Avance circular al siguiente al ltimo*/
cola --> final=siguiente (cola --> final);
cola --> listaCola[cola---->final]=dato;
}
4 ) Quitar un elemento de la cola.final
tipoDato quitar (Cola *cola)
{
if(colaVacia(*cola))
{
puts (Extraccion en la cola vacia);
exits(1);
}
dato=cola--->listaCola[cola--->frente];
/*Avanza circularmente*/
cola--->frente=siguiente(cola---->frente);
return dato;
}
5 ) Cola vacia
int colaVacia(Cola cola)
{
return cola.frente==siguiente(cola.frente)
}
6 ) Cola llena
int colaLlena (Cola cola)
{
return cola.frente == siguiente (siguente(cola.final));
}

FICHEROS EN C
1.TIPOS DE FICHEROS.

Secuenciales:Solo pueden leerse y escribirse empezando desde el principio.

- Caractericticas.
i) La escritura es por el final
ii) Para leer una zona concreta que est antes hay que rebobinar.

- Son siempre secuenciales los siguientes archivos:

stdin:Suele ser el teclado.Siempre son de lectura

stdout:Por pantalla, slo escritura
stderr:Por pantalla, slo escritura.
stdaux:Puerto serie.Puede ser de lectura y Escritura.

Aleatorios: Las operaciones de lectura escritura pueden hacerse en cualquier

punto del archivo.

- Se sugieren las siguientes normas.

i. Abrirlo en modo R/W
ii. Abrirlo en modo Binario
iii. Usar fread, fwrite.
iv. Usar fseek para situar el puntero.
-Se defien los datos en forma de registros.Despues de cada L/E el cursor se actualiza
automticamente a la siguiente posicin, por ello conviene hacer siempre un fread o un
fwrite

2.OPERACIONES PARA TRATAR CON ARCHIVOS

1.ABRIR ARCHIVOS
FILE *fp;
if((fp=fopen(nomre y ruta,modo))==NULL){
printf(Error al intentar abrir el archivo);
exit(1);
}

Los modos son:

1) r ----> Abrir para slo lectura
2) w ---> Abrir para slo escritura
3) a ----> Abrir para aadir datos
4) r-----> Abrir para lectura y escritura (el fichero ya existia)
5) w---->Abrir para lectura y escritura (el archivo ya existia)
6) a+---->Abrir para lectura y aadir
Al modo se le puede aadir
1) t ----> Son archivos de texto
2) b----> Son archivos de binarios.
2.CERRAR EL ARCHIVO
fclose (ptr);

3.PROCESAMIENTO DE ARCHIVOS
while (!feof(ptr))
{
//codigo
}
fclose(ptr);

4.ACCESO DIRECTO A ARCHIVOS

fseek(fichero,posicion,origen);

los valores de 'origen' son:

1) SEEK_SET ----------> 0 (principio del archivo)
2) SEEK_CUR ---------> 1 (posicion actual)
3) SEEK_END ---------> 2 (final de fichero)

5. FUNCIONES PARA TRATAR CON CARACTERES Y CADENA.

A) Trabajos con caracteres
Se emplean las funciones : getchar(), putchar(), getc(), putc()
1. getchar() y putchar()
i ) getchar()
car=getchar(); Lee un carcter dado por teclados
No suele emplearse como funcin interactiva.Se prefiere usar :getc() y getche().
ii) putchar(carcter)
Devuelve EOF si se produce algn error

2. getc() y putc()
i) getc()

car=getc(ptrArchivo) .Leer caracteres de un archivo

Si llegamos al final del archivo devuelve eof.Para leer un archivo de texto hasta el final usamos

do{
c=getc(fptr);
}while (c!=EOF)

ii) putc(car,fptr)
Escribe un carcter en un archivo

Si falla retorna EOF. Se puede reemplazar por fputc()

B) Trabajo con cadenas

Se emplean las funciones:gets(), puts(), fgets(), fputs().
1) gets() y puts()
i) gets(cad)
cadena=gets(cad). Lee una cadena proporcionada desde el teclado
Observaciones:
Cuando pulso intro se aade un terminador nulo
No lee nmeros.
No se aconseja para leer campos de registros.
ii) puts(cad)
Escribe caracteres por pantalla.
2) fgets() u fputs()
i) fgets(cadena ,longitud de car a leer, puntero a archivo)
cadena=fgets(cad,n,fptr). Lee una cadena de un archivo

ii)fputs(cadena,puntero a archivo)
Escribe una cadena en el archivo.

C) Trabajo con archivos que contienen registros, nmeros y caracteres.

Se emplea fprintf(),fscanf(), fread(), fwrite().
i)fprintf() y fscanf().
Se comporta como printf() y scanf() pero actuan sobre archivos.

fprintf(puntero_archivo,cadenea_control,cadena_texto);
fscanf(puntero_archivo,cadena_control,&variabl

ii)fread() y fwrite()
Se emplea en archivos sin formato(?).Se suele emplear cuando queremos leer y escribir el bloque
entero y no los miembros.
fread(&variable_tipo_registro, tamao_bloque,nmero_bloques,puntero_archivo)
fwrite(&variable_tipo_registro,tamao_bloque,nmero_bloques,puntero_archivo)

fread(&variable,sizeof(tipo_registro),1,fptr)
fwrite(&varaible,sizeof(tipo_registro),1,fptr)

6.TRATAR UN FICHERO, ESTRUCTURADO EN REGISTROS, LINEA A LINEA

2.OPERACIONES CON ARCHIVOS INDIZADOS.

1)
2)
3)
4)
5)

QUICKSORT
INTERCAMBIA
RECONSTRUIR INDICE
LEER_CAMPO
LISTAR ORDENADOS LOS CAMPOS DEL INDICE

1) QUICKSORT
void Quicksort (File * fi, long inicio, long final)
{
long iz, de;
char mitad [10];
static char cad [10];
iz=inicio:;
de=final;
strcpy (mitad, leerCampo (fi,(iz+de)/2,cad));
do{
while( (strcmp(leerCampo(fi,iz,cad),mitad)<0) && (iz < de) )
iz ++;
while( (strcmp(mitad,leerCampo(fi,de,cad)<0) &&(de>iz) )
de ;
if (iz < de ) Intercambia (fi, iz, de);
if (i <=de)
{
iz ++;
de -;
}
} while(iz < de);
if (inicio < de ) Quicksort (fi, inicio, de);
if (iz< final ) Quicksort (fi, iz, final);
}

2 )INTERCAMBIA

void Intercambia (FILE *fi, long iz, long de)

{
indice reg1, reg2;
fseek(fi, iz*sizeof (indice), SEEK_SET);
fread(&reg1, sizeof(indice), 1,fi);
fseek(fi, de*sizeof(indice),SEEK_SET);
fread(&reg2, sizeof(indice), 1, fi);
fseek(fi, iz*sizeof(indice), SEEK_SET);
fwrite(&reg2,sizeof(indice),1,fi);
fseek(fi, de*sizeof(indice), SEEK_SET);
fwrite(&reg1, sizeof(indice),1,fi);
}

3 ) RECONSTRUIR INDICE
void ReconstruirIndice (FILE *pf)
{
long n=0;
FILE * fi;
datos Ind;
/*Creo el archivo de indices*/
fi=fopen(indices.ind,w+b);
/*Abro el archivo con los datos*/
pf=fopen(Archivos.dat, rb);
rewind(pf);
while(fread(&reg,sizeof(datos),1,pf))
{
strcpy(ind.CampoIndice,reg.CampoIndice);
ind.indice=n++;
/*escribo en el archivo de indices*/
if (fwrite (&ind,sizeof(indice),1,fi)==1)
{
printf(%s,registro grabado);
}
}
QuickSort(fi,0,n-1);
fclose(fi);
fclose(pf);
}

4) LEER CAMPO
char *leerCampo ( FILE *fi, long n, char * buf)
{
indice ind;
fseek (fi, n*sizeof(indice), SEEK_SET);
fread (&ind, sizeof (indice), 1, fi);
strcpy (buf, ind.CampoIndice);
return buf;
}

5) LISTAR LOS CAMPOS ORDENADOS POR SU INDICE

void listarOrdenadoLosCamposPorIndice(FILE *pf)
{
FILE *fi;
datos reg;
indice ind;
/*Abro los dos archivos*/
fi=fopen(indices.dat,r+b);
pf=fopen(Archivo.dat,rb);
while(fread(&ind,sizeof(indice),1,fi)
{
fseek(pf,ind.indice*sizeof(datos);SEEK_SET);
fread(&reg,sizeof(datos),1,pf);
<escribir los campos>
}
fclose(fi);
}

3.OPERACIONES CON ARCHIVOS SECUENCIALES

(Comprobar si faltan algoritmos)
1.-SEPARAR
2.MOSTRAR
3.MEZCLAR
1.SEPARAR
void separar (FILE *pf, FILE **aux)
{
char linea [128];
char anterior[2][128];
int salida=0;
strcpy(anterior[0],);
strcpy(anterior[1],);
gets(linea,128,pf);
while(!fget(pf))
{
if(salida==0 && strcpy(linea,anterior[0])<0);
{
salida=1;
}
else if (salida ==1 && strcpy(linea,anterior[1])<0)
{
salida=0;
}
strcpy(anterior[salida],linea);
puts(linea,aux[salida]);
gets(linea,128,pf);
}
}

(Comprobar que esta completo)

2.MOSTRAR
void mostrar (FILE *pf)
{
char linea[128];
rewind (pf)
fgets(linea,128,pf)
while(!feof(pf))
{
puts(linea);
fgets(linea,128,9f);
}
}

3.MEZCLAR
int mezclar(FILE *pf, FILE **aux)
{
char ultima[128];
char linea [2][128];
char anterior[2][128];
int entrada;
int tramos=0;
fgets(linea[0],128,aux[0]);
fgets(linea[1],128,aux[1]);
strcpy(ultima,);
strcpy(anterior[0],);
strcpy(anterior[1],);
while(!feof(aux[0]) && !feof(aux[1])
{
if(strcmp(linea[0],linea[1])<=0)
entrada=0;
else
entrada=1;
strcpy(anterior[entrada],linea[entrada])
fputs(linea[entrada],pf)
fgets(linea[entrada],128,aux[entrada]);
if(strcmp(anterior[entrada],linea[entrada])>0)
{
if(!entrada)
{
entrada=1;
else
entrada=0;
tramos ++;
do
{
strcpy(anterior[entrada],linea[entrada]);
fputs(linea[entrada],pf);
fgets(linea[entrada],128,aux[entrada]);
}while(!feof(aux[entrada &&
strcmp(anterior[entrada],linea[entrada])<=0);
}
}
if(!feof(aux[])) tramos ++;
while(!feof(aux[0]))
{
fputs(linea[0],pf)
fgets(linea[0],128,aux[0]);
}
if(!feof(aux[1])) tramos ++;
while(!feof(aux[1]))
{
fputs(linea[1],pf)
fgets(linea[1],128,aux[1]);
}
}

El algotimo que se emplea es :

int main()
{
FILE *fichero;
/*abro el archivo*/
mezcla(fichero);
mostrar(fichero);
/*cerrar el fichero*/
}