You are on page 1of 86

APUNTES DE ADMINISTRACIN Y ORGANIZACIN DE DATOS.

ndice

1. Introduccin.
1. Concepto de archivos.
2. Tipos de archivos
3. Organizacin de archivos
4. Operaciones sobre archivos

2. Organizaciones bsicas.
1. Organizacin Secuencial.
2. Organizacin Secuencial Indexado.
3. Organizacin Directa.

3. Mtodos de Ordenamiento y Bsqueda.


1. Fundamentos de los algoritmos de ordenamiento.
3.1.1. Algoritmos de ordenamiento por enumeracin.
3.1.2. Algoritmo de ordenamiento por insercin.
3.1.3. Algoritmo de ordenamiento por intercambio.
3.1.4. Algoritmo de ordenamiento por seleccin.
3.1.5. Algoritmo de ordenamiento por combinacin.
3.1.6. Algoritmo de ordenacin externa/mezcla natural.
2. Algoritmos de bsqueda.
3.2.1. Algoritmo de bsqueda secuencial.
3.2.2. Algoritmo de bsqueda binaria.
3.2.3. Algoritmo de bsqueda usando transformacin de claves.

4. Organizacin de Archivos Actuales.


4.1 Procesamiento de Archivo CVS.
4.2 Procesamiento de Archivos XML.
4.3 Organizacin de archivos no estructuradas.

5. Visualizacin de informacin.
5.1 Representacin tabular.
5.2 Representacin grfica.
5.3 Representacin jerrquica.

6. Evaluacin general de Organizaciones de Archivos.


6.1 Estimacin del uso del sistema.
6.2 Anlisis de los beneficios del sistema.
6.3 Comparacin entre costo y beneficio.

1
1. Concepto de archivo.

1.1. Concepto de archivos.

El proceso computacional implica leer datos, procesarlos y generar resultados


(datos); De dnde se leen los datos?, En dnde se guardan los resultados?; en un
archivo.
<<<<< Un archivo es un medio de almacenamiento >>>>>.

Generalmente los datos se leen del archivo estndar de entrada (stdin) que identifica
el buffer del teclado, y los resultados se presentan en el monitor: archivo estndar de
salida (stdout) . Una caracterstica importante de los archivos es que los datos se
guardan en Dispositivos de Almacenamientos Secundarios (DAS), dispositivos que
permiten un almacenamiento permanente (cintas magnticas, discos magnticos,
discos pticos, memorias flash, etc.) diferente de la memoria principal de la
computadora (RAM), que es un almacenamiento voltil.
<<<<< Un archivo es un medio que permite almacenar datos en DAS >>>>>

Una pregunta razonable en este punto es Qu significa el trmino < medio > que se
utiliza en la definicin de archivo?, cmo se puede reemplazar la palabra medio?,
por el concepto tipo de dato.
<<<<<Un archivo es un tipo de dato que permite almacenar en DAS >>>>>

Qu es un tipo de dato?:

Un tipo de datos es una clase de objetos de datos ligados a un conjunto de


operaciones para crearlos y manipularlos (Pratt, Zelkowitz; 1998, pg. 112).

Al determinar el tipo de datos, se definen una serie de atributos, como lo son: la


manera de implementar los datos, el rango de los mismos, la cantidad de bytes para
almacenarlos, las operaciones que se pueden efectuar con ellos, la etiqueta que
corresponde al tipo de datos en el lenguaje de programacin que se esta usando, y
los errores que se pueden generar como consecuencia del tipo de datos, por ejemplo
de este ltimo caso, el tipo de dato real puede generar adems del error de sobreflujo
un error de subflujo.

<<<<< Un archivo es un tipo de dato estructurado >>>>>

2
Los tipos de datos se pueden clasificar en estticos y dinmicos, los estticos se
clasifican a su vez en primitivos o elementales , en tipos de datos estructurados y en
tipos de datos definidos por el usuario (programador).

TIPOS DE
DATOS

ESTTICOS APUNTADOR DINMICOS

LISTAS
PILAS
PRIMITIVOS DEFINIDOS POR
COLAS
EL USUARIO RBOLES

SIMPLES ESTRUCTURADOS ENUMERADO


SUBRANGO

ARREGLOS
REGISTROS
ORDINALES NO ORDINALES
CONJUNTOS
ARCHIVOS
ENTERO REAL
CARCTER CADENA
BOOLEANO

Figura 1.1.1 Clasificacin de los tipos de datos.

ARCHIVO:

TIPO DE DATO ESTRUCTURADO QUE PERMITE ALMACENAR GRANDES


VOLMENES DE INFORMACIN, ALMACENAR DATOS
INDEPENDIENTES DE LA EJECUCIN DE UN PROGRAMA EN
PARTICULAR Y ACCESAR SLO LA PARTE DE INFORMACIN
REQUERIDA.

COLECCIN DE REGISTROS LGICAMENTE RELACIONADOS,


ALMACENADOS EN UN DISPOSITIVO DE ALMACENAMIENTO
SECUNDARIO (DAS).
3
1.2. Tipos de archivos.

Los archivos se pueden clasificar considerando diferentes enfoques: de acuerdo a su


implementacin, con base en su funcin, con respecto a las entradas y salidas en
el marco de un proceso, etc.

Considerando la implementacin, los archivos se clasifican en archivos


tipo texto y tipo binario.

Los archivos tipo texto se caracterizan, por ser archivos legibles, esto se
debe a que se graban en el DAS de acuerdo a un cdigo de caracteres, por
ejemplo el cdigo ASCII.
Los archivos tipo binario no son legibles debido a que los datos se
almacenan de acuerdo a tipos de datos determinados.
Los archivos tipo texto se pueden crear desde cualquier editor o por medio
de un programa.
Los archivos tipo binario slo pueden ser creados desde un programa, en el
que se definen los tipos de datos asociados a los valores que se van a guardar
en el archivo. Esto significa que un archivo se constituye por registros que
pueden estar constituidos por diferentes tipos de datos, cada tipo de dato se
asocia a un campo determinado del registro.

<< Los campos constituyen un registro, los registros definen un archivo >>

Los registros en un archivo tipo texto tienen una longitud variable, que esta
en funcin de la cantidad de caracteres definidos en el registro o la lnea,
cada lnea tiene un carcter que representa el fin de la misma.
Los registros en un archivo tipo binario, se definen como registros de
longitud fija, debido a que se constituyen de acuerdo a la cantidad de bytes
definida por el tipo de dato de cada campo que integran el registro.
Los datos que se leen de un archivo tipo texto para colocarse en las celdas
que corresponden a la variables asociadas a los mismos en RAM (proceso de
entrada), se deben codificar de acuerdo a la implementacin del tipo de dato
definido para cada variable. Respecto al proceso de salida, los datos que se
leen de RAM para almacenarse en un archivo tipo texto, deben decodificarse
de la implementacin del tipo de dato al cdigo de caracteres. Estos procesos
de codificacin y decodificacin determinan que las operaciones con los
archivos tipo texto sean ms lentas .
Los procesos de entrada y salida relacionados con los archivos binarios no
requieren la codificacin y decodificacin, debido a que los datos se
encuentran grabados en el archivo de acuerdo a la implementacin de los
tipos de datos requerida para la variables asociadas a los datos, por ende la
aplicacin de estos archivos es ms rpida.

4
PROCEDIMIENTO DE ARCH
ENTRADA TEXTO
ARCH (CODIFICAR AL TIPO
TEXTO DE DATO) (STDOUT)
(STDIN)
ASCII
RAM
ASCII
VARIABLE Implementacin: PROCEDIMIENTO DE
TIPO DE DATO SALIDA
(DECODIFICAR AL
CDIGO DE
CARACTERES)

ARCH PROCEDIMIENTO
BINARIO DE ENTRADA
(DIRECTO) PROCEDIMIENTO
DE SALIDA
TIPO DE DATO (DIRECTO)

ARCH
BINARIO

TIPO DE DATO

Figura 1.2.1 Clasificacin de los archivos por su implementacin.

5
Con base en su funcin, los archivos se clasifican en:

Archivo maestro.

El archivo maestro contiene la informacin actual de un sistema. Por


ejemplo considere un sistema bancario, el archivo maestro debe
contener la informacin actualizada en tiempo real de cada una de las
cuentas de los clientes.

Archivo de transacciones.

El archivo de transacciones contiene los cambios de la informacin,


con estos cambios se debe actualizar el archivo maestro. Por ejemplo
en un sistema de cuentas por cobrar, el archivo de transacciones debe
contener los pagos de los clientes, en un periodo determinado de
tiempo, con esta informacin se actualiza el archivo maestro.

Archivo de trabajo.

El archivo de trabajo es un archivo temporal, que se genera como


archivo intermedio en un proceso. Por ejemplo, se guardan en el
archivo de trabajo la informacin de los trabajadores de una empresa
que ganen ms del salario mnimo, posteriormente se toman estos
datos y se ordenan alfabticamente para seguir con el proceso.

Archivo de reporte.

El archivo de reporte es un archivo tipo texto que sirve para guardar


datos en un formato en particular. Estos archivos se presentan a los
clientes interesados en esta informacin. Por ejemplo el gerente de
recursos humanos requiere la informacin de los trabajadores que
deben pagar este ao impuestos, sta deber presentarse en un
formato especfico.

Archivo de programa.

El archivo de programa es un archivo que contiene una serie de


instrucciones para ejecutar una tarea en particular. La tarea puede ser
ordenar datos, buscar valores determinados, hacer clculos, etc. Por
ejemplo el programa que ordena alfabticamente los nombres de los
empleados.

6
ARCHIVO
MAESTRO

(INFORMACIN
ACTUAL)
ARCHIVO
DE TRANSACCIONES.

(CAMBIOS)

ARCHIVO DE
TRABAJO.

(TEMPORAL)
ACTUALIZACIN

ARCHIVO DE
PROGRAMA.

(INSTRUCCIONES)

ARCHIVO DE
REPORTE

(PRESENTACIN
RESULTADOS)

Figura 1.2.2 Clasificacin de los archivos por su funcin.

7
Con respecto a las entradas y salidas en el marco de un proceso, los archivos se
clasifican como:

Archivos de entrada.
El archivo de entrada es el archivo del que se toman los datos de entrada,
para procesarlos y generar una informacin en un proceso determinado.

Archivos de entrada salida.


Los archivos de entrada salida, son archivos en los que se almacenan datos
y tambin resultados o resultados intermedios en un proceso dado.

Archivos de salida.
Los archivos de salida sirven para almacenar informacin generada de un
proceso.

datos
RAM

Resultados
ARCHIVO Finales
DE
ENTRADA
ARCHIVO DE SALIDA

Resultados
Intermedios

ARCHIVO DE ENTRADA
- SALIDA

Figura 1.2.3. Clasificacin de los archivos en un proceso.

8
Considerando el acceso al archivo, los archivos se clasifican en:

Archivos de acceso secuencial:

Estos archivos se caracterizan por acceder los registros de manera


consecutiva, iniciando desde el primer registro almacenado en el archivo.
Los registros pueden ser de longitud fija o longitud variable, debido a que no
se requiere dar saltos para encontrar un registro determinado. Como
consecuencia de lo anterior, el archivo puede ser implementado como texto o
binario.

Archivos de acceso aleatorio:

Los archivos de acceso aleatorio permiten acceder a cualquier registro


