C8G4TA04

Trabajo Práctico N°4 C8G4 Año: 2015
TRABAJO PRÁCTICO N° 4
COMISION: C8
GRUPO: G4
INTEGRANTES:
Brandan, Flavia Daniela DNI: 35.274.908 LU: 6803
Ordoñez, Daiana Ayelén DNI: 38.746.109 LU: 7013
Sutara, Esteban DNI: 37.095.770 LU: 6722
Herrera, Juan Ignacio DNI: 38.656.275 LU: 1415

CEA:
program CEA;
uses crt;
type
2
TEmpleado = record
legajo: integer;
nombre: String[50];
sector: char;
ingreso: integer;
estado: integer;
end;
TVector = array[1..100]of TEmpleado;
var
empleados: TVector;
n,opc,legajo,pos: integer;
procedure menu(var opc: integer);
begin
writeln('*******************************************');
writeln('* 1- Ingresar Datos *');
writeln('* 2- Mostrar *');
writeln('* 3- Mostrar por estado *');
writeln('* 4- Buscar por Legajo(mostrar) *');
writeln('* 5- Ordenacion de legajo (metodo rapido) *');
writeln('* 6- Agregar dato *');
writeln('* 7- Modificar estado *');
writeln('* 0- Salir *');

writeln('*******************************************');
write('Ingrese una opcion: ');
readln(opc);
end;
3
procedure cargarDatos(var empleados:TVector; var n: integer);
var
i,estado1:integer;
begin
write('Ingrese la cantidad de empleados: ');
readln(n);
for i := 1 to n do
with empleados[i] do
begin
writeln;
write('Legajo: '); readln(legajo);
write('Nombre: '); readln(nombre);
write('Sector: '); readln(sector);
write('Ingreso: '); readln(ingreso);
write('Estado: ');
repeat
readln(estado1);
if (estado1>=0) and (estado1<=3) then
estado:=estado1
else
WriteLn('opcion invalida, vuelva a ingresar');
until (estado1>=0) and (estado1<=3);

end;
end;
procedure mostrarEmpleado(e: TEmpleado);

4
begin
with e do
begin
writeln('Legajo: ',legajo);
writeln('Nombre: ',nombre);
writeln('Sector: ',sector);
writeln('Ingreso: ',ingreso);
writeln('Estado: ',estado);
end;
writeln;
end;
procedure mostrarDatos(empleados:TVector; n: integer);
var
i:integer;
begin
writeln('Lista de empleados');
writeln('==================');
for i := 1 to n do
mostrarEmpleado(empleados[i]);
readkey;
end;
Procedure Swap(Var X, Y : TEmpleado);
Var
Temp: TEmpleado;
Begin
5
Temp:= X;
X:= Y;
Y:= Temp
End;
Procedure ShellSort(Var A : TVector; N : Integer);
Var
Done: Boolean;
Jump,
I,J : Integer;
Begin
Jump := N;
While (Jump > 1) Do
Begin
Jump := Jump Div 2;
Repeat
Done := true;
For J := 1 To (N - Jump) Do
Begin
I := J + Jump;
If (A[J].nombre > A[I].nombre) Then
Begin
Swap(A[J], A[I]);
Done := false
End;
End;
Until Done;
6
End
End;
procedure mostrarPorEstado(A:TVector; n:integer);
var
i, estado: integer;
begin
writeln('Ingrese el estado: ');
readln(estado);
ShellSort(A,n);
for i := 1 to n do
if(A[i].estado = estado) then
mostrarEmpleado(A[i]);
end;
procedure QuickSort(l,r:integer; var v:TVector);
var
i,j:integer;
x:integer;
aux: TEmpleado;
begin
i:=l;
j:=r;
x:=v[(l+r) div 2].legajo;

repeat
while v[i].legajo<x do
inc(i);
while v[j].legajo>x do
7
dec(j);
if i<=j then
begin
aux:=v[i];
v[i]:=v[j];
v[j]:=aux;
inc(i);
dec(j);
end;
until i>j;
if l<j then
QuickSort(l,j,v);
if l<r then
QuickSort(i,r,v);
end;
function BusquedaBinaria (V: TVector; n, elem : integer ):integer;
var E,D,medio : integer ;
encontrado : boolean ;
begin
E := 1 ; D := n ;
encontrado := false;
while ( (E <= D) and not(encontrado) ) do

begin
medio := (E+D) div 2;
if (V[medio].legajo = elem) then
encontrado := true
8
else
if (V[medio].legajo < elem) then
E := medio + 1
else
D := medio - 1;
end;
if ( encontrado ) then
BusquedaBinaria := medio
else
BusquedaBinaria := 0;
end;
procedure buscarPorLegajo(A:TVector; n:integer);
var
legajo, pos: integer;
begin
write('Ingrese legajo: ');
readln(legajo);
QuickSort(1,n,A);
pos := BusquedaBinaria(A, n, legajo);
if (pos <> 0) then

mostrarEmpleado(A[pos])
else
writeln('No existe...');
readkey;
9
end;
procedure agregar(var empleados:tvector; var n:integer; legajo:integer);
var
i:integer;
begin
n:=n+1;
writeln('Ingrese nombre');
readln(empleados[n].nombre);
empleados[n].legajo:=legajo;
writeln('Ingrse sector');
readln(empleados[n].sector);
Writeln('Ingrese el ingreso');
readln(empleados[n].ingreso);
writeln('Ingrese el estado');
readln(empleados[n].sector);
end;
procedure buscarEmpleado(var Empleados:Tvector; var n: integer);
var legajo: integer;
pos: integer;
begin
write('Ingrese el legajo: ');
readln(legajo);
pos := BusquedaBinaria(empleados, n, legajo);
if(pos = 0)then
begin
writeln('No existe el empleado...');

10
pos:=1;
agregar(empleados,n,legajo);
end
else
mostrarempleado(empleados[pos]);
end;
procedure Modificar(var empleados:tvector; n:integer;pos:integer);
var
estado2:integer;
begin
writeln('Realice la modificacion del sector');
repeat
readln(estado2);
if (estado2>=0) and (estado2<=3) then
empleados[pos].estado:=estado2
else
WriteLn('opcion invalida, vuelva a ingresar');
until (estado2>=0) and (estado2<=3);
end;
begin
repeat
clrscr;
menu(opc);
case opc of
11
1: cargarDatos(empleados,n);
2:
begin
if n>0 then
mostrarDatos(empleados,n)
else
writeln('Debe cargar primero');
end;
3:
begin
if n>0 then
begin
mostrarPorEstado(empleados, n);
readkey;
end
else
end;
4:
begin
if n>0 then
buscarPorLegajo(empleados,n)
else
end;
5:
12
begin
if n>0 then
begin
QuickSort(1,n,empleados);
mostrarDatos(empleados,n);
end
else
end;
6:
begin
if n>0 then
buscarEmpleado(Empleados, n)
else
end;
7:
begin
if n>0 then
begin
writeln('Ingrese el legajo');
readln(legajo);
pos := BusquedaBinaria(empleados, n, legajo);
if(pos = 0)then
writeln('No existe el empleado...')
else
13
begin
Modificar(empleados, n,pos);
mostrardatos(empleados,n);
end;
end
else
end;
0: writeln('Fin del programa...');
else
writeln('Opcion incorrecta...')
end;
until opc = 0;
end.
Punto 1
Vector original
Z X E C T W A Y B M E
Divido n a la mitad(5), comparó: Z<W no, realizo el intercambio
W X E C T Z A Y B M E
Comparó C<A: NO, realizo el intercambio,
W A E C T Z X Y B M E
Comparó E<Y: Si, No realizo intercambio,
Comparó C<B: No, realizo intercambio,
W A E B T Z X Y C M E
14
Comparó T<M: No, realizó el intercambio,
W A E B M Z X Y C T E
Comparó Z<E: No, realizó el intercambio,
W A E B M E X Y C T Z
Ahora con distancia 2 (5/2=2.5):
Comparó W<E: No, realizó el intercambio,
E A W B M E X Y C T Z
Comparó W<M: No, realizo el intercambio,
E A M B W E X Y C T Z
Comparó W<X: Si, se mantiene igual,
E A M B W E X Y C T Z
Comparó X<C: No, realizó el intercambio,
E A M B W E C Y X T Z
Comparó X<Z: Si, se mantiene igual,
Comparó A<B: Si, se mantiene igual,
Comparó B<E: Si, se mantiene igual,
Comparó E<Y: Si, se mantiene igual,
Comparó Y<T: No, realizamos el intercambio,

E A M B W E C T X Y Z
Comparó E<M: Si, se mantiene igual,
Comparó M<W: Si, se mantiene igual,
Comparó W<C: No, realizó el intercambio,

15
E A M B C E W T X Y Z
Comparó A<B: SI, se mantiene igual,
Comparó B<E: Si, se mantiene igual,
Comparó E<T: Si, se mantiene igual,
Comparó T<Y: Si, se mantiene igual,
Comparó M<C: NO, realizó el intercambio,
E A C B M E W T X Y Z
Comparó M<W: Si, se mantiene igual,
Vector resultante, luego de las comparaciones:
C A E B M E W T X Y Z
Distancia 1:
Comparó C<A: No, realizó el intercambio;
A C E B M E W T X Y Z
Comparó C<E: Si, se mantiene igual,
Comparó E<B: No, realizó el intercambio,
A C B E M E W T X Y Z

Comparó M<E: No, realizó el intercambio,
A C B E E M W T X Y Z
Comparó M<W: si, se mantiene igual,
Comparó W<T: Si, se mantiene igual,

16
Comparó T<X: si, se mantiene igual,
Comparó X<Y: si, se mantiene igual,
Comparó Y<Z: si, se mantiene igual,
Comparó, de nuevo:
A<C: SI; C<B: NO, realizó el intercambio;
A B C E E M W T X Y Z
C<E: SI; E<E: NO (pero no se modifica nada); E<M: si; M<W: Si; W<T: NO, realizó el intercambio:
A B C E E M T W X Y Z
W<X: SI; X<Y:SI, Y<Z:SI.
Gap: 5,3,1
Distancia 5, comparó: Z<W no, realizo el intercambio
W X E C T Z A Y B M E
Comparó C<A: NO, realizo el intercambio,
Comparó E<Y: Si, No realizo intercambio,
Comparó C<B: No, realizo intercambio,
W A E B T Z X Y C M E
Comparó T<M: No, realizó el intercambio,
W A E B M Z X Y C T E
Comparó Z<E: No, realizó el intercambio,
W A E B M E X Y C T Z
Distancia 3:
B A E W M E T Y C X Z
B A E W M E T Y C X Z
Luego, de realizar las comparaciones obtenemos el siguiente vector:

17
A B E M E W T C Y X Z
A B E E M W C T Y X Z
A B E E M C W T Y X Z
A B E E C M W T Y X Z
A B E C E M W T Y X Z
A B C E E M W T Y X Z
Vector resultante:
A B C E E M W T Y X Z
Se observa, que el método Shellsort, la primera parte comparando con el segundo (gap
5,3,1), toma más tiempo, por la distancia 5,2,1 que la segunda parte.
Punto 2
100 25 18 2 36 11 1 67 39 18 3
Comparó 100<3: NO, realizamos intercambio
Vector resultante;
3 25 18 2 36 11 1 67 39 18 100
Comparó el 25<100: SI, (queda tal como está)
3 25 18 2 36 11 1 67 39 18 100
Comparo el 18<100: si (queda tal como está)
3 25 18 2 36 11 1 67 39 18 100
Comparo el 2<100: SI (queda tal como está)
3 25 18 2 36 11 1 67 39 18 100

3 25 18 2 36 11 1 67 39 18 100
3 25 18 2 36 11 1 67 39 18 100

18
3 25 18 2 36 11 1 67 39 18 100
3 25 18 2 36 11 1 67 39 18 100
3 25 18 2 36 11 1 67 39 18 100
3 25 18 2 36 11 1 67 39 18 100
22Comparó el 3<18: Si (queda tal como está)
3 25 18 2 36 11 1 67 39 18 100
Comparó el 3<39: SI (queda tal como está);
3 25 18 2 36 11 1 67 39 18 100
Comparó el 3<67: SI (queda tal como está)
3 25 18 2 36 11 1 67 39 18 100
Comparó el 3<1: NO (Realice intercambio)
1 25 18 2 36 11 3 67 39 18 100
Comparó el 25<3: NO (Realice el intercambio)
1 3 18 2 36 11 25 67 39 18 100
Comparó el 3<11 :SI (queda tal como está)
1 3 18 2 36 11 25 67 39 18 100
Comparó el 3<36 :SI (queda tal como está)
1 3 18 2 36 11 25 67 39 18 100
Comparó el 3<2 : NO (Realice el intercambio)

1 2 18 3 36 11 25 67 39 18 100
1 2 3 18 36 11 25 67 39 18 100

19
1 2 3 18 36 11 25 67 39 18 100
1 2 3 18 36 11 25 67 39 18 100
1 2 3 18 36 11 25 67 39 18 100
Comparó el 36<18 NO (Realice el intercambio)
1 2 3 18 18 11 25 67 39 36 100
1 2 3 18 18 11 25 67 39 36 100
1 2 3 18 18 11 25 67 39 36 100
1 2 3 18 18 11 25 67 39 36 100
1 2 3 18 11 18 25 67 39 36 100
1 2 3 11 18 18 25 67 39 36 100
1 2 3 11 18 18 25 67 39 36 100
1 2 3 11 18 18 25 67 39 36 100

1 2 3 11 18 18 25 67 39 36 100
1 2 3 11 18 18 25 67 39 36 100

20
1 2 3 11 18 18 25 67 39 36 100
1 2 3 11 18 18 25 36 39 67 100
1 2 3 11 18 18 25 36 39 67 100
1 2 3 11 18 18 25 36 39 67 100
VECTOR ORDENADO
1 2 3 11 18 18 25 36 39 67 100
El orden que tiene el método rápido (quick sort) es O(n·log n), se basa en el hecho que
los intercambios deben ser realizado sobre distancias grandes. El pivote es cualquier
elemento de la lista a ordenar, buscó la posición que le corresponda , acomodamos a la
izquierda los >x y a la derecha <x y por de la recursividad ordenamos. La desventaja de este
método es que se base en mucha recursividad, mucha diferencia entre el peor y el mejor caso,
(el mejor de los casos, cuando el pivote queda en el centro, peor de los casos cuando el pivote
se inclina hacia un lado).
Punto 3
program punto3;
uses
crt;
type
tvector = array[1..100] of integer;
var
w:tvector;
t:tvector;
n:integer;
Procedure cargarvector(var w:tvector; var t:tvector; var n:integer);

21
var
i, op:integer;
begin
i:=0;
repeat
i:=i+1;
Writeln('Ingrese los valores');
readln(w[i]);
t[i]:=i;
writeln('Desea continuar(0 para salir)');
readln(op);
until op=0;
n:=i
end;
procedure Mostrarvector(w:tvector;t:tvector;n:integer);
var
i:integer;
begin
i:=0;
writeln('Valores del vector');
writeln('******************');
for i:=1 to n do
Writeln('valor ',i,': ',w[i],' ','valor del vector indice (t) ',t[i])
end;
22
procedure Mostrarvectorresultante(w:tvector;t:tvector;n:integer);
var
i:integer;
begin
i:=0;
writeln('Valores del vector');
writeln('******************');
for i:=1 to n do
Writeln('valor ',i,': ',w[t[i]],' ','valor del vector indice (t) ',t[i])
end;
procedure Quick_Sort(l,r:integer; var w:tvector;var t:tvector);
var
i,j,x,aux:integer;
begin
i:=l;
j:=r;
x:=w[(l+r) div 2];
repeat
while w[i]<x do inc(i);
while w[j]>x do dec(j);
if i<=j then
begin
aux:=t[i];
t[i]:=t[j];
t[j]:=aux;
23
inc(i);
dec(j);
end;
until i>j;
if l<j then Quick_Sort(l,j,w,t);
if l<r then Quick_Sort(i,r,w,t);
end;
begin
cargarvector(w,t,n);
Mostrarvector(w,t,n);
Quick_Sort(1,n,w,t);
Mostrarvectorresultante(w,t,n);
readkey;
end.
Punto 4
program TP4P4;
uses crt;
type
TR=record
C1:integer;
C2:char;
C3:real;
end;
TMatriz= array[1..100,1..100] of TR;
var
24
Matriz:TMatriz;
op,n,m:integer;
procedure menu( var op:integer);
begin
writeln('***************MENU*****************************');
writeln('** 1: Cargar datos. **');
writeln('** 2: Mostrar datos. **');
writeln('** 3: Ordenar por fila. **');
writeln('** 4: Ordenar por columna. **');
writeln('** 5: Salir. **');
write('Ingrese una opcion:');
readln(op);
clrscr;
end;
Procedure cargarVector(var V:TR);
begin
write('Ingrese el dato de tipo entero : ');
readln(V.c1);
write('Ingrese el dato de tipo caracter: ');
readln(V.c2);
write('Ingrese el dato de tipo real : ');
readln(V.c3);
end;
procedure cargarMatriz(var X:TMatriz;var n,m:integer);
var i,j: integer;

25
begin
write('Ingrese la cantidad de filas: ');
readln(n);
write('Ingrese la cantidad de columnas: ');
readln(m);
for i:=1 to n do
for j :=1 to m do
begin
writeln('Ingrese los datos para la posicion [',i,',',j,']: ');
cargarVector(X[i,j]);
end;
end;
Procedure MostrarVector(V:TR);
begin
write('Dato de tipo entero : ');
writeln(V.c1);
write('Dato de tipo caracter: ');
writeln(V.c2);
write('Dato de tipo real : ');
writeln(V.c3:7:3);
end;
Procedure MostrarMatriz(X:TMatriz;n,m:integer);
var i,j:integer;
begin
for i :=1 to n do
26
begin
writeln();
for j:=1 to m do
begin
writeln();
writeln('Posicion [',i,',',j,']: ');
MostrarVector(X[i,j]);
end;
end;
readkey;
end;
Procedure Swap(Var X, Y : TR);
Var
Temp: TR;
Begin
Temp:= X;
X:= Y;
Y:= Temp
End;
Procedure ShellSortFila(Var X:TMatriz;N:integer);
Var
Done: Boolean;
Jump,I,J,f : Integer;
Begin
write('Ingrese la fila a ordenar: ');
readln(f);
27
Jump := N;
While (Jump > 1) Do
Begin
Jump := Jump Div 2;
Repeat
Done := true;
For J := 1 To (N - Jump) Do
Begin
I := J + Jump;
If (X[f,J].c2 > X[f,I].c2) Then
Begin
Swap(X[f,J], X[f,I]);
Done := false
End;
End;
Until Done;
End
End;
Procedure ShellSortColumna(Var X:TMatriz;M:integer);
Var
Done: Boolean;
Jump,I,J,c: Integer;
Begin
write('Ingrese la columna a ordenar: ');
readln(c);
Jump := M;
28
While (Jump > 1) Do
Begin
Jump := Jump Div 2;
Repeat
Done := true;
For J := 1 To (M - Jump) Do
Begin
I := J + Jump;
If (X[J,c].c2 > X[I,c].c2) Then
Begin
Swap(X[J,c], X[I,c]);
Done := false
End;
End;
Until Done;
End
End;
begin
n:=0;
m:=0;
op:=0;
repeat
menu(op);
case op of
1: cargarMatriz(matriz,n,m);
2: MostrarMatriz(matriz,n,m);
29
3:begin
ShellSortFila(matriz,N);
MostrarMatriz(matriz,n,m);
end;
4:begin
ShellSortColumna(matriz,M);
MostrarMatriz(matriz,n,m);
end;
5:writeln('Salir');
else
writeln('Opcion incorrecta..');
end;
until (op=5);
end.
Punto 5
program punto5;
uses
crt;
type
TPersona = record
nombre:string[50];
sueldo:real;
end;
TVectorEmpleados = array[1..100] of TPersona;

30
var
empleado: TVectorEmpleados;
n: integer;
Procedure CargarEmpleados(var empleado: TVectorEmpleados; n: integer);
begin
begin
with empleado[1] do
begin
nombre := 'Mendez';
sueldo := 899.5;
end;
end;
begin
with empleado[2] do
begin
nombre := 'Ramos';
sueldo := 2575.3;
end;
end;
begin
with empleado[3] do
begin
nombre := 'Mamani';
sueldo := 1896.5;
end;
31
end;
begin
with empleado[4] do
begin
nombre := 'Tolaba';
sueldo := 789.2;
end;
end;
begin
with empleado[5] do
begin
nombre := 'Condori';
sueldo := 3582.7;
end;
end;
begin
with empleado[6] do
begin
nombre := 'Tolaba';
sueldo := 1010.9;
end;
end;
begin
with empleado[7] do
begin
nombre := 'Aban';
32
sueldo := 507.9;
end;
end;
begin
with empleado[8] do
begin
nombre := 'Lamas';
sueldo := 4754.7;
end;
end;
begin
with empleado[9] do
begin
nombre := 'Gomez';
sueldo := 695.9;
end;
end;
begin
with empleado[10] do
begin
nombre := 'Cruz';
sueldo := 2566.8;
end;
end;
begin
33
begin
nombre := 'Abalos';
sueldo := 775.6;
end;
end;
begin
begin
nombre := 'Ramirez';
sueldo := 2000.8;
end;
end;
begin
begin
nombre := 'Acosta';
sueldo := 1555.6;
end;
end;
n:=13
end;
procedure Seleccion(var empleado: TVectorEmpleados ; n: integer);
var
i,k,j:integer;
y:TPersona;
34
begin
For I := 1 To (N - 1) Do
Begin
K := I;
Y := empleado[I];
For J := (I + 1) To N Do
If (empleado[J].nombre < Y.nombre) Then
Begin
K := J;
Y := empleado[J];
End;
empleado[K] := empleado[I];
empleado[I] := Y;
End;
writeln('La ordenacion por Seleccion a finalizado...');
end;
procedure SeleccionSueldo(var empleado: TVectorEmpleados ; n: integer);
var
i,k,j:integer;
y:TPersona;
begin
For I := 1 To (N - 1) Do
Begin
K := I;
Y := empleado[I];
For J := (I + 1) To N Do
35
If (empleado[J].sueldo < Y.sueldo) Then
Begin
K := J;
Y := empleado[J];
End;
empleado[K] := empleado[I];
empleado[I] := Y;
End;
writeln('La ordenacion por Seleccion a finalizado...');
end;
procedure MostrarEmpleado(var empleado: TVectorEmpleados; n: integer);
var
i: integer;
begin
for i:=1 to 13 do
begin
with empleado[i] do
begin
writeln('----------Empleados----------');
writeln(nombre);
writeln(sueldo:7:2);
writeln;
end;
end;
end;
36
begin
CargarEmpleados(empleado, n);
Seleccion(empleado, n);
SeleccionSueldo(empleado, n);
MostrarEmpleado(empleado, n);
writeln('Fin del Proceso...Bay! (*.*)/');
readkey;
end.

C8G4TA04

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

C8G4TA04

Cargado por

Copyright:

Formatos disponibles

Trabajo Práctico N°4 C8G4 Año: 2015

Brandan, Flavia Daniela DNI: 35.274.908 LU: 6803

Ordoñez, Daiana Ayelén DNI: 38.746.109 LU: 7013

Sutara, Esteban DNI: 37.095.770 LU: 6722

Herrera, Juan Ignacio DNI: 38.656.275 LU: 1415

TVector = array[1..100]of TEmpleado;

procedure menu(var opc: integer);

writeln('* 1- Ingresar Datos *');

writeln('* 2- Mostrar *');

writeln('* 3- Mostrar por estado *');

writeln('* 4- Buscar por Legajo(mostrar) *');

writeln('* 5- Ordenacion de legajo (metodo rapido) *');

writeln('* 6- Agregar dato *');

writeln('* 7- Modificar estado *');

writeln('* 0- Salir *');

write('Ingrese una opcion: ');

write('Ingrese la cantidad de empleados: ');

write('Legajo: '); readln(legajo);

write('Nombre: '); readln(nombre);

write('Sector: '); readln(sector);

write('Ingreso: '); readln(ingreso);

if (estado1>=0) and (estado1<=3) then

WriteLn('opcion invalida, vuelva a ingresar');

until (estado1>=0) and (estado1<=3);

procedure mostrarEmpleado(e: TEmpleado);

procedure mostrarDatos(empleados:TVector; n: integer);

Procedure Swap(Var X, Y : TEmpleado);

Procedure ShellSort(Var A : TVector; N : Integer);

While (Jump > 1) Do

Jump := Jump Div 2;

If (A[J].nombre > A[I].nombre) Then

procedure mostrarPorEstado(A:TVector; n:integer);

writeln('Ingrese el estado: ');

if(A[i].estado = estado) then

procedure QuickSort(l,r:integer; var v:TVector);

x:=v[(l+r) div 2].legajo;

function BusquedaBinaria (V: TVector; n, elem : integer ):integer;

var E,D,medio : integer ;

while ( (E <= D) and not(encontrado) ) do

medio := (E+D) div 2;

if (V[medio].legajo = elem) then

if (V[medio].legajo < elem) then

procedure buscarPorLegajo(A:TVector; n:integer);

legajo, pos: integer;

write('Ingrese legajo: ');

pos := BusquedaBinaria(A, n, legajo);

if (pos <> 0) then

procedure agregar(var empleados:tvector; var n:integer; legajo:integer);

procedure buscarEmpleado(var Empleados:Tvector; var n: integer);

var legajo: integer;

write('Ingrese el legajo: ');

pos := BusquedaBinaria(empleados, n, legajo);

writeln('No existe el empleado...');

procedure Modificar(var empleados:tvector; n:integer;pos:integer);

writeln('Realice la modificacion del sector');

if (estado2>=0) and (estado2<=3) then

WriteLn('opcion invalida, vuelva a ingresar');

until (estado2>=0) and (estado2<=3);

writeln('Debe cargar primero');

writeln('Debe cargar primero');

writeln('Debe cargar primero');

writeln('Debe cargar primero');

writeln('Debe cargar primero');

pos := BusquedaBinaria(empleados, n, legajo);