clase 29: Ordenar Archivos

import java.io.*;
Problema. Ordenar un archivo (suponiendo que slo N lneas class Sortfile
caben en memoria) {
Solucin. Algoritmo de Cascada. //arreglo para N lneas
protected static int N=100, n=0;
N de lneas: N N N N protected String[]linea=new String[N];
archivo: ...
public void main(String[]args)throws IOException
ordenar {
arreglo //grabar archivo auxiliar vacio
grabar PrintWriterW B=new PrintWriter(
archivo A1 new FileWriter(A2.txt));
merge B.close();
archivo A2 //abrir archivo y nombrar archivos auxilares
BufferedReader A=new BufferedReader(
merge new FileReader(args[0]));
archivo A1 String in="A2.txt", out="A1.txt";
...
archivo A1/2

//repetir hasta terminar archivo //Leer desde (posicin del cursor de) archivo
while(true) //un mximo de N lneas.
{ //Entregar tambin n de lneas ledas.
//leer n lneas de archivo(max N) en arreglo
n=leerLineas(A,linea,N);
if(n==0) break; static public int leerLineas
(BufferedReader archivo, String[]lineas, int N)
//ordenar arreglo de n lneas throws IOException
quicksort(linea,0,n-1); {
int n=0;
//merge de arreglo y archivo in(resultado en out)
merge(linea,n,in,out);
String linea;
while((linea=archivo.readLine())!=null){
//intercambiar rol de archivos if(n>=N) U.abortar(max de lineas =+N);
String aux=in; in=out; out=aux; lineas[n++] = linea;
} }
A.close(); return n;
U.println("resultado: archivo "+in);
}
}

//merge de arreglo y archivo ordenados //obtener primeros elementos

static public void merge int i=0; //indice primer elemento
(String[]x,int n,String input,String output) String L=I.readLine();//primera lnea
throws IOException
{ //repetir hasta terminar arreglo y archivo
PrintWriter O=new PrintWriter( while(i<n || L!=null)//!(i>=n && L==null)
new FileWriter(output)); {
BufferedReader I=new BufferedReader( //grabar menor (o el que quede) y avanzar
new FileReader(input)); if(i<n && (L==null || x[i].compareTo(L)<=0)){
O.println(x[i]);//grabar elemento
Merge ++i; //siguiente ndice
arreglo archivo I archivo O }else{
sit. inicial O.println(L); //grabar lnea
i cursor cursor L=I.readLine();//sgte lnea
}
invariante }
i cursor cursor I.close(); O.close();
}}

1
clase 29: Ordenar Archivos

clase RandomAccessFile (RAF)

Archivos de Acceso Directo (arreglos en disco) Mtodo Significado ejemplo
ndice posicin registro RandomAccessFile Abre archivo de nombre x RAF A =new RAF
0 0 (String x,String y) (y=rw(read/write) o r). (a.bin,rw);
1 L Cursor al comienzo.
2 2L void seek(long x) posiciona cursor en byte A.seek(x);
... ... ... ubicado en posicin x>=0
N-1 (N-1)L void escribe x, y avanza cursor A.writeInt(10);
Largo Fijo = L writeTipo(Tipo x) en tamao del Tipo escribe 10
(Int, Double, Char) y avanza 4 bytes
Archivos de texto Archivos Acceso Directo Tipo readTipo() lee y entrega valor del tipo A.readDouble()
acceso secuencial acceso directo (por posicin) indicado (y avanza cursor) lee double
lneas de largo variable registros de largo fijo y avanza 8 bytes
long getFilePointer() entrega posicin del cursor A.getFilePointer()
(delimitadas por newline) (sin delimitadores)
lectura o escritura lectura y escritura long length() entrega tamao en bytes A.length()
grabacin en caracteres grabacin en binario del archivo
editable no editable

ordenar archivo de acceso directo public static void quicksort

import java.io.*; (RandomAccessFile archivo,int ip,int iu)
class SortRAF{ throws IOException
protected static int LargoReg;//en bytes {
public static void main(String[]args) //caso base: 0 o 1 registro
throws IOException{ if(ip>=iu) return;
//chequear n de parmetros
if(args.length!=2) //particionar archivo
U.abortar(uso:java SortRAF archivo lreg); int i=particionar(archivo,ip,iu);
//obtener archivo y largo en bytes de registros
RAF archivo=new RAF(args[0],"rw" ); //ordenar primera parte
LargoReg=Integer.parseInt(args[1]); quicksort(archivo,ip,i-1);
//calcular n de registros
final int n=(int)archivo.length()/LargoReg; //ordenar segunda parte
//ordenar con algoritmo para arreglos quicksort(archivo,i+1,iu);
quicksort(archivo,0,n-1); }
}

public static int particionar //leer registro ubicado en ndice

(RAF archivo,int ip,int iu) static public String leerRegistro
throws IOException{ (RAF archivo,int indice)throws IOException{
String pivote=leerRegistro(archivo,ip); archivo.seek(indice*LargoReg);//cursor
int i=ip; String registro="";
for(int j=ip+1; j<=iu; ++j) for(int i=1; i<=LargoReg/2; ++i)
if(leerRegistro(archivo,j).compareTo(pivote)<0) registro += archivo.readChar();
intercambiar(archivo,++i,j); return registro;
intercambiar(archivo,ip,i); }
return i; //grabar registro en ndice
} static public void escribirRegistro
public static void intercambiar (RAF archivo,String registro,int indice)
(RAF archivo,int i,int j)throws IOException{ throws IOException{
String reg_i=leerRegistro(archivo,i), archivo.seek(indice*LargoReg);//cursor
reg_j=leerRegistro(archivo,j); for(int i=0; i<registro.length(); ++i)
escribirRegistro(archivo,reg_i,j); archivo.writeChar(registro.charAt(i));
escribirRegistro(archivo,reg_j,i);
}
}

2
clase 29: Ordenar Archivos

Problema. Reescribir bsqueda binaria para RAF Solucin

static public int indice static public int indice
(Comparable x,Comparable[]y,int ip,int iu) (Comparable x,RAF y,int ip,int iu)
{ throws IOException{
//devolver 1 si x no est en y(o y vaco) //devolver 1 si x no est en y(o y vaco)
if(ip>iu) return 1; //no esta if(ip>iu) return 1; //no esta

//comparar x con elemento que est en la mitad //comparar x con elemento que est en la mitad
int im=(ip+iu)/2; //indice del medio int im=(ip+iu)/2; //indice del medio
int c=x.compareTo(y[im]); int c=x.compareTo(leerRegistro(y,im));

//si son iguales,devolver ndice de mitad //si son iguales,devolver ndice de mitad
if(c==0) return im; if(c==0) return im;

//si no, buscar en mitad del arreglo //si no, buscar en mitad del archivo
if(c<0) iu=im-1; else ip=im+1; if(c<0) iu=im-1; else ip=im+1;
return indice(x,y,ip,iu); return indice(x,y,ip,iu);
} }

Resumen Algoritmos de Bsqueda y Ordenamiento Resumen Estructuras de datos

Formas de organizacin y almacenamiento de datos (en memoria)
problema algoritmo O(x) .txt RAF Obs Sirven para representar Tipos de datos abtractos (TDAs) con
buscar Secuencial n si si mltiples valores. Ej: Stack, Queue, Diccionario, Conjunto,
buscar Binaria log2n no si ordenado Polinomio, etc
buscar Hashing 1 no si
ordenar Seleccin n2 no si arreglo
ordenar Burbuja n2 no si
ordenar Insercin n2 no si
ordenar MergeSort n log2n no si lista enlazada
ordenar QuickSort n log2n no si
ordenar Cascada k N log2N si no para .txt ...

rbol

Clases Stack/Queue Diccionario

new Stack/Queue()
void push/enque(Object x)throws Full
Object pop/deque( )throws Empty
void reset( ) boolean empty/full( )
Object buscar(Object x)
boolean agregar(Object x,Object y)
throws DiccLleno
boolean borrar(Object x)
boolean cambiar(Object x,Object y)
devolver significado de palabra
agregar palabra x con significado y
(false si ya existe)
borrar palabra x (false si no existe)
cambiar significado de palabra x

Tiempos de operaciones Tiempos:

Est de Datos push pop enque deque Estructura de datos buscar agregar borrar cambiar
arreglo 1 1 1 n arreglo ordenado log2n n n log2n
lista enlazada n n n n
arreglo circular 1 1 lista doble enlace n n n n
lista enlazada 1 1 1 n ABB h(altura) h h h
con 1 y ltimo 1 1 ABB balanceado log2n log2n log2n log2n
circular 1 1
lista doble enlace 1 1
n significa O(n), es decir, depende de n de valores
1 significa O(1), es decir, no depende de n de valores

3
clase 29: Ordenar Archivos

CC1001- Computacin I Objetivos

Razonamiento algortmico/lgico
Capacidad modelamiento/abstraccin
Habilidad gral resolver problemas
Problemas
general
Computacin resolver problemas
especfico
escribir programas que resuelvan problemas
de largo plazo (propsitos)
razonamientos algortmico y lgico
capacidades de abstraccin y modelamiento
Soluciones
habilidad general para resolver problemas

Metodologa Contenidos
Pedagoga
1. Fundamentos de programacin
orientacin al aprendizaje
clases de ctedra y auxiliares centradas en problemas 2. Programacin orientada a objetos
ejercicios clases obligatorios 3. Listas y tablas de valores
Tecnologa 4. Computacin numrica
lenguajes Java y Matlab 5. Bsqueda y ordenamiento de informacin
ambiente Internet/web

Evaluacin
NF (nota final): 70%NC+30%NT (NC,NT 4) Ejercicios
NT (nota tareas): promedio 5 tareas (1 por cap)
Si 3NT<4 y NC 4, NF=I + tarea extra se considera promedio promedio promedio
de los 19 mejores c1,c2,c3 ejercicios
NC (nota control): prom ponderado controles
si tiene menos de 19, 5,5 cualquiera
control contenidos semana pond NF=I + tarea(s) extra(s) 5,4 2.0
1 1 4 20 % sirven para eximirse
5,3 2.5
2 2 8 20 % de examen de acuerdo a
la sgte tabla: 5,2 3.0
3 3y4 15 20 %
5,1 3.3
examen 1a5 9 julio 40 %
5,0 3.5