deseado. Para identificar los registros se necesita definir un campo llave, este
campo puede ser el rfc, el curp, o alguna clave que no se repita. Con este
acceso, el usuario puede solicitar la informacin de cualquier registro, dando
la llave del mismo. Por ende, los registros deben ser de longitud fija, ya que
se requiere hacer desplazamientos determinados para localizar el registro
deseado, como consecuencia el archivo debe ser binario.

Archivos de acceso secuencial - aleatorio:

Este tipo de archivo se caracteriza por permitir los dos accesos: secuencial y
aleatorio. Se deben constituir por registros que se identifiquen con un campo
llave; se requiere que los registros sean de longitud fija, por lo que el archivo
debe implementarse como binario.

<< El campo llave sirve para identificar el registro de un archivo >>

9
1.3. Organizaciones de archivos

<<<<< Qu significa Organizacin? >>>>>

Con base en la Real Academia Espaola, Organizacin es la asociacin de personas


regulada por un conjunto de normas en funcin de determinados fines.

Considerando un enfoque ms amplio:

Organizacin es un sistema cuya estructura esta diseada para que los recursos
humanos, financieros, fsicos, de informacin y otros, de forma coordinada,
ordenada y regulada por un conjunto de normas, logren determinados fines.

La organizacin de archivos corresponde a la forma en la que se estructura para su


implementacin el archivo, sta se clasifica en:

ORGANIZACIN SECUENCIAL

Se permite solamente el acceso secuencial.

ORGANIZACIN SECUENCIAL INDEXADA

Se permite el acceso secuencial y el acceso aleatorio

ORGANIZACIN DIRECTA

Se permite el acceso aleatorio.

ORGANIZACIN MULTILLAVE

Se permite acceder al archivo por medio de diferentes llaves.

<<<<< Cul es la Organizacin ms apropiada? >>>>>

La respuesta est en funcin de las caractersticas del archivo dentro de un


proceso:

Volatilidad: Corresponde a la frecuencia de los cambios, supresiones e


inserciones de los registros del archivo.

10
Actividad: Equivale a la frecuencia de recuperacin de la informacin
contenida en los registros del archivo.

Tamao: Tamao del archivo.

V F
Una llave?

V Slo
F Organizacin
Acceso Multillave
Secuencial?
?

Organizacin V Slo
F
Secuencial Acceso
Aleatorio?

Organizacin Organizacin
Directa Secuencial Indexada

Figura 1.3.1. Clasificacin de la Organizacin de archivos.

11
1.4. Operaciones sobre archivos

La organizacin de archivos responde a la pregunta:


Cul es la forma en la que se estructuran y manipulan los archivos?

Y la respuesta al Cmo? , se define por medio de las operaciones sobre archivos.

<<<<< Las operaciones sobre archivos son: >>>>>

1. CREACIN

Es la generacin del archivo. Por ejemplo la creacin del


archivo maestro.

2. ACTUALIZACIN

Comprende los cambios que se hacen a los registros:

a. INSERCIN: Adicionar nuevos registros


b. MODIFICACIN : Cambiar campos de los registros.
c. SUPRESIN: Eliminar registros

3. RECUPERACIN

Implica recuperar la informacin almacenada en el archivo.

a. CONSULTA
b. GENERACIN DE REPORTES

4. MANTENIMIENTO

Cambios al archivo para mantenerlo vigente en cualquier


proceso.

a. ESTRUCTURACIN (de los campos)


b. REORGANIZACIN

12
APLICACIONES

/*Desarrolle un programa en Java para crear un archivo tipo texto, con el objetivo de
escribir 5 enteros, y posteriormente leerlos*/

package od_1;

import java.io.*;

public class Main {

public Main() {
}

public static void main (String[] args) throws IOException {

Texto vector = new Texto ();

vector.escribir ();
vector.leer();
}
}

----------------------------------------------------------------------------------------------------------

package od_1;

import java.io.*;
import java.util.*;

public class Texto {

int i;

void escribir ()throws IOException{

int [] x=new int [5];


Scanner entrada = new Scanner (system.in);

13
//DEFINICIN DEL NOMBRE LGICO Y APERTURA DEL ARCHIVO.

FileWriter archix= new FileWriter (texto1.dato);


PrintWriter archi=new PrintWriter (archix);

System.out.println (\n Escribe 5 Enteros: );

for(i=0;i<5;i++){
x[i]=entrada.nextInt();

//ESCRIBIR EN EL ARCHIVO.

archi.println (x[i]);

//CERRAR EL ARCHIVO
archi.close ();
}

void leer () throws IOException{

int []y=new int [5];

//DEFINICIN DEL NOMBRE LGICO Y APERTURA DEL ARCHIVO.

FileReader arch1=new FileReader (texto1.dato);


BufferedReader arch2 = new BufferedReader(arch1);

for(i=0;i<5;i++){

//LEER DEL ARCHIVO.


y[i]=Integer.parseInt(arch2.readLine());

System.out.println (DATOS LEIDOS DEL ARCHIVO: + y[i]);


}

//CERRAR EL ARCHIVO.
arch2.close();
}

14
/*Desarrolle un programa en Java para crear un archivo tipo binario, con el objetivo
de escribir 5 enteros, y posteriormente leerlos*/

package od_2;

import java.io.*;

public class Main {

public Main() {
}

public static void main (String[] args) throws IOException {

Binario vector = new Binario ();

vector.escribir ();
vector.leer();
}
}

---------------------------------------------------------------------------------------------------------

package od_2;

import java.io.*;
import java.util.*;

public class Binario {

int i;

void escribir ()throws IOException{

int [] x=new int [5];


Scanner entrada = new Scanner (system.in);

//DEFINICIN DEL NOMBRE LGICO Y APERTURA DEL ARCHIVO.

FileWriter archi= new FileWriter (binario1.dato);

15
System.out.println (\n Escribe 5 Enteros: );
for(i=0;i<5;i++){
x[i]=entrada.nextInt();

//ESCRIBIR EN EL ARCHIVO.

archi.write (x[i]);

//CERRAR EL ARCHIVO
archi.close ();
}

void leer () throws IOException{

int []y=new int [5];

//DEFINICIN DEL NOMBRE LGICO Y APERTURA DEL ARCHIVO.

FileReader arch1=new FileReader (binario1.dato);


BufferedReader arch2 = new BufferedReader(arch1);

for(i=0;i<5;i++){

//LEER DEL ARCHIVO.


y[i]= arch2.read();

System.out.println (DATOS LEIDOS DEL ARCHIVO: + y[i]);


}

//CERRAR EL ARCHIVO.
arch2.close();
}
}

Observaciones:

Escribir un archivo tipo texto:

Definicin del nombre lgico: FileWriter archix = new FileWriter


(texto1.dato)
Relacin con la clase PrintWriter (para PrintWriter archi = new printWriter
poder utilizar el mtodo println). (archix)
Escribir en el archivo: archi.println(x[i])
Cerrar el archivo: archi.close.
16
Leer de un archivo tipo texto:

Definicin del nombre lgico: FileReader arch1 = new FileReader


(texto1.dato)
Relacin con el buffer BufferedReader arch2 = new Buffered
Reader(arch1)
Leer del archivo: Y[i]=Integer.parseInt(arch2.readLine());
Cerrar el archivo: arch2.close().

Escribir un archivo tipo binario:

Definicin del nombre lgico: FileWriter archi = new FileWriter


(binario1.dat)
Escribir en el archivo: archi.write(x[i])
Cerrar el archive: archi.close().

Leer de un archivo tipo binario:

Definicin del nombre lgico FileReader arch1 = new


FileReader(binario1.dat)
Relacin el buffer BufferedReader arch2 = new
BufferedReader (arch1)
Leer del archivo: y[i] = arch2.read()
Cerrar el archivo: arch2.close()

Clases utilizadas:

Paquete de java Superclases: Subclases


Flujo de caracteres.
Java.io Writer FileWriter
PrintWriter
BufferedWriter
Java.io Reader FileReader
BufferedReader

17
2. ORGANIZACIONES BSICAS.

2.1 ORGANIZACIN SECUENCIAL.

Los registros se graban consecutivamente en orden


ascendente o descendente de acuerdo a la llave.
primaria.

El acceso permitido es solamente


secuencial.

Los registros pueden tener longitud


variable o fija.

La implementacin del archivo puede ser texto


o binario.

Se pueden grabar en cualquier dispositivo de


almacenamiento secundario, incluyendo cintas
magnticas.

Aplicacin:
Procesamiento por lotes (inventario,
salario).
Archivos histricos.

Caractersticas del archivo:


Poca volatilidad.
Gran actividad.
Tamao variable.
18
2.1.1 OPERACIONES SOBRE ARCHIVOS SECUENCIALES.

2.1.1.1 CREACIN

Implementacin: texto o binario

Guardar los registros en orden ascendente o


descendente de acuerdo a la llave primaria.

Instanciacin del objeto archivo.


Relacin del nombre lgico con
el nombre fsico.

Apertura del archivo.

Escritura en el archivo

Cierre del archivo

Figura 2.1.1.1.1. Creacin del archivo maestro organizado Secuencialmente

19
2.1.1.2 RECUPERACIN

SLO ACCESO SECUENCIAL!

RAM
ARCHIVO
Leer_Registro_M Registro_M
MAESTRO

Fin de Archivo
Maestro?. Concluir

PRESENTAR INFORMACIN
DE ACUERDO A LO
REQUERIDO.

Figura 2.1.1.2.1 Recuperacin de los registros de un archivo con organizacin


Secuencial.

20
2.1.1.3 ACTUALIZACIN

2.1.1.3.1 ACTUALIZACIN
(MODIFICACIN)

RAM
Leer_Registro_M
1
Archivo
Registro_M
Maestro
(ordenado)
Llave_Primaria_Registro
Leer_Registro_T
_M =
Llave_Primaria_Registro
Archivo _T
Transacciones. Registro-T
(ordenado)
(cambios)

Guardar Registro_T en
archivo Maestro Nuevo
Guardar Registro_M en
Archivo Maestro Nuevo
Fin de archivo
de
transacciones?.
Leer Siguiente
Registro_M, y siguiente Leer Siguiente
Registro_T Registro_M
Guardar Registros restantes del archivo
Maestro en el Nuevo Archivo Maestro.
Concluir.

Fin de archivo
Maestro? O
Fin de ambos
archivos? Concluir Fin de archivo
Maestro?. Concluir
1

Figura 2.1.1.3.1.1 Modificacin de los registros de un archivo con organizacin


Secuencial.

21
2.1.1.3.2 ACTUALIZACIN
(INSERCIN)

Leer_Registro_M RAM
ARCHIVO Registro_M
MAESTRO

Leer_Registro_T
ARCHIVO DE
TRANSACCIN
(Nuevos Registros Registro_T
ORDENADOS)

V
Llave_Primaria_Registro_M < Llave_Primaria_Registro_T

Guardar Registro_M F
en archivo Maestro
Nuevo.

Guardar Registro_T en
archivo Maestro Nuevo.
Leer siguiente
Registro_M

Leer Siguiente
Registro_T

Fin de Archivo
Maestro? 1

Fin de archivo de
Guardar registros restantes del Archivo de Guardar registros restantes del Transacciones?
Transacciones en el archivo Maestro Nuevo. Archivo Maestro en el archivo
Concluir. Maestro Nuevo. Concluir.

Figura 2.1.1.3.2.1 Insercin de los registros de un archivo con organizacin Secuencial.

22
2.1.1.3.3 ACTUALIZACIN
(ELIMINACIN)

Leer_Registro_M
RAM
ARCHIVO
MAESTRO
Registro_M

Leer_Registro_T
ARCHIVO
TRANSACCIN
(Registros Registro_T
ordenados para
eliminarse)

V
Llave_Primaria_Registro_M = Llave_Primaria_Registro_T

F
Leer Siguiente
Registro_M, y siguiente
Registro_T Guardar Registro_M en
Archivo Maestro Nuevo.

Fin de Archivo Fin de Archivo de


Maestro?. Concluir Transaccin ?.
Leer Siguiente Registro_M

Guardar Registros restantes del archivo


Maestro en el Nuevo Archivo Maestro.
Fin de Archivo
Concluir.
Maestro?. Concluir

Figura 2.1.1.3.3.1 Supresin de los registros de un archivo con organizacin Secuencial.

23
APLICACIONES

/* Desarrolle un programa en Java para crear un archivo MAESTRO SECUENCIAL


tipo binario, con el objetivo de escribir DATOS DE LIBROS (clave, nombre y
clasificacin). Defina adems un mtodo para leer la informacin del archivo y
presentarla en el archivo estndar de salida */

package registros;

import java.io.*;
import java.util.*;

public class Main {

public static void main(String[] args) throws IOException {


Libro lib = new Libro();
lib.escribir_Arch_Maestro();
System.out.println("LECTURA DEL ARCHIVO MAESTRO \n");
lib.leer_archivo_maestro();
}

/* Clase libro.java*/

package registros;

import java.io.*;
import java.util.Scanner;

public class Libro {

int llave;
String nomb;
double clasifica;

public void escribir_Arch_Maestro() throws IOException{


int n;
System.out.println("Archivo Maestro");

DataOutputStream archi = new DataOutputStream (new


FileOutputStream("biblioteca"));

Scanner entrada = new Scanner(System.in);

24
do{
System.out.println("Clave del libro <<ENTERO>>: ");
llave=entrada.nextInt();
archi.writeInt(llave);
System.out.println("Nombre del libro <<CARACTERES SIN ESPACIO>>: ");
nomb=entrada.next();
archi.writeUTF(nomb);
System.out.println("Clasificacin del libro << REAL>>: ");
clasifica=entrada.nextDouble();
archi.writeDouble(clasifica);
System.out.println("Presiona 1 para el siguiente libro");
n=entrada.nextInt();
}while(n==1);
archi.close();
}

public void leer_archivo_maestro()throws IOException{


long ap_actual, ap_final;
RandomAccessFile leer_archi = new RandomAccessFile("biblioteca","r");

while((ap_actual=leer_archi.getFilePointer())!=(ap_final=leer_archi.length())){
llave=leer_archi.readInt();
System.out.println(llave);
nomb=leer_archi.readUTF();
System.out.println(nomb);
clasifica=leer_archi.readDouble();
System.out.println(clasifica);

}
leer_archi.close();
}
}

Paquete de java Superclases: Subclases


Flujo de caracteres.
Java.io RandomAccessFile

Java.io OutputStream DataOutputStream


FileOutputStream

25
2.2 ORGANIZACIN SECUENCIAL INDEXADA.

Se definen registros de longitud fija, ordenados de acuerdo a


la llave, la llave se asocia a una direccin fsica, sta
asociacin se define en un archivo denominado ndice.

El acceso permitido es secuencial y


aleatorio.

Los registros son de longitud fija.

La implementacin del archivo es binaria.

Se pueden grabar en cualquier dispositivo de


almacenamiento secundario, excepto cintas
magnticas.

Aplicacin:
Procesos que impliquen acceso
secuencial y aleatorio.

El ndice se puede definir como denso disperso. En el primero se acotan las


llaves y las direcciones fsicas directamente; y en el segundo, la relacin de las
llaves con la direccin fsica se puede establecer en diferentes archivos, por
ejemplo: en un archivo se pueden definir rangos de llaves en determinados
cilindros; en otro, para cada cilindro se puede relacionar rangos de llaves con las
caras de un cilindro determinado y finalmente en un archivo ms se puede
establecer la relacin para cada cara, de la llave con la direccin del registro.
Para facilitar la bsqueda de la direccin fsica de un determinado registro se
pueden utilizar rboles.

Caractersticas del archivo:


Mediana volatilidad.
Actividad variable. 26
Tamao relativamente estable.
2.2.1 OPERACIONES SOBRE ARCHIVOS SECUENCIALES INDEXADOS.

2.2.1.1 CREACIN

Implementacin: binario

ARCHIVO INDICE. Guardar en


cada registro la llave y la direccin
fsica que le corresponde al registro.
ARCHIVO MAESTRO. Guardar los registros
en orden ascendente o descendente de acuerdo
a la llave primaria.

Instanciacin del objeto archivo.


Relacin del nombre lgico con
el nombre fsico.

Apertura del archivo.

Escritura en el archivo

Cierre del archivo

Figura 2.2.1.1.1 Creacin del archivo maestro secuencial indexado

27
2.2.1.2 RECUPERACIN

ACCESO SECUENCIAL Y ACCESO ALEATORIO!

1
RAM
Leer_Registro_I
ARCHIVO 3
INDICE RBOL_BINARIO

Con llave, buscar direccin fsica


llave
LLAVE

ARCHIVO 2
Leer_Registro_M Registro_M
MAESTRO

3
Con direccin fsica, buscar registro

PRESENTAR INFORMACIN
DE ACUERDO A LO
REQUERIDO.

Figura 2.2.1.2.1 Recuperacin de los registros de un archivo con organizacin


Secuencial.

28
2.2.1.3. ACTUALIZACIN

2.2.1.3.1 ACTUALIZACIN
(MODIFICACIN)

Con direccin fsica, buscar registro


4
MODIFICAR
RAM
REGISTRO
Leer_Registro_M
Archivo Registro_M
Maestro
(ordenado)
2
5
LLAVE llave
Escribir registro modificado

Con llave, buscar direccin fsica


Archivo Leer_Registro_I RBOL
INDICE.

1
3

Figura 2.2.1.3.1.1 Modificacin de los registros de un archivo secuencial indexado

29
2.2.1.3.2 ACTUALIZACIN
(INSERCIN)

RAM

Registro_M
Archivo
Maestro
2 (ordenado)

1
Nuevo_Reg Escribe registro (zona desbordamiento)
Nuevo_Registro

Escribe llave y direccin fsica del


nuevo registro.

3 Archivo
INDICE.

4 NUEVO ARCHIVO MAESTRO.


NUEVO ARCHIVO INDICE.

Figura 2.2.1.3.2.1 Insercin de los registros de un archivo secuencial indexado

30
2.2.1.3.3 ACTUALIZACIN
(ELIMINACIN)

Con direccin fsica, buscar registro


4 ELIMINAR
REGISTRO.
RAM
(Marcarlo)
Leer_Registro_M
Archivo Registro_M
Maestro
(ordenado)
2

LLAVE llave

Con llave, buscar direccin fsica


Archivo Leer_Registro_I RBOL
INDICE.

1
3

5 Marcar llave o direccin fsica


del registro eliminado en el
ARCHIVO INDICE.

6 NUEVO ARCHIVO MAESTRO.


NUEVO ARCHIVO INDICE.

Figura 2.2.1.3.3.1 Supresin de los registros de un archivo secuencial indexado

31
APLICACIONES

/* Desarrolle un programa en Java para crear un archivo MAESTRO SECUENCIAL


INDEXADO, con el objetivo de escribir DATOS DE LIBROS (clave, nombre y
clasificacin). Defina adems un mtodo para leer ALEATORIAMENTE la
informacin del archivo y presentarla en el archivo estndar de salida */

/* Clase Main */

package od_5;

import java.io.*;
import java.util.*;

public class Main {

public static void main(String[] args)throws IOException {

Libro lib=new Libro();

lib.escribir_Arch_Maestro();
System.out.println("LECTURA DEL ARCHIVO MAESTRO\n");
lib.leer_secuencial_maestro();
lib.leer_aleatorio_maestro();
}

/* Clase Libro.java */

package od_5;

import java.io.*;
import java.util.*;

public class Libro {

int llave;
String nomb;
double clasifica;

32
public void escribir_Arch_Maestro()throws IOException{
int n;
StringBuffer buffer=null;
System.out.println("Archivo Maestro");
RandomAccessFile archi=new RandomAccessFile("biblioteca","rw");
Scanner entrada =new Scanner(System.in);
do{
System.out.println("Clave del libro");
llave=entrada.nextInt();
archi.writeInt(llave);
System.out.println("Nombre del libro");
nomb=entrada.next();
buffer=new StringBuffer(nomb);
buffer.setLength(15);
archi.writeChars(buffer.toString());
System.out.println("Clasificacin del libro");
clasifica=entrada.nextDouble();
archi.writeDouble(clasifica);
System.out.println("OTRO LIBRO? : SI=1, NO=O ");
n=entrada.nextInt();
}while (n==1);
archi.close();
}

public void leer_secuencial_maestro()throws IOException{

long ap_actual, ap_final;

RandomAccessFile leer_archi=new RandomAccessFile("biblioteca","r");


while((ap_actual=leer_archi.getFilePointer())!=(ap_final=leer_archi.length())){
llave=leer_archi.readInt();
System.out.println(llave);
char nombre[]=new char[15],temp;
for(int c=0;c<nombre.length;c++){
temp=leer_archi.readChar();
nombre[c]=temp;
}
new String(nombre).replace('\0',' ');
System.out.println(nombre);
clasifica=leer_archi.readDouble();
System.out.println(clasifica);
}//Fin while
leer_archi.close();

33
public void leer_aleatorio_maestro( )throws IOException{

int n,dl;
long lreg,desplaza;

RandomAccessFile archi=new RandomAccessFile("biblioteca","r");


Scanner entrada =new Scanner(System.in);
archi.readInt();
char nomb[]=new char[15];
for(int c=0;c<nomb.length;c++)
nomb[c]=archi.readChar();
archi.readDouble();
lreg=archi.getFilePointer();
do{
System.out.println("\nIntroduce la direccin lgica del registro: ");
dl=entrada.nextInt();
desplaza=(dl-1)*lreg;
archi.seek(desplaza);
llave=archi.readInt();
System.out.println("\nLos datos del registro son: ");
System.out.println(llave);
char nombre[]=new char[15],temp;
for(int c=0;c<nombre.length;c++){
temp=archi.readChar();
nombre[c]=temp;
}
new String(nombre).replace('\0',' ');
System.out.println(nombre);
clasifica=archi.readDouble();
System.out.println(clasifica);
System.out.println("OTRO LIBRO? : SI=1, NO=O ");
n=entrada.nextInt();
}while (n==1);
archi.close();

}
}

Paquete de java Superclases: Subclases


Flujo de caracteres.
Java.io RandomAccessFile

34
/* Para simular la bsqueda en el archivo ndice, desarrolle un programa en Java
para crear un rbol constituido por nodos con dos campos de informacin: llave y
posicin. Defina adems un mtodo para hacer una bsqueda con base en la llave.*/

package arbol;
import java.util.Scanner;

public class Main {

public static void main(String[] args) {

int llave;
int pos;
Scanner lee= new Scanner(System.in);
Arbol arbol1 = new Arbol();
for(int i=0;i<5;i++)
arbol1.insertar(i+100,i+1 );
do {
System.out.println("Dame la llave (100 ..104) / 0 para terminar");
llave=lee.nextInt();
pos=arbol1.buscar(llave);
if(pos!=0)
System.out.println("La posicin es "+pos);
}while(llave!=0);
}
}

package arbol;

public class Nodo {


int llav;
int dl;
Nodo izq;
Nodo der;
public Nodo(int ele, int dir, Nodo I, Nodo D){
llav=ele;
dl=dir;
izq=I;
der=D;
}//constructor
public Nodo(int ele, int dir){
this(ele,dir,null,null);
}//constructor

35
package arbol;

import java.io.*;

public class Arbol {


Nodo raiz=null;

public void insertar(int llave, int p)


{Nodo nuevo;
Nodo ant=null;
Nodo rec;
if(raiz==null)
{raiz=new Nodo(llave,p);
System.out.println("valor insertado"+llave);
}
else
{nuevo=new Nodo(llave,p);
System.out.println("valor insertado"+llave);
rec=raiz;
while(rec!=null)
{ ant=rec;
if(rec.llav>nuevo.llav)
rec=rec.izq;
else
rec=rec.der;
}
if(ant.llav>nuevo.llav)
ant.izq=nuevo;
else
ant.der=nuevo;
}
}// fin de insertar

public int buscar(int llave)


{
int p=0;
Nodo rec;
Nodo ant;
if(raiz==null)
System.out.println("En este momento el rbol se encuentra vacio");
else
{
rec=raiz;
ant=raiz;
while((ant.llav!=llave)&&(rec!=null))
{ant=rec;
if(rec.llav>llave)
rec=rec.izq;
else
rec=rec.der;
}
if(ant.llav==llave){
System.out.println("El valor se encuentra en el rbol: "+ant.llav);
p=ant.dl;
}
else
System.out.println("El valor "+llave+" no se encuentra en el rbol");
}
return(p);
}//fin de buscar
}

36
2.3 ORGANIZACIN DIRECTA (RELATIVA).

Registros de longitud fija, se almacenan uno al lado del otro,


la posicin del registro (no direccin fija) se calcula como la
direccin relativa. La direccin relativa se estable en funcin
de la llave. Direccin relativa = R(valor de la llave).

Acceso aleatorio.

Los registros son de longitud fija.

La implementacin del archivo es binaria.

Se pueden grabar en cualquier dispositivo de


almacenamiento secundario, excepto cintas
magnticas.

Aplicacin:
Procesos que impliquen acceso aleatorio,
por ejemplos cajeros automticos.

La direccin relativa (DR) se puede calcular con tcnicas de direccionamiento, stas se clasifican en
direccionamiento directo y direccionamiento indirecto. El modelo del primero es: DR=[(Llave primaria)-
(llave primaria mnima)] +1. El direccionamiento indirecto se clasifica a su vez en: Correspondencia por
asociacin, en el que la llave primaria se relaciona directamente con una direccin definida (se pueden utilizar
rboles); y correspondencia por clculo, ejemplos de sta son los mtodos hashing. Entre los mtodos
hashing destacan:
Divisin por un nmero primo: DR= R(llave) = (Llave MOD primo)+1.
Truncamiento o extraccin. Ejemplo: R(11197)=197 R(23197)=319.
Doblamiento: R(982347659)= 982+347+659=1988.
Seleccin: R(238465)=286 (seleccin de dgitos por posicin).
Cuadrado: R(213) = (213)2.
Conversin por cambio de base: R(679) = 9*110+7*111+6*112
Un problema grave del direccionamiento es la generacin de llaves sinnimas, stas son llaves diferentes con la
misma direccin relativa que provocan colisiones. Para este problema se pueden utilizar diferentes estrategias,
por ejemplo el concepto del cubo o la zona de sobreflujo o desbordamiento.

Caractersticas del archivo:


Gran volatilidad. 37
Poca actividad.
Tamao estable.
2.3.1 OPERACIONES SOBRE ARCHIVOS DIRECTOS.

2.3.1.1 CREACIN

Implementacin: binario

Se define el modelo de
direccionamiento: R(llave) .

ARCHIVO MAESTRO. Guardar los registros de acuerdo a la direccin relativa.


Antes de escribir el registro se debe colocar el apuntador del archivo en la
posicin correspondiente al mismo. En el caso de colisiones utilizar el rea de
cubos o desboradmiento.

Instanciacin del objeto archivo.


Relacin del nombre lgico con
el nombre fsico.

Apertura del archivo.

Escritura en el archivo

Cierre del archivo

Figura 2.3.1.1.1 Creacin del archivo maestro directo

38
2.3.1.2 RECUPERACIN

ACCESO ALEATORIO!

RAM
Llave primaria Calcular Direccin
1
1 Relativa.
Con direccin relativa, buscar registro (si es necesario rea de cubos o
desbordamienmto)

ARCHIVO
Leer_Registro_M Registro_M
MAESTRO

PRESENTAR INFORMACIN
DE ACUERDO A LO
REQUERIDO.

Figura 2.3.1.2.1 Recuperacin de los registros de un archivo con organizacin Directa.

39
2.3.1.3. ACTUALIZACIN

2.3.1.3.1 ACTUALIZACIN
(MODIFICACIN)

Con direccin relativa, buscar registro (en las reas necesarias)


2
MODIFICAR
RAM
REGISTRO
Leer_Registro_M
Archivo Registro_M
Maestro

3
Escribir registro modificado

Calcular
Direccin
Llave primaria Relativa

Figura 2.3.1.3.1.1 Modificacin de los registros de un archivo directo.

40
2.3.1.3.2 ACTUALIZACIN
(INSERCIN)

RAM

Archivo
Maestro

Nuevo_Registro Nuevo_Reg Escribe registro, en caso de


colisin utilizar la zona de
desbordamiento (sobreflujo) o en
la zona de cubos.

Con llave
calcular
direccin
relativa.

Figura 2.3.1.3.2.1 Insercin de los registros de un archivo directo.

41
2.3.1.3.3 ACTUALIZACIN
(ELIMINACIN)

3 ELIMINAR
REGISTRO.
RAM
(Marcarlo).
Leer_Registro_M Cuando sea necesario
Archivo Registro_M construir un nuevo
archivo maestro,
Maestro considerando la
eliminacin de los
registros marcados.
2

Con direccin relativa, buscar registro en las


reas necesarias.

Calcular
Direccin
Llave relativa
Primaria

Figura 2.3.1.3.3.1 Supresin de los registros de un archivo directo.

42
APLICACIONES

/* Considere el siguiente programa en Java para crear un archivo MAESTRO


DIRECTO, y grabar los registros como objetos. Realice los cambios pertinentes.*/

/*Main.Java*/

package serializacion;

import java.io.*;
import java.util.Scanner;

public class Main {

public static void main(String[] args) throws IOException,ClassNotFoundException {

Grabar libro = new Grabar();


libro.grabar_Objeto();
Leer otro = new Leer();
System.out.println("LECTURA DEL ARCHIVO MAESTRO\n");
otro.leer_Objeto();

/*
* Grabar Java
*/

package serializacion;

import java.io.*;
import java.util.Scanner;

43
public class Grabar {
int llav;
String nom;
double clas;

public void grabar_Objeto()throws IOException{


int n;
Scanner entrada = new Scanner(System.in);
ObjectOutputStream archi=new ObjectOutputStream(new
FileOutputStream("biblioteca"));
System.out.println("CAPTURA DE LA INFORMACIN DE 5 LIBROS");
for(int i=0; i<5;i++){
System.out.println("Clave del libro");
llav=entrada.nextInt();
System.out.println("Nombre del libro");
nom=entrada.next();
System.out.println("Clasificacion del libro");
clas=entrada.nextDouble();
Creacion libro = new Creacion(llav,nom,clas);
archi.writeObject(libro);
}
archi.close();

/*
* Leer.java

*/

package serializacion;
import java.io.*;
import java.util.Scanner;

public class Leer {

public void leer_Objeto()throws IOException, ClassNotFoundException {

ObjectInputStream archi=new ObjectInputStream(new FileInputStream("biblioteca"));

44
Creacion[] otro= new Creacion[5];
for(int i=0; i<otro.length; i++){
otro[i]=(Creacion)archi.readObject();
otro[i].mostrarInfo();
}
archi.close();

/*Creacin */

package serializacion;
import java.io.*;
import java.util.Scanner;

public class Creacion implements Serializable {

int llave;
String nombre;
double clasifica;

public Creacion(int llav, String nomb, double clasi){


this.llave= llav;
this.nombre=nomb;
this.clasifica=clasi;
}

public void mostrarInfo(){


System.out.println("Clave del libro: "+this.nombre);
System.out.println("Nombre del libro: "+ this.nombre);
System.out.println("Clasificacin del libro: "+this.clasifica);
}
}

45
3. MTODOS DE ORDENAMIENTO Y BSQUEDA.

3.1. Fundamentos de los algoritmos de ordenamiento.

El anlisis de algoritmo requiere de las teoras de computabilidad y de complejidad.


Considere el siguiente diagrama:

PROBLEMA
Se resuelve con
un algoritmo?

Teora de la
computabilidad

Qu se requiere?

Teora de la complejidad

Figura 3.1.1. Anlisis de algoritmos

Dentro del mbito de la teora de la complejidad es importante tener en cuenta que a menor
recurso el algoritmo es ms eficiente, dos recursos importantes son el tiempo (nmero de
pasos de ejecucin de un algoritmo) y el espacio (cantidad de memoria utilizada por un
algoritmo); por ende << a menor complejidad es ms eficiente un algoritmo>> , de ah el
siguiente cuestionamiento: Cmo se calcula la complejidad de un algoritmo?

46
Para determinar la complejidad de un algoritmo se debe considerar el concepto de la O
GRANDE (O). La O es una funcin que tiene como argumento una funcin del tiempo de
ejecucin.

O (f(n)*),

donde:
f(n)*: tiempo de ejecucin en el peor de los casos.

El tiempo de ejecucin depende de la cantidad de los datos y de la configuracin de los


mismos, esto ltimo se refiere a su disposicin, establecimiento o configuracin; si la
configuracin es la ms desfavorable al proceso, se le considera el peor de los casos; si se
tiene una configuracin regular con respecto al proceso, se le considera configuracin tipo
media. Considerando que el tiempo real es siempre menor que un lmite superior, se tiene:

f(n) (real) O (f(n)*),

Considere los siguientes ejemplos:

Complejidad constante: Extraer cualquier elemento de un vector lleva el mismo tiempo.

O (c)

47
Complejidad logartmica. Buscar en un diccionario: Se inicia la bsqueda a la mitad, si no
se encuentra la palabra en una de las dos mitades se repite el proceso (recursivo).

O (log n)

Complejidad Cuadrtica. Ordenar un conjunto de elementos: Se hace un recorrido completo


del conjunto original para seleccionar el elemento menor, se repite el proceso por cada
elemento: n*n.

O (n2)

Ejercicios: Diagrame los siguientes modelos:

O (n) (lineal)

O (2n) (exponencial)

O (n log n2) (logartmica)

O (n logn) (logartmica)
48
Cmo se clasifican los algoritmos de ordenacin?

Ordenacin interna: Se utiliza para volmenes de datos regulares o pequeos. La


clasificacin de los valores se hace con base en un vector. El tiempo de ordenacin es corto.
Ejemplos de estos algoritmos son:

a) Algoritmos de enumeracin.

b) Algoritmos de insercin: Directa (baraja), Shell.

c) Algoritmos de intercambio: Burbuja, quick sort, merge Exchange, radix sort.

d) Algoritmos de seleccin: Directa, rboles, heap sort.

e) Algoritmos de combinacin: Two way (merge), natural two way, list merge.

Ordenacin externa: Se utiliza para volmenes grandes de datos. Se clasifican los


registros situados en un dispositivo de almacenamiento secundario. El tiempo de
ordenacin es regular, dependiendo de los datos (cantidad y configuracin) puede
considerarse lento. Ejemplos de estos algoritmos son:

a) Mezcla directa.

b) Mezcla natural.

c) Mezcla equilibrada mltiple.

d) Mtodo polifsico.

49
APLICACIONES

Determine la complejidad de los algoritmos considerando los siguientes mtodos:

package enumera;

import java.util.Scanner;

/* public class enumera1 {


ALGORITMO DE CLASIFICACIN POR
ENUMERACIN
*/ public int[] pedir(){
int n=5;
package enumera; int arreglo[]=new int [n];
Scanner leer=new Scanner(System.in);
public class Main { System.out.println(" 5 nmeros diferentes a
public static void main(String[] args) { ordenar");
int k=5; for(int i=0;i<n;i++){
int vector[]=new int[k]; System.out.println("Ingrese un nmero");
enumera1 obj= new enumera1(); arreglo[i]=leer.nextInt();
}
vector=obj.pedir(); return arreglo;
vector=obj.ordenar(vector); }
obj.imprimir(vector);

} public int[] ordenar (int arreglo[]){

} int x,y,pos;
int n=arreglo.length;
int aux[]=new int[n];

for(x=0;x<=(n-1);x++){
pos=0;
for(y=0;y<=(n-1);y++){
if(x!=y)
if(arreglo[x]>arreglo[y])
pos++;
}
aux[pos]=arreglo[x];
}
for(pos=0;pos<n;pos++)
arreglo[pos]=aux[pos];
return arreglo;
}

public void imprimir (int arreglo[]){

System.out.println("Valores ordenados");
for(int i=0; i<arreglo.length;i++){
System.out.println(arreglo[i]);
}
}

50
Ordenamiento por insercin directa

Mtodo de la baraja.

public class baraja {

------------------------------------------------------------------------
------------------------------------------------------------------------
------------------------------------------------------------------------

public int[] ordenar(int arreglo[]) {


int k, i, aux;

for(i=1; i<arreglo.length;i++){
aux=arreglo[i];
k=i-1;
while( (k>=0) && (aux<arreglo[k]) ){
arreglo[k+1]=arreglo[k];
k- =1;
}
arreglo[k+1]=aux;
}
return arreglo;
}

------------------------------------------------------------------------
------------------------------------------------------------------------
------------------------------------------------------------------------

51
Ordenamiento por insercin.

Mtodo SHELL .

public class shellmet{

int k, i, aux, e, ban;


int n=5;

-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------

public int[] shell (int arreglo[]) {

e=n+1;
while(e>1){
e=e/2;
ban=1;
while(ban==1){
ban=0;
i=0;
while((i+e)<n){
if(arreglo[i]>arreglo[i+e]{
aux=arreglo[i];
arreglo[i]=arreglo[i+e];
arreglo[i+e]=aux;
ban=1;
}
i++;
}
}
}

return arreglo;
}

-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------

52

}
Ordenamiento por intercambio.

Mtodo BURBUJA .

public class burbujamet{

int i, j, aux;
int n=5;

-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------

public int[] burbuja(int arreglo[]) {

for(i=1; i<arreglo.length; i++)


for(j=0; j<(arreglo.length-1); j++)
if(arreglo[j]>arreglo[j+1]{
aux=arreglo[j];
arreglo[j]=arreglo[j+1];
arreglo[j+1]=aux;
}

return arreglo;
}

-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------

53
Ordenamiento por intercambio.

Mtodo QUICK SORT .

public class quicksortmet{

-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------

void quick_sort (int arreglo[], int ind_izq, int ind_der) {

int i, j, elem, aux;

i=ind_izq;
i=ind_der;

elem=arreglo[(i+j)/2];
do{
while(arreglo[i]<elem && i<ind_der)
i++;
while(arreglo[j]>elem && j>ind_izq)
j--;
if(i<=j){
aux=arreglo[i];
arreglo[i]=arreglo[j];
arreglo[j]=aux;
i++;
j--;
}
}while(i<j);
if(ind_izq<j)
quick_sort(arreglo,ind_izq,j);
if(i<ind_der)
quick_sort(arreglo,i,ind_der);
}
____________________________________________________
____________________________________________________
____________________________________________________
}

54
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
package radixsort;
public class Nodo {
Ordenamiento por intercambio. public int info=0;
Mtodo RADIX SORT public int next=0;

public Nodo(int i, int s){


this.info=i;
this.next=s;
}

package radixsort; public Nodo(){


import java.util.Scanner; }
import java.io.*; public int radixsort(int[] arreglo){
int n=4;
Nodo node[]= new Nodo[n];
int[]front= new int[10];
public class Main { int[]rear=new int[10];
int ex,first,i,j,k,q,y,p=0;
double exp;
for(i=0;i<n-1;i++){
node[i]=new Nodo(arreglo[i],(i+1));
public static void main(String[] args) { }
int i; node[n-1]= new Nodo(arreglo[n-1],-1);
first=0;
int n=4; /*Ciclo que contola las repeticiones, para nmeros de tres dgitos*/
int []arreglo= new int[n]; for(k=1;k<=3;k++){
Scanner scan=new Scanner(System.in); for(i=0;i<10;i++){
rear[i]=-1;
Nodo no= new Nodo(); front[i]=-1;
for(i=0;i<n;i++){ }
System.out.println("Introduce el valor while(first!=-1){
p=first;
(con tres dgitos) : " +(i+1)); first=node[first].next;
arreglo[i]=scan.nextInt(); y=node[p].info;
} exp=Math.pow(10,k-1);
ex=(int)exp;
arreglo[n-1]= no.radixsort(arreglo); j=(y/ex)%10;
System.out.println("\n Arreglo q=rear[j];
Ordenado"); if(q==-1)
front[j]=p;
for(i=0;i<n;i++) else
System.out.println(arreglo[i]); node[q].next=p;
rear[j]=p;
}
} for(j=0;j<10&&front[j]==-1;j++);
first=front[j];
} while(j<=9){
for(i=j+1;i<10&&front[i]==-1;i++);
if(i<=9){
p=i;
node[rear[j]].next=front[i];
}
j=i;
}
node [rear[p]].next=-1;
}
for(i=0;i<n;i++){
arreglo[i]=node[first].info;
first=node[first].next;
}
return arreglo[n-1];
}
}

55
Ordenamiento por Seleccin

Mtodo HEAP SORT.

package heapsort;

public class heapsorter {


package heapsort; int[] a;
int n;
import java.util.Scanner; public void sort (int [] a0){
a=a0;
public class Main { n=a.length;
heapsort();
public static void main(String[] args) { }
int i,n; public void heapsort(){
Scanner le=new Scanner(System.in); buildheap();
int[] arreglo; while(n>1)
System.out.println("Nmero de elementos a {
ordenar :"); n--;
exchange(0,n);
n=le.nextInt(); downheap(0);
arreglo=new int[n]; }
for(i=0;i<n;i++){ }
System.out.println("Ingresa un nmero");
arreglo[i]=le.nextInt(); public void buildheap(){
for(int v=n/2-1; v>=0; v--)
} downheap(v);
heapsorter he=new heapsorter(); }
he.sort(arreglo); public void downheap(int v){
System.out.println("Los nmeros ordenados int w=2*v+1;
son"); while(w<n){
if(w+1<n)
for(i=0;i<n;i++) if(a[w+1]>a[w])
System.out.println(arreglo[i]); w++;
} if(a[v]>=a[w])
return;
} exchange(v,w);
v=w;
w=2*v+1;

}
}

public void exchange(int v, int w){


int t=a[v];
a[v]=a[w];
a[w]=t;
}
}

56
Ordenamiento por Seleccin Directa.

Mtodo DIRECTO.

package hs_2; package hs_2;


import java.util.Scanner;
public class Main { public class Metodo {
int n=5;
public static void main(String[] args) { public int[] directa_in(int arreglo[]){
int i, n=5; int i,j,k,x;
int[]arreglo=new int[n]; for(i=n-1;i>0;i--){
Metodo obj=new Metodo(); x=arreglo[0];
Scanner capt=new Scanner(System.in); k=0;
System.out.println("Elementos a ordenar"); for(j=1;j<=i;j++){
for(i=0;i<n;i++){ if(arreglo[j]>x){
System.out.println("Inserta un numero"); x=arreglo[j];
arreglo[i]=capt.nextInt(); k=j;
} }
arreglo=obj.directa_in(arreglo); }
System.out.println("\n"+"Los elementos arreglo[k]=arreglo[i];
ordenados son : "+"\n"); arreglo[i]=x;
for(i=0;i<n;i++){ }
System.out.println(" "+arreglo[i]); return arreglo;
} }
} }

57
Ordenamiento Externo

Mtodo Mezcla natural.

import java.io.*;

public class Main {


static String ruta="C:\\Users\\Maria\\Documents\\NetBeansProjects";
static String fAux1= "auxiliar1.dat";
static String fAux2= "auxiliar2.dat";
static String ficheroOrdenar= ruta+"archivosNumerosaleatorios.dat";
static int numTramos=0;
static boolean fdt;//fin de un tramo

public static void main (String[] args)throws IOException {


File fichC=new File(ficheroOrdenar);
File fichA=new File(ruta+fAux1);
File fichB=new File(ruta+fAux2);
System.out.println("SE GENERA EL FICHERO DE DATOS A
ORDENAR");
generaFicheroNumeros(fichC);
listaFicheroNumeros(fichC);
do{
distribucion(fichC, fichA, fichB);
numTramos=0;
mezcla(fichA, fichB, fichC);
}
while(!(numTramos==1));
System.out.println("_________________________");
System.out.println("FICHERO ORDENADO");
listaFicheroNumeros(fichC);

58
public static void generaFicheroNumeros(File fich)throws IOException{
DataOutputStream fichCOut=new DataOutputStream(new FileOutputStream(fich));
for (int i=0; i<20; i++){
fichCOut.writeInt(1+(int)(Math.random()*100));
}
fichCOut.close();
}

public static void listaFicheroNumeros(File fich)throws IOException{


int dat=0;
int i=0;
DataInputStream fichIn=new DataInputStream(new FileInputStream(fich));
while (!eof(fichIn)){
dat=fichIn.readInt();
System.out.println("dato: "+i+" "+dat);
i++;
}
fichIn.close();
}

public static boolean eof(DataInputStream dis)throws IOException{


if(dis.available()==0){
return true;
}
else{
return false;
}
}

public static int leoDatoFich(DataInputStream dis)throws IOException{


int devolver;
devolver=dis.readInt();//se lee el dato...
dis.skip(-4);//se coloca el puntero nuevamente..
return devolver;
}

public static boolean copiar(DataInputStream dis, DataOutputStream dos)throws IOException{


int buf, aux;
buf=dis.readInt();
dos.writeInt(buf);
if(eof(dis)){
return true;
}
else{
aux=leoDatoFich(dis);
return(buf>aux);
}
}

59
public static void copiTramo(DataInputStream dis, DataOutputStream dos)throws
IOException{
do{
fdt=copiar(dis,dos);
}
while(!fdt);
}

public static void distribucion(File fichC, File fichA, File fichB)throws


IOException{
DataInputStream _Cln=new DataInputStream(new FileInputStream(fichC));
DataOutputStream _AOut=new DataOutputStream(new
FileOutputStream(fichA));
DataOutputStream _BOut=new DataOutputStream(new
FileOutputStream(fichB));
do{
copiTramo(_Cln,_AOut);
if(!eof(_Cln)){
copiTramo(_Cln, _BOut);
}
}
while(!eof(_Cln));
_Cln.close();
_AOut.close();
_BOut.close();
}

public static void mezTramo(DataInputStream _A, DataInputStream _B,


DataOutputStream _C)throws IOException{
int datoA, datoB;
do{
datoA=leoDatoFich(_A);
datoB=leoDatoFich(_B);
if(datoA<=datoB){
fdt=copiar(_A,_C);
if(fdt){
copiTramo(_B,_C);
}
}else{
fdt=copiar(_B,_C);
if(fdt){
copiTramo(_A,_C);
}
}
}
while(!fdt);
}

60
public static void mezcla(File fichA, File fichB, File fichC)throws
IOException{
DataInputStream _Aln=new DataInputStream(new FileInputStream(fichA));
DataInputStream _Bln=new DataInputStream(new FileInputStream(fichB));
DataOutputStream _COut=new DataOutputStream(new
FileOutputStream(fichC));

while ((!eof(_Aln))&&(!eof(_Bln))){
mezTramo(_Aln,_Bln,_COut);
numTramos++;
}
while (!eof(_Aln)){
copiTramo(_Aln,_COut);
numTramos++;
}
while (!eof(_Bln)){
copiTramo(_Bln,_COut);
numTramos++;
}
_Aln.close();
_Bln.close();
_COut.close();
}

61
3.2. Algoritmos de bsqueda.

Algoritmo de bsqueda secuencial.

package bussec; package bussec;

import java.util.*; import java.util.*;


public class Main {
public class Secuencial {
public static void main(String[] args) { int n=5;
int elemento, fin; int arreglo[]={6,2,9,4,10};
Secuencial sec= new Secuencial();
fin=2; void arre(){
sec.arre(); for(int i=0;i<arreglo.length;i++){
while (fin!=0){ System.out.println("EL VALOR ES:
System.out.println("QUE "+ arreglo[i]);
ELEMENTO DESEAS BUSCAR"); }
Scanner scan=new }
Scanner(System.in); void buscar (int e){
elemento=scan.nextInt(); int i;
sec.buscar(elemento); for(i=0;i<n;i++){
System.out.println("Terminar=0; if(e==arreglo[i]){
Continuar=1"); System.out.println("El elemento se
fin=scan.nextInt(); encuentra en la posicion "+i);
} i=n;
} }
}
} if(i==n)
System.out.println("El elemento no se
encuentra");
}
}

62
Algoritmo de bsqueda binaria.

package busbinaria;

import java.util.*;

public class busq_bin {


package busbinaria; Scanner leer = new Scanner(System.in);
int n=5;
void datos(){
public class Main { int arreglo[]={2,4,6,9,10};
int pos, i, elemento, fin=1;
public static void main(String[] args) { for(i=0;i<n;i++)
busq_bin b = new busq_bin(); System.out.println(arreglo[i]);
b.datos(); while(fin!=0){
} System.out.println("Elemento a buscar");
elemento=leer.nextInt();
} pos=bus_bin(arreglo,elemento);
if(pos!=-1)
System.out.println("El elemento se encuentra en
la posicion "+pos);
else
System.out.println("El elemento no existe");
System.out.println("Terminar = 0; Continuar = 1");
fin=leer.nextInt();
}
}

int bus_bin(int arreglo[], int elem){


int centro, inicio, fin;
inicio=0;
fin=n-1;
while(inicio<=fin){
centro=(inicio+fin)/2;
if(elem==arreglo[centro])
return centro;
else
if(elem>arreglo[centro])
inicio=centro+1;
else
fin=centro-1;
}
return -1;

}
63
4. ORGANIZACIN DE ARCHIVOS ACTUALES.

Introduccin

El desarrollo tecnolgico tanto para Internet, comunicaciones mviles, banda


ancha, satlites, microondas, etc. est produciendo cambios significativos en
la estructura econmica y social, as como en el conjunto de las relaciones sociales. Las
organizaciones pblicas y privadas requieren de diversos anlisis que les permitan
desarrollar con eficiencia una direccin estratgica. Por lo que el trabajo ya no es individual
sino en equipo, esto lleva, a que la informacin debe ser creada, actualizada y enviada en el
tiempo y forma requerida.

La informacin se ha convertido en el eje promotor de cambios sociales, econmicos y


culturales. El auge de las telecomunicaciones ha producido una transformacin de las
tecnologas de la informacin y de la comunicacin, cuyo impacto ha afectado a todos los
sectores de la economa y de la sociedad. Por ello, la creacin de la organizacin de
archivos actuales permite el intercambio de informacin no slo local sino mundialmente,
resguardando la creacin y modificacin de los archivos que se estn trabajando. Adems
presentan a un mundo 3D con las aplicaciones visuales para que todos los que no son
programadores entiendan lo que esta organizacin conlleva.

La poca actual es considerada como la Era de la Informacin; razn por la cual se habla de
la Sociedad de la Informacin, y en su forma evolutiva, como sociedad del conocimiento e
innovacin que considera fundamentalmente las mltiples necesidades del individuo y de la
entidades, de producir y consumir informacin; sea para desarrollar determinadas
actividades o mantener una esfera de poder, y por ltimo por la enorme facilidad de crear,
difundir y acceder a la informacin: por ejemplo: el correo electrnico, internet y las
comunicaciones.

Los archivos actuales facilitan la transmisin estructuracin y representacin de la


informacin de una forma entendible, no solo para el usuario sino tambin para la mquina
a fin de facilitar las tareas diarias de todo proceso informtico, considere el desarrollo de
software a gran escala en l que se requiere de un equipo de desarrolladores no solo locales
sino internacionales, los cuales deben estar compartiendo cdigo fuente para el desarrollo
pleno del proyecto, los archivos CVS proporcionan un amplio margen de ayuda para este
contexto, o considere los archivos XML cuya funcin principal es almacenar grandes
cantidades de informacin de una forma estructurada, que pueda compartirse con otro tipo
de aplicaciones.

64
4.1. Procesamiento de archivos CVS.

Qu es un archivo CVS?

Es un sistema de mantenimiento de cdigo fuente (grupos de archivos en general)


extraordinariamente til para grupos de desarrolladores que trabajan cooperativamente
usando alguna clase de red. Permitiendo, trabajar y modificar concurrentemente archivos
organizados en proyectos. Esto significa que dos o ms personas pueden modificar un
mismo archivo sin que se pierdan los trabajos de ninguna.

Cmo est estructurado?

CVS utiliza una arquitectura cliente-servidor: un servidor guarda la(s) versin(es) actual(es)
del proyecto y su historia, y los clientes se conectan al servidor para sacar una copia
completa del proyecto, trabajar en esa copia y entonces ingresar sus cambios. Adems
guarda las versiones antiguas de los archivos. Esto permite recuperar en cualquier momento
versiones anteriores a la actual.

Figura 4.1.1 Estructura de un archivo CVS

Con que tipo de archivos trabaja?

Dado que trabaja con archivos ASCII es igual de til para trabajar con cdigos fuentes de
programas o con toda clase de documentos siempre que su formato sea completamente de
texto, como pueden ser archivos sgml/html/xml y tambin puede almacenar archivos
binarios.

65
Cmo trabaja el servidor que sirve de repositorio a los archivos?

CVS puede trabajarse de forma local (repositorio y copias de trabajo en el mismo sistema)
o remota (el repositorio est en un sistema servidor y la copia local en otro que es cliente
del primero). Se le llama repositorio a la jerarqua de directorios alojada en un servidor que
contiene diferentes mdulos (rbol de directorios que forma parte del repositorio; cuenta
con un nombre identificador gracias al cual podemos bajarlo de forma selectiva) a
disposicin de los usuarios.

Figura 4.1.2. Repositorio de datos de un archivo CVS

Al trabajar en remoto con CVS pueden elegirse varias alternativas de autentificacin (es
decir, de demostrar al servidor que somos quienes decimos que somos). A continuacin se
muestran las ms importantes:
Ssh: suministra una contrasea y un nombre de usuario cada vez que ejecute CVS.
Pserver: no se necesita acceder por medio de una contrasea para poder trabajar con CVS
solo necesita un nombre de usuario.

66
Cul es la estructura de un repositorio?

BRANCH BRANCH BRANCH BRANCH

MERGE MERGE MERGE MERGE

BRANCH BRANCH

HEAD

Figura 4.1.3. Estructura de un repositorio de datos de un archivo CVS

La imagen de arriba explica cmo est estructurado un repositorio. El head representa la


raz principal es decir el comienzo de nuestro proyecto, el branch es la lnea de evolucin
del mdulo y el merge es la combinacin de dos o ms mdulos.

67
Cmo puedo trabajar en l?

A travs de rdenes como las que se muestran en la siguiente tabla:

Funciones Comandos
Crear un modulo. Co
Actualizar cambios Update
Publicar nuestras ci/commit
modificaciones o
guardar cambios

Aadir archivos de Add/add-kb


texto/binario
Eliminar archivos Remove

CVS informa acerca de qu est haciendo con cada fichero y para eso utiliza el cdigo de
una letra. Este es el significado:

Cundo pueden ocurrir los conflictos?

1.-Pueden ocurrir cuando dos o ms personas modifican a la vez exactamente las mismas
partes de un archivo. Para evitarnos el problema elegimos la modificacin que ms nos
guste y borramos todo lo dems.

Figura 4.1.4. Presentacin de un conflicto


68
2.-CVS puede almacenar archivos binarios pero no puede trabajar sobre ellos ya que es
posible que se d una combinacin de bytes que coincida con estas variables que
modificara el contenido y lo corrompera. Adems no crea un control de versin de los
mismos.

Resolucin de conflictos:

Letra Significado
U Se ha bajado un archivo completamente
nuevo.
P Se ha bajado una modificacin del
archivo y ahora ste est actualizado.
A El archivo lo ha aadido usted pero no lo
ha subido todava al repositorio.
R El archivo ha sido borrado (pero podra
recuperarse del histrico que se almacena
en el repositorio).
C Hay un conflicto: otra persona ha
modificado antes las mismas partes del
fichero y no le queda ms remedio que
revisarlo manualmente antes de poder
subir los cambios de ese fichero.
M Usted ha modificado el fichero pero an
no lo ha subido al repositorio.

? CVS se ha encontrado un fichero que no


tiene registrado y simplemente avisa y lo
deja en paz.

69
Conclusin:

Los archivos CVS nos ayudan a Ayudan al desarrollo de


administrar archivos a travs 1 grandes proyectos
de servidores.

Principalmente son archivos Se almacenan a travs de un


tipo texto. 3 repositorio

Sin embargo no puedes


Estos pueden trabajar local (a travs de eliminarlos ni trabajar
una computadora) o remotamente (a 5 directamente con los archivos
travs de un servidor como el internet). binarios

Solo se pueden actualizar


manualmente

70
4.2. Procesamiento de archivos XML.

Cmo surgi el XML?

El XML proviene de un lenguaje que invent IBM all por los aos 70.

El lenguaje de IBM se llama GML (General Markup Language) y surgi por la


necesidad que tenan en la empresa de almacenar grandes cantidades de informacin
de temas diversos. Imaginar por un momento la cantidad de documentacin que
generara IBM sobre todas las reas en las que trabajaba e investigaba y la cantidad
de informacin que habr generado hasta hoy.
Este lenguaje gust mucho a la gente de ISO, una entidad que se encarga de
normalizar cuantas cosas podrs imaginar para los procesos del mundo actual, en
1986 trabajaron para normalizar el lenguaje, creando el SGML, que no era ms que
el GML pero estndar.
En 1989, para el mbito de la red Internet, un usuario que haba conocido el
lenguaje de etiquetas (Markup) y los hiperenlaces creo un nuevo lenguaje
llamado HTML, que fue utilizado para un nuevo servicio de Internet, la Web.
Desde el 1996 hasta hoy una entidad llamada W3C ha tratado de poner orden en
el HTML y establecer sus reglas y etiquetas para que sea un estndar. Sin embargo
el HTML creci de una manera descontrolada y no cumpli todos los problemas
que planteaba la sociedad global de Internet.
El mismo W3C en el 1998 empez y contina, en el desarrollo de XML (Extended
Markup Language). En este lenguaje se ha pensado mucho ms y muchas personas
con grandes conocimientos en la materia estn trabajando todava en su gestacin.

En los ltimos aos se ha hablado mucho de las nuevas tecnologas, concretamente de


XML como una tecnologa en auge que cada vez se est utilizando ms en las
organizaciones.

71
Cmo caracteriza al XML?

XML es un metalenguaje con el que se pueden Los documentos XML tienen


definir otros lenguajes de etiquetas, para algn formato de texto, de manera que
uso determinado. Es decir el XML es un son interpretables por los humanos
archivo que contiene una informacin y por las mquinas.
organizada, la cual puede servirnos en general
para compartirla o intercambiarla con otros
sistemas y en particular para servirla a otros
entornos que puedan tratarla a su gusto en
funcin de sus necesidades.
XML se utiliza como lenguaje
intermedio para intercambiar
informacin (obtenerla o
servirla).

Estructura Lgica
Cada archivo XML contiene uno o ms elementos, cuyos lmites estn
delimitados por etiquetas de comienzo y de final.
Cada elemento tiene un tipo, identificado por un nombre y puede tener un
conjunto de especificaciones de atributos.
Cada especificacin de atributo tiene un nombre y un valor.

Estructura Fsica
Un archivo XML puede consistir en una o ms unidades de
almacenamiento, llamadas entidades. Todas estas unidades tienen contenido y
todas ellas estn identificadas por un nombre. Cada archivo XML contiene
una entidad que sirve como punto de partida para el procesador XML y que
puede contener el archivo completo.

Es una arquitectura ms abierta y extensible.


Mayor consistencia, homogeneidad y amplitud de
los identificadores descriptivos.
Integracin de los datos de las fuentes ms
dispares.
Datos compuestos de mltiples aplicaciones.
Gestin y manipulacin de los datos desde el propio
cliente web.
Los motores de bsqueda devolvern respuestas
ms adecuadas y precisas.
72
Exportabilidad a otros formatos de publicacin.
XML consta de cuatro estndares probados y
optimizada para la Webs:

DTD (Document Type Definition): Definicin del


tipo de documento. Es decir, un archivo(s) que
encierra una definicin formal de un tipo de
documento y especfica la estructura lgica de
cada documento.
XSL (eXtensible Stylesheet Language): Define o
implementa el lenguaje de estilo de los
documentos escritos para XML. Permitiendo que
este tipo de archivo sea utilizado ms diseo
archivos XML que encierran datos estructurados
(tablas, organigramas, etc.).
XLL (eXtensible Linking Language): Define el modo
de enlace entre diferentes enlaces.
XUA (XML User Agent): Estandarizacin de
navegadores XML.

Implementaciones con XML.

CDF (Channel Definition Format): Los canales creado por Microsoft en el


explorador IE4 con tecnologa push.
RDF (Resource Description Framework): Esquema de descripcin de
recursos (La capacidad de describir los contenidos y sus relaciones en
una biblioteca digital o sede web).
OSD (Open Software Description Format): Formato abierto de descripcin
de software. Desarrollo de software en multiples plataformas.
CML (Chemical Markup Language): Lenguaje de marcas para qumica.
MathML (Mathematical Markup Language): Lenguaje de marcas para
matemticas. EDI (Electronic Document Interchange): Intercambio
electrnico de datos.
OFX (Open Financial Exchange): Intercambio financiero abierto.
TEI (Text Encoding Initiative): Iniciativa que parti de diversas
asociaciones profesionales en los campos de humanidades.

73
Ejemplo de Aplicaciones del XML

TELEFONIAS MOVILES
A travs de esta solucin los clientes pueden tener acceso a aplicaciones integradas desde los
Telfonos IP:
Envi de mensajes SMS a celular.
Geo ubicacin de flotilla de vehculos o de personas.
Video vigilancia

SISTEMA OPERATIVO ANDROID


Especifica todo el interfaz, la mayora de los mens y/o aplicaciones que cuentan con este
sistema operativo son programados desde java pero utilizando archivos xml.

LA PAQUETERA DE OFFICE
Una de las aplicaciones de los archivos xml con la cual se puede guardar archivos con este
formato (.xml) si se abre en block de notas, aparecer la estructura de este tipo de archivos.
Se puede ver que tiene la primera lnea indispensable para indicar que es un archivo xml. L

LA UTILIZACIN DE ESTOS ARCHIVOS SE DEBE :


Archivos compactos: Los archivos se comprimen automticamente y pueden llegar
a ser un 75 por ciento ms pequeos en algunos casos. El formato XML usa
tecnologa de compresin zip para almacenar los documentos, lo que ofrece un
ahorro potencial de costos puesto que reduce el espacio de disco necesario para
almacenar los archivos.
Mejoras en la recuperacin de archivos daados: Los archivos se estructuran de una
forma modular que mantiene los diferentes componentes de datos del archivo
independientes entre s. Esto permite abrir los archivos aunque algn componente
del archivo est daado o alterado.
Mayor privacidad y ms control de la informacin personal: Los archivos se pueden
compartir confidencialmente, ya que la informacin de carcter personal y la
informacin profesional confidencial.

74
Cmo crear un archivo con extensin .xml.?

Existe un programa de Office SharePointServer el cual permite crear el archivo en una


pgina web (contando con una URL podr hacerse la siguiente aplicacin en java)

package trabajo;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.StringReader;
import java.net.URL;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;

public class Trabajo {

public static void main(String argv[]) {

try {
URL url=new URL("(tiene costo) ");
BufferedReader br = new BufferedReader(new InputStreamReader(url.openStream()));
String entrada;
String cadena="";

while ((entrada = br.readLine()) != null){


cadena = cadena + entrada;
}

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();


DocumentBuilder db = dbf.newDocumentBuilder();

InputSource archivo = new InputSource();


archivo.setCharacterStream(new StringReader(cadena));

Document documento = db.parse(archivo);


documento.getDocumentElement().normalize();

NodeList nodeLista = documento.getElementsByTagName("descarga");


System.out.println("Mis mensajes");
for (int s = 0; s < nodeLista.getLength(); s++) {

Node primerNodo = nodeLista.item(s);


75
String nombre;
String apellido;
String fecha;
String texto;

if (primerNodo.getNodeType() == Node.ELEMENT_NODE) {

Element primerElemento = (Element) primerNodo;

NodeList primerNombreElementoLista
=primerElemento.getElementsByTagName("nombre");
Element primerNombreElemento = (Element)
primerNombreElementoLista.item(0);
NodeList primerNombre = primerNombreElemento.getChildNodes();
nombre = ((Node) primerNombre.item(0)).getNodeValue().toString();
System.out.println("Nombre : " + nombre);

NodeList segundoNombreElementoLista =
primerElemento.getElementsByTagName("apellido");
Element segundoNombreElemento = (Element)
segundoNombreElementoLista.item(0);
NodeList segundoNombre = segundoNombreElemento.getChildNodes();
apellido = ((Node) segundoNombre.item(0)).getNodeValue().toString();
System.out.println("Apellido : " + apellido);

NodeList tercerNombreElementoLista =
primerElemento.getElementsByTagName("fecha");
Element tercerNombreElemento = (Element) tercerNombreElementoLista.item(0);
NodeList tercerNombre = tercerNombreElemento.getChildNodes();
fecha = ((Node) tercerNombre.item(0)).getNodeValue().toString();
System.out.println("Hits : " + fecha);

NodeList cuartoNombreElementoLista =
primerElemento.getElementsByTagName("texto");
Element cuartoNombreElemento = (Element) cuartoNombreElementoLista.item(0);
NodeList cuartoNombre = cuartoNombreElemento.getChildNodes();
texto = ((Node) tercerNombre.item(0)).getNodeValue().toString();
System.out.println("Mensaje : " + texto);

}
}
}
catch (Exception e) {
e.printStackTrace();
}
}

76
4.3. Organizacin de archivos no estructurados.

Contiene datos sin tipos pre-


definidos. El usuario se encarga de
definir los datos que utilizara en este
tipo de estructuras como por Se almacenan en dispositivos de
ejemplo en los archivos XML que almacenamiento secundario, que por regla
estn basados en etiquetas y las general es el disco duro. (Obviamente,
crea el usuario. tambin pueden ser almacenado en cintas,
memorias..etc).

Se almacenan como documentos u


objetos sin estructura uniforme. Que
sus campos no son iguales del mismo
tamao o tipo, sus cambios en la
estructura pueden ser muy bruscos. La informacin basada en estos archivos:
Crece ms rpidamente
Ocupa ms espacio
Se retiene por ms tiempo

Ejemplos:
Un programa (Java, C++, C, Perl)
Los documentos de procesamiento de
texto
Las presentaciones
Los archivos de imgenes y vdeo
Las imgenes de mquinas virtuales El nombre asociado a estos archivos slo
representa una funcin lgica, no de
dependencia fsica. Su nombre se utiliza
para hacer referencia al archivo, tiene que
ser nico entre los nombres de archivos
lgicos de la base de datos y no incluye la
ruta de acceso al archivo.
Restricciones para este tipo de archivos:
nombre no mayor de 255 caracteres
no usar meta-caracteres del SHELL
evitar comenzar con un nmero
tener en cuenta que un nombre comenzado
con un punto, significa un archivo oculto.

77
Implementacin

Generalmente se utilizan programas para crear o visualizar una


imagen con cualquier formato que se almacenen, los programas
pueden ser desde Paint hasta un programa ms especializado como
Photoshop, las extensiones se dividen en un sinfn como pueden ser
BMP, TIFF, GIF, PNG, JPEG o JPEG.

Sin embargo aparte de esto hay


varios programas en los que se
puede visualizar las imgenes,
segn el lenguaje que maneja
cada programa.

Aqu se cre una imagen en el programa PAINT con extensin .png, el cual genera su
archivo no estructurado.

En el programa Windows Media


Center se muestra pues comprende el
lenguaje con el cual fue creada.

78
Pero al intentar visualizar esa
imagen con un editor de texto
llamado Notepad no muestra la
imagen si no que se muestra la
estructura de lo que el entendi al
momento de que le llega el archivo
de intercambio.

79
Conclusin

Son archivos no estructurados:


Tienen un modelo o estructura,
es decir, se caracterizan por
tener forma de componer el
archivo

Permiten tener una bsqueda ms


efectiva, precisa y en orden. Ya
que estn organizados bajo ciertas
norma estrictas para un mejor
control de la informacin.
Son independientes, no necesitan
de una plataforma especfica para
su uso.

El futuro de estos archivos, va


ms all de una simple
organizacin, sino una gran
importancia en el mundo Web
(internet) y comunicaciones
locales (Servidores en el mundo)

80
4. VISUALIZACIN DE INFORMACIN.

Ante el crecimiento tan vertiginoso en la cantidad de informacin, se hace prcticamente


imposible para una persona poder extraer conclusiones, tendencias y patrones a partir de los
datos crudos. Es aqu donde la visualizacin hace su aporte significativo y la exploracin de
distintos conjuntos de datos se beneficia enormemente si cuenta con un soporte adecuado
de visualizacin.
El principal objetivo de la Visualizacin es la representacin perceptual adecuada tanto de
los datos con parmetros mltiples como de las tendencias y las relaciones subyacentes que
existen entre ellos. Su propsito no es la creacin de las imgenes en s mismas sino el
insigth, es decir, la asimilacin rpida de informacin o monitoreo de grandes cantidades de
datos. La Visualizacin es parte de los nuevos medios hechos posible debido al desarrollo
de la visualizacin en computadoras en tiempo real.
La cantidad de aplicaciones en Visualizacin es grande y crece constantemente siendo
actualmente un rea de activo desarrollo. En muchas aplicaciones, los conjuntos de datos
que deben manejarse son miles de veces ms numerosos que la cantidad de pixeles en un
display y las tcnicas de visualizacin que inicialmente estaban motivadas solamente por
percepciones visuales se han diversificado. As como los usuarios creativos empujan los
lmites de las herramientas actuales, los diseadores sern presionados para proveer an
mayor funcionalidad. Tambin cabe sealar que un requerimiento fundamental de la
visualizacin, es que d una respuesta en tiempos interactivos. Los mtodos utilizados en
las distintas ramas de la visualizacin son, en su mayora, de gran costo computacional y es
por ello que, para lograr una visualizacin en tiempos interactivos, es imperativo contar con
mtodos adecuados para los distintos conjuntos de datos.

81
En entornos inteligentes las aplicaciones conscientes de contexto permiten conseguir
interfaces naturales, incluso servicios basados en interaccin implcita que utilizan todo este
conocimiento de su entorno para facilitar el da a da de los usuarios, de forma sencilla. Una
nueva apuesta se basa en aplicar la consciencia de contexto para proporcionar informacin
adaptativa a los usuarios a travs de los dispositivos y gracias a la tecnologa de
identificacin por radiofrecuencia, todos ello embebido en el entorno y transparente al
usuario. La Inteligencia Ambiental es un paradigma que promete cambiar de forma radical
la vida diaria de las personas. Puede entenderse como un paraguas que abarca la
computacin ubicua (Weiser, 1993), las interfaces naturales (Coen, 1998) y las
comunicaciones ubicuas (Chen, & Kotz, 2000), pero que se alimenta de otras muchas
agentes inteligentes artificiales, entre otras.

En los ltimos aos, esta habiendo grandes esfuerzos entre los investigadores para obtener
nuevas formas de interaccin con los dispositivos computacionales de forma ms simple y,
sobre todo, ms natural. En este sentido se est trabajando en el campo de la computacin
ubicua, que, segn la visin inicial de Weiser (Weiser, 1991) representa la desaparicin del
actual computador como una herramienta para todo. Weiser propuso distribuir la
computadora en pequeos dispositivos de funcionalidad reducida y omnipresentes en el
entorno. Con este enfoque se puede acercar a una interaccin intuitiva y conseguir que el
usuario pueda centrarse plenamente en la tarea a realizar sin preocuparse en absoluto de la
herramienta. En la interaccin tradicional (explcita) el usuario debe especificarle al sistema
todos los detalles de la tarea que desea realizar en interfaces demasiado sofisticadas, un
enfoque no vlido si se busca acercarse a la computacin invisible. Se define la
interaccin persona-computador implcita (iHCI) como la interaccin de una persona con el
entorno y con los dispositivos encargados de ayudar para un fin; con este proceso el sistema
adquiere entradas implcitas del usuario para proporcionarle salidas implcitas. Se puede
observar con claridad que el contexto del usuario toma un papel fundamental como fuente
de informacin que suple la ausencia de entradas explcitas del usuario. Se necesita, por
tanto, desarrollar aplicaciones conscientes del contexto (context-awareness).

82
La informacin de contexto, es imprescindible para conseguir interfaces ms naturales as
como para poder ofrecer servicios cuya interaccin con el usuario sea implcita, es una
informacin por s misma catica, a la vez que demasiado amplia y genrica como para
tenerla en cuenta sin un anlisis conciso previo. En primer lugar qu se entiende por
contexto? En la literatura existe multitud de definiciones; si se decanta por la de A. Dey:
Contexto es cualquier informacin que pueda ser utilizada para caracterizar la situacin de
una entidad, entendiendo entidad como una persona, lugar u objeto considerado relevante
para la interaccin entre el usuario y la aplicacin. Se trata de una definicin interesante
para centrar los objetivos pero para poder aprovechar las bondades del contexto se debe dar
respuesta de las siguientes preguntas: Quin (el perfil del usuario), despliega el Qu (la
actividad a realizarse, en este caso servicios de visualizacin de informacin) en Dnde (el
lugar en que se realizaran las actividades) Cundo (dependiendo de las agendas de cada
usuario) y Por qu (Interaccin implcita).
Es necesario definir una ontologa para ofrecer una especificacin explcita de servicios en
ambientes conscientes de contexto, definida en forma modular para hacerla ms general y
aplicable a diferentes servicios. A travs de esta especificacin formal se consiguen
mecanismos para usar y compartir el conocimiento, tanto entre humanos como entre
aplicaciones o mquinas, consiguiendo una comprensin mejor. La ontologa debe estar
enfocada al dominio de discurso de la inteligencia ambiental, concretada en el servicio de
visualizacin de informacin. Para ello se definen de forma progresiva la especializacin de
los conceptos que intervienen (clases), las propiedades de cada clase que describen varias
caractersticas o atributos de cada concepto (propiedades o roles) as como las relaciones
entre clases, llegando cada vez a un menor nivel de abstraccin.
Es importante aprovechar las tres utilidades fundamentales de las ontologas:
En primer lugar mejorando la comunicacin tanto entre humanos, como entre sistemas y
entre humanos y los sistemas computacionales. El objetivo es consensuar el conocimiento
de la porcin de realidad modelada. En segundo lugar la ontologa permite la organizacin
y reutilizacin del conocimiento. Por ltimo la ontologa es fundamental para la inferencia
computacional.

83
Es importante considerar en este apartado que el valor de cualquier sistema de
informacin est condicionado por la calidad y cantidad de informacin contenida,
pero al mismo tiempo por su findability o facilidad para encontrar dicha informacin,
cualidad que naturalmente disminuir conforme aumente el tamao del sistema.

No es de extraar, por tanto, que la investigacin en tcnicas de acceso y recuperacin de


informacin haya experimentado su mayor auge con el advenimiento de un sistema de
informacin de gigantesco volumen, y crecimiento exponencial, como la World Wide Web.
El estudio de la problemtica del acceso a la informacin comnmente se divide en dos
modelos de acceso a la informacin, diferenciados en funcin del sentido en el que se
produce dicho acceso: Push y Pull. En el modelo Push o Filtrado de Informacin, el
sistema regularmente informa o alerta al usuario sobre aquellos documentos de nueva
incorporacin o publicacin cuya temtica se corresponde con el perfil o intereses
previamente definidos por el usuario. Se trata por tanto de una estrategia pasiva, por parte
del usuario, de acceso a la informacin. En el modelo Pull o Recuperacin de
Informacin, es el usuario el que, de forma activa, busca y accede a la informacin
necesitada. Las estrategias que utiliza el usuario para recuperar informacin se pueden
dividir en dos:
grandes clases: querying (interrogacin) y browsing (exploracin).
En el querying el usuario introduce en el sistema una serie de palabras clave
(representacin de sus necesidades de informacin), tras lo que el sistema le devuelve una
lista de resultados pertinentes para su consulta, normalmente ordenada por relevancia. El
ejemplo ms popular de sistema de recuperacin de informacin basado en querying es
Google.
Los sistemas basados en querying resultan tiles y muy eficientes en multitud de casos. Sin
embargo, cuando el usuario no tiene completamente claro qu est buscando o, cuando es
incapaz o tiene dificultades para formalizar sus necesidades de informacin a travs del
lenguaje de consulta, requiere de un modelo alternativo de acceso a la informacin.
En la estrategia de recuperacin por browsing, en oposicin al querying, el usuario explora
visual y espacialmente el conjunto documental, sin necesidad de tener que expresar de

84
forma previa cules son sus necesidades de informacin. Es decir, el usuario prefiere
navegar el conjunto documental, y reconocer visualmente qu est buscando, en lugar de
especificar sus necesidades mediante el lenguaje de consulta.
En funcin del grado de especificidad de las necesidades de informacin del usuario existen
entre varios tipos de browsing :
Browsing de bsqueda directa: El usuario sabe qu est buscando.
Browsing de propsito general: El usuario explora fuentes con una
alta probabilidad de resultar de inters.
Browsing fortuito o por serendipia: Es una estrategia de bsqueda
al azar.
El ejemplo ms claro de browsing es la navegacin hipertextual, en la que el usuario
explora visual y espacialmente el conjunto documental: reconoce visualmente la
informacin buscada o aquellos enlaces que cree le llevarn a esta informacin, y se
desplaza por este espacio de informacin saltando de pgina en pgina.
Entre los sistemas de informacin que ofrecen la posibilidad de bsqueda por browsing,
cabe destacar aquellos que proveen de un medio especfico para realizar browsing grfico a
travs de las denominadas Interfaces Visuales de Recuperacin de Informacin o VIRIs
(Visual Information Retrieval Interfaces). El browsing grfico es similar al hipertextual,
pero mientras que el hipertextual nicamente permite explorar los documentos por
separado, el browsing grfico posibilita adems visualizar conjuntos de documentos de
forma global a travs de su abstraccin grfica, no necesariamente textual.
Los VIRIs, por tanto, no slo tienen el objetivo de ayudar al usuario a navegar y recuperar
informacin, sino tambin el de ofrecer una visin global del conjunto documental. A
travs de esta vista global el usuario podr predecir qu puede encontrar, e incluso adquirir
nuevo conocimiento mediante la interiorizacin de la visualizacin.

85
BIBLIOGRAFA

Pratt Terrence W., Zelkowitz MarvinV.;1998, Lenguajes de programacin, diseo e


implementacin, Editorial: Prentice-Hall Hispanoamericana, S.A., Mxico.

86

You might also like