!

$ $ %( $ % $ +% %/ . ) % % % % %

$% $ ) %

& $ * ) $ $ * +, /

$ ) + . % %

$ + )% % , $

%& % $ ' %% %

$ % % * . % ) % ) $ %& % %$ ) % % % % $ * %"0 1 ) ( & + %

' , $ $ ) % % $ ) % * " $ " "

% $ $ 2/ $

$ ) % ' % $ )

%& $ $ * $ % ) % / % (

+ $ / % ' ' $ ) % /

, % $

" "

$ % *

"#"

% *4 + / 7 % $ % $ $ +/ & % ) $ % ' $ + % %% + %% + % % 1 + $ + 8 " ! " % " ! : " ! : . % $ . . ) , %

% , $ $

$ 5 , * $ * %

+ $ & + % * , % * $ $ % / $ 6 / $ ( 9 %* % % % $ / / $ %

) ( %

% 6+ .% $ ) % +$

$ + %% & 7

" %" "

% $

% , % % % 7 % $ % $ $ %( $ $ *

( , ,

/ $ %

"

%' * 7 % $ % *

"

$ % 5 $ %

/ +$ ) $ %$ ) % %$ ) % * % % * % %

$ ) % " ' %%

% ( &% % + $ ) % ' %% ) * %$ ) % . 8 $ %

% $ % -

% % + ) %& % $

% %%

% $ ) % )% + %$ ) % %$

* % * * $ $ * %% % $ + %$ ) % % ) +

% "

$ "

( &/ %$ ) % '. / %& % * $ ) % % $ % , ;$ ( + ) $ $ . $ / $ ( % $ ) % %* % % + ) % 5 6 %$ ) % . ) % ( &/ % ) * % % %$ ) % + ) $ % /

% % % %$ ) % % * % 8

"

$ (

% / %%

$ ) % % % $ *

. $ ) %

* % $

, #*3 5 $ % 6

"

% %

% "3"

"

! % $ * % $ , $ . % % "

/ $

$ $

%* / $ ) % % / $ $ % $ *

% + .$ ) , $ +

% $

%; .

%' ' / % / % $ / $ % *

$ " ), %

% ( % . % $ ( % & / % *

$ ) % / % $ $ / $ % / , + ,

8 ) +% % , %% ( %

% + % *

: /

* $& % , , %/ $ / ) , * ( * % $ " " "

$ * ) $ $ % *

% ' ' .

% " ! ) ) = " ! ) % " ! ) * % *

) * *

$ % ) $ ( + % ) ) ) % , . %% % + . $ %

9 $ $ . % % * 8 * ( ( & * ) ) % % " $ % / $ "

) % %

. $

/ 5 %$ ) % * $ -% * )

+ $ %$ ) % + % / % $ $ $ $ %( % % # 5 $ " 1 ) ( $ ) % *

$ 6 % % %

%% /

. % .

%&

%$ ) % 5 $ $ .% %$ ) %

%( * 6. ' %% $ ( ! % ( % % $ $ " )" +. "

$ % , $ "

$ ) % " : > %% % ( *? .( ( % $ $% ( % % ( % ' %+ % %%

6*

( % + . %$ ) % %( * $ )& ) % % . %% . $ % % % %$ ) % * $ % $ ) % $ % , / ( ( % % % % % +$ . $ % * $ % : "<" 9

! $ $ %

" " "

%$ ) % *

$ % % $

( % *

$ )

%$ ) %

8 % 9 " ! " ! " " " ? " , % %

( + % ) , ? % , >" 5> %' ( .% 8 $

% /

% %

* )*

% % %

% (

( $

"

"

'

, % , $ ( $

% % %

$ $ % % , %

, %' %&
!

$ $ $ $ * %$

% % ; +. / * $ ) % $ + %

$ %

$ % %

8 $ % $ ) % ) $ % %

.% " " "

% , % ( * % )% % )% % , * ,

/ % $ $%

%& % % , )%

* $ $ 9 ?

& % % 9

) (% % % '

" " "

%9

$ %

. %? *

% %

9 !

%/

$ 9 *

/ $ . %

( % %

. ) $ ) % % , 9 % $ %

$ $ %* 9 "@" %& % $ "

! $ % ( % % %% / % $ * % % % $ % % ; % ;. $ + % " %% ; $ ) %

$ )% )% $ ' %% 7 % > % % , ) %& ( %

+$ % / 5 . %

% , $ % $ % , , %$

6. % ' / +$ % / % % $ % %$ ) % ($ * % % '
"

+$ $ %

( ' %
!

% )%&

% ' , ' & %

.% * ( %

)% %

%& *

5 $: % $ % * / %

.7%$ 6 $ % %$ ) % % +$ ' % $ % % % , '

% % %$ % , ) % % . %

* %

%& % % / % % %

%% $

, % ( $ $

%' % % +. *

"

% " %$ % $ $ $ % )% % $ $ &

( ! & + %$

, &% ' + $

% %% % % $ $ %& * %% % .

.% % .%

, $ %

$ *

* %

$ % /

% $ $ %$ $ %% , $

, ) % / % ; % $

$ % + , % % % $

% * ( , $ " $ / $ " 5 % * % % 6. , .

%+ % $ % 5 8 6+ % % % $ +$ % / %

%& $ .7%$

#
% * % %
!

$ $

) $ ) %

( % +% * %

. %

)% + %

$ % (

$ % ( % +$ ,

" $ % +

$
* $ % % %

( ( % % $ / %

) %& %

% (

% % %$ %

%& % % * %

, $ +. / % %

" ,

#
. 7 % *

+ % ,

, $ $ "A" , )%

$ .

$ ,

)% %

! 86$ $ ' )% +% %& % % , 5 "

/ 6* % ,

' $ & % %% % 8 " " " , , ,

!

%& ( '

% $ '

, & , (

)% 5 $ *

% , 5$ % ) * $ ), % % / ( % ( %
%

$ 6. % 9

#
% , ' % . /

, . )% + 8

. ) %

)% C . # 5% / % + / +

) % , ) $ $ % + + % %& $ * % , ' / / / 5' $ % & * % , 1 6*

$ % % ) % $ %$ ' % $ % $ * %$ $ , $ * 6* 9

/ /

* $ .% " " % "

* ,

, / / 8 " " " ) + % %

$ * ( . . $

%' ( %.% % $ ( + ,
!

$ %& ) $ 5$ ) . 6. ) $ $ % % %

% ,

% /
!

$ % % 7

$ ) % * %

; $

#
! ) ( 8 % / ( % % $ * ? ) % +. / $ / * $ % /

&

% $ %) % , % ) /

$ / %

% 5)

, 6 %

* $ ), ( %* , ), ( %+ % $ , $ $ % +$ $ )% $

/ + ' % $ % & $ / 6* % % , / $ % % * , $ $ / % %% / / $ $ %

, 5 ,

$ " $% ) ), ( %$

%/ %

% * % %$ , ) %

/ + %$ " "

, ) % ( %

% , / $ $% ( % +% / $ %

% "

#
% $ % $ / * $ % *

&

, %

/ $

%& + % ,

% , % "B"

% * % ') % ( % /

: %* !

/ '

$ %% , " %% "

! $ % / * % . % ( %( + %+ * %& %$ $ $ " , "

), %

( %+ . / , %

( %

$ % 7 % % % / ,

$ %% $ % $ %$ * %E + ) %+ ? $ $ + % . $ *

% ( , / $ % * % ( % / $ / %% $ % % ) ) % ( , $ % %

%& $ % $ / $ /

#
$ ( % % % % $ % , % . % / 5$ , . / ) , ( * 8 % , % &* / *> / ) , 6* $ $ $ , % $ % 9 +% % +% % , .* % % . % , * % ( % * / " / "

/ ( % "

$
% $ $ % $ + ' #F@B+ 0 ' G > $) % $ $ % $ % .% $ % . %' 1 * $ 5 % $ (* $ $ , % % * + . % % $ ) % * + ( &/ % ) ), ) % ) %& ' 1 $ ) % %/ $ $ % , % *! % $ + % + , 6$ * $ % * & % ( % / +% % " *

$ /

& % $

'

( %& $ % $ +% %% , . % * %

% $

$ % " *

*4

%$ .% , % / $ & % % * % + % * $ $ % , / '

" + ( % " + %

% $ . 7 .+ $ * $ % <* $

), % + % )

! ,H ;'

* %

)+(

"

( $ . "D"

%$ $

% "

! $ %% $% % %/ $ % A* %

%% % %

. (

% % *

$ (

)
!

% $

/ $ $

) %

$ %

%%

%9

1. Inicio. 2. Levantar el tubo del telfono. 3. Marcar el nmero del amigo. 4. Si la llamada es respondida, hablar. 5. Fin.

$ $ %7 % $ ) % 69

%%

% $ %% * % %

( %$

+$ %

$ 5

1. Inicio 2. Si se conoce el nmero de telfono de la otra persona pasar al paso 4. 3. Buscar el nmero de telfono en la gua de telfonos. 4. Tomar el tubo con la mano izquierda. 5. Colocar el tubo al lado de la cabeza, asegurndose de que el auricular quede lo ms cerca posible de la oreja, y de que el micrfono quede suficientemente prximo a la boca. 6. Marcar el primer dgito del nmero de telfono que aun no se haya marcado. 7. Repetir el paso 6 hasta haber marcado todos los nmeros. 8. Proceder a contar los tonos odos. 9. Si la llamada es respondida, hablar. 10. Si no, si la cuenta llega a 8, cortar la comunicacin suponiendo que la otra persona no est. 11. Fin
!

% % * > ( * $ + % )

/ $ 9

) % %

$ /

$ % $

$ % & % .% %

" "

1. Inicio 2. Buscar las herramientas y el neumtico de repuesto. 3. Levantar el vehculo usando el gato. 4. Quitar el neumtico averiado 5. Colocar el neumtico de repuesto y ajustarlo. 6. Guardar las herramientas y el neumtico averiado. 7. Fin

"I"

1. Inicio 2. Verificar si se cuenta con un neumtico de repuesto, con una llave cruz y con un gato para elevar el vehculo. 3. Si no se cuenta con alguno de los elementos anteriores, debe llamarse al auxilio mecnico, pues no se puede proceder con el reemplazo y continuar en el paso 20. 4. Retirar los elementos de la cajuela y disponerlos en el suelo en un lugar accesible. 5. Colocar el gato en la posicin adecuada, teniendo en cuenta la posicin del neumtico averiado y las indicaciones que pudiera tener el vehculo acerca de donde colorar los gatos. 6. Elevar parcialmente el vehculo, sin que el neumtico se despegue totalmente del suelo. 7. Colocar la llave cruz en uno de los bulones del neumtico. 8. Hacer girar la llave hasta que el buln se haya aflojado parcialmente. 9. Repetir los pasos 7 y 8, hasta que todos los bulones del neumtico hayan sido aflojados. 10. Elevar el vehculo hasta que el neumtico se haya despegado totalmente del suelo. 11. Retirar el neumtico averiado, colocndolo en el bal, en el lugar donde se encontraba el neumtico retirado en el paso 4. 12. Colocar el neumtico de auxilio en el lugar donde estaba el neumtico averiado. 13. Colocar un buln de vuelta en su lugar, ajustndolo parcialmente con la llave cruz. 14. Repetir el paso 13 hasta haber colocado todos los bulones en su correspondiente lugar. 15. Hacer descender el vehculo parcialmente, hasta que le neumtico se apoye en el suelo. 16. Ajustar fuertemente un buln del neumtico, valindose de la llave cruz. 17. Repetir el paso 16 hasta haber ajustado todos los bulones. 18. Hacer descender el vehculo hasta que retorne a su posicin original. 19. Guardar los elementos sobrantes en la cajuela. 20. Fin

"F"

% ( / ' + 7 $ % $ % % % . ( ) % * 7 % + $ % ' % % / $ 9% $ ) ' % % % 7 ) + 8 $ % $ * +% % 8 * + % % % % % % 7 + . $ ) % % + ( % * % % * +$ + , $ % +% ) ( % . $ % $ , $ % % $

% *

) ,

/ %& %

% $" . . % %& % $ () % *

$ ( * % % ) % * ) % .

" #C "

) / % 8 $ % %

% $ +

+ % %/

% ) ' $ ) ' ' ,

% 9 ' '+ ) , * / ' $ % $ ( %$ * 00 ( $ ( & .$ ( (

$ $ % % $ ( 8 .

. %

$ * % $ ) % $ %% , % . / % + * * ( %( &

* . % / % / / % 8 7 +% $ %+ % $ % $ . ) , + $ /

+-

%& $

* 7% % *

% " )

% $ 7 % 8

$ $

+ $ %& % % / $ * & *

$ $

/ *

% +% $ ) / $ $ * &

" , "

$ & $ 9 ( % $ ) % * ( % ) % / * % , . %% . % $

"

, $ $

( % ( % %

* / $ % * +%

$ % / $ %&

6. % .$ % %%

$ " % % $ " / %

% ( % , $ $

$ * / $ $ ( * . $ $ % % $ / $ % $ , , . % $ %$ % % $ % $ $ + * . ( % $ $

5 ( "

$ % * *

"

$ %

* ( % *

"

* " ## "

8 % $ $ . .

( + $ % $ % +$ % / ' *
(

/ *! ) + % . $ $ * %

$ +% % /

+ $ $ ( + . 9, % 1 % +, $ % * % , ( $ ) $ 2

$ / % %

. , $ +/

+*

) $ % % , $ + $

, .+ 8 %&

% + ( / %

7 $ , )$ % $ % ,

*! ) / $ * $ % + . 7 ( % $ ) %

$ % % . * %

/ $ 3) . 5#B ) 6+ $ % % BAA<B ( % " * 8 ( $ $ , +$ % / %% / $ ( % ( % J<3DBI . K<3DBD+ % " + 8 <3DBI ( % ( ) #A ) $ ( % . $ % 9 3#A L <3DBI+ $ % . <3DBI ( % $ ( 5 % % %C 7 % ) % J<3DBI K<3DBD6* , ) 3) . * > +% % ) % $ " %
(

) $ (

$ / $ %& + % % +% $ $ % 2 * % $

$ $ .% +$ 1 % * $ %

. %

: * +% %% * +% % $ %" $ / % +

+.

$ $ $ $ @) .

) , ' +

% , $ ) % $ % $ $ %% * * % %/ %& .% $ % 5$ % $ / $ ) "

% %/

7 ( % .$ %+ % + % . $

% *! ) % %* 8 ( *4 (

) $ $ %

% " % /

% %% *

* % +% +% % $ %" )- $ $ % % " $ $ 6* +. %

+% .

$ ( % $

+% $

* 2 %

. %3 .

* $ .% % % )

/ $ %& / $ $ * % E % 5$ % /

% $ ' % $ " #3 " %

( % ( $ $ )%

, * % $ % %%

$ +% %

%+ , ) % 6* +% ( "

! +%

"

$ %

+ % $ $*

, * * % $ ( % %% * % 6* 6+ %% #/ ) 8 )% * " $ % $ % % % / ) % %6* % $ % % $ $ % , ) %

. . 6+ % %

% %& ) % % % )% % ) % * $

$ $ % + 7 * )% % %7 + + 8 , ) %% 6* +$ 3AB +$ , % )% % + %% % )%

$ ) * 5) . % $ % 5 $% ) 5 / %& 5

$ $ $ ) %

"

. % +

$% ) + % ' %% . % + %

M#N5/

* )%

% $

%& + % $

$ % 9 M NO M) N +/ * +-

$*

&
. ( % + 5 $ % . . + ( $ 6+ $ % ' % %& %$ ( ) % % ( $ % %/ ) $ $ ) * , / + ' $ , * ) % ( % $ $ / % ( + $ $ % $ $ . % % $ % % % * ( * ) % ; +% % ( ) % " * %$ $ ' $ % %$ ) % $ $ % $ % 9 ( $ / %% / 7 %% $ $ $ * $ % 5 +. % % ( * % % . % ( ) % %% ) $ % $ %$ , $% $ % % * + % $ ) % * . % % , ( ) % * )% * +% $ % , %$ " % " $ % 9 %" ) %( % $ " ( ) % 6* ) ( % * +$ % +% $ . % % %& $ ) / $ % / )% . %% ) " % * ( % % , % % % +. / , ) % $ " $ ' "

% % )% % % " ( % $

Real precio 7

" #< "

&

( ( ( %( %

) % $ ) % ) % % + ) $ ( ( $ ) %

% )

$ )% *

* / ( % * % % ( % * % $ $ *

) % $
&

% % 5( % ) % ) * % ) + )% > $ %& * ? % %
*

% , $ ) % / % ) 6* > ) .% % ( $ . % ) % + ), * $% ) + + % )) $

%%

$ % ) $ ( ) )$ % )

% ) ( % %

% 5 % % % + ) 5 % % $ ) % % , 6 * $ %

/ $ % / $ $ % $ * * % % 6 " +

& 5PQR6* %$

) $ % * ( % / % , % % ( $ . $ % 8 $ * 7 % $
* * (

+( ( % % %

) % + $ / $ / *

+$ -

. % ( % ( %

) % . ( % ) % %

" .

% ( ) % . $ . $ -

8 $ *

% +

8 $ + *6* %

( 8 $ "

8 $ $ 5 &
*

8 $ $ $

% 6. $

( %

. ) % %

% . * ) ) %&

$ 5

( %7 %/ / %

" % % $ $ $*

* 6+ $ /

( % % %"

8 $ *

9%

.%

$ "

" #@ "

#
% )% / % $ %& % *

#
(

% $ K " P S T (

$ $ $ % %

* $ % % % % % %

% $ % !( !( % 5 6 8 $ (@ % %

% %

12 + 4

$ % )

) %

$ % +%

9 @ P &T 5#S36 K #3

$ % $* %& % 5verdadero falso6*

% 8 $ $ L O U OL UL OU %

% *

$ %

%& %

$ $ $

% %

"

%/ / . . / %/ %/

% $

% % ) -

$ *

%&

7 %

"

6* + )

$ $ %

% )-

5 %& ) % (

6 8 $ 9

not 5 % *

6+ and 5

6 . or 5 . " / $. / $ $ "

" #A "

!
Negacin p verdadero falso not p falso verdadero p verdadero verdadero Falso falso Conjuncin q verdadero falso verdadero falso p and q verdadero falso falso falso

!
Disyuncin p verdadero verdadero falso falso q verdadero falso verdadero falso p or q verdadero verdadero verdadero falso

%(

8 $ * $ 5 8 $

/ % / 6+ % $ % $ $ +% + % not % $ %

$ $ 8 $ $ .

/ *

% %

/ 9 * * $

/ 8 ) %

% ( % + .

/ $ - " % + + " % %

( %7 $ ( %7 $ % . $ * ( ) % ( % %$ % % ) %( %

/ $ * ! %

$ ( $ %

$ % $ % $ % $ $ $

$ % .$ 7 %

or* and . $ 7 % '*

$ % 8 $ $ % or* 8 $ ( $ / $

+ . % and $ ) % not+ % ( %7 & / %% + *

( +

%/ %& $ -

%/

$ 8 $

"

$
% $ $ % / % ( ( ) % * $ ) ) % %& / $ ( % $ % % .% % % , $ $ % * 9 % *

) % *

variable expresin % expresin ) ) ( ) % ) $ / % % expresin ) % $ $ 6* , $ x 5 ' / % ( $ % ) % 8 % $ %( % / % % % ( ) % 5 ) %( % A' ( + , + .% ( $ $ % & $ + * ( ( % ( % ( ( % * ) ( % ( ) % + . ) % + $ % + / % % . $ % % $ + ( ) % % $ % ( ) % 5 ) +% % 8 $ ;$ , $ % + % $ % ( " %% 8 +% "

( %7 % expresin+ / 8 $ $ " #B "

! % % %% $ % ( y. ) % 6* % ( , $ % + ) % 8

$ / / % +%

% 9

( % (

% $ ) % % $

x 4 y 10 + x * 2 ' / 8 P 36* % $ %% $ % %A % $ % @+ . % + / % % + '. % #I 5 % % ' 9 % / ( ) % ( % #C K @ ) $

% ( ) % $ %% 5MN 6* , $ % + $ letra . / % letra A %% $ ) % ( % 9 v verdadero ) * $

( % $ (

) % +. / ( ) % ( %

$ ) % ) % % % " +

( ( % $ %

5verdadero . falso6 * , $ % +

%( %

verdadero

% (

) % (*

'
) % $ ) % ' %% % $ $, $ % +$ % a b c a c b % $ c* + V C 3 ) / , V V % &+ % % ( $ $ 9 ) % ( ' ) % * 5 % % % $ ' % ) 5. % % % $ 7%$ 6* % ( % +/ ( / $ / %& % % % % ( " $ % 6*

) %

% %$ 8

entero a, b, c

0 2 5 b + c a + 2 * b 5 + c % ) + ) $ % % % ( ) % a+ $ 9 b.% $

--. / 01 2 +3 . 4 +5 +6 7 ,1 23 +8 +1 . +,3 2 entero a, b, c % $ V* a 0 $ % & %( % * b 2 $ % & %( % * " #D " ( ) % + a$ b$ C; b . c 3; a . c %( % %+ " "

! c$ A; % a$ % A % a.b b$ * a+ b+ c* . % " %$ % / 9 +$ * c$ % % % % * ( " ( % % % a.b

A D ## #B D #B ##

c 5 %

$ % & %( % * $ % & %( % C % ( % b.c

a b + c ( % . b . c; %

c a + 2 * b $ % & %( % ( % % 8 $ a K 3 P b; % ( % b 5 + c % % 8 $ G% % A K c; % % $ % & %( % 3 % ( % a.c % ( ) %

( % + % $

%& ) % 9 / % % % $% ) 9 variables+ inicio . fin* >

( $

Variables entero a, b, c Inicio a b c a c b Fin % 0 2 5 b + c a + 2 * b 5 + c . % ( % $ *

" #I "

%$ $ ) % + ) %9 %$ $ + % ( ) % 6* , )! ,H %

$ % $ :

% * % % $ . %+ %% % %& $ $ % % % $ * $ / % % % % % % % % % $ % % ( % $ % % % $ % ( ) % % ( , . / %& . % ) $ % $

% * )" " +

/ %% / %& ) %% $ ( * $ %$ % * ( ( % 8 ) % +

* (

$ % %& . % % / % ( % ) $

" "

) % +. / 5( "

" #F "

% %& & % % 5 :

$ % # ) $ % , ) +( -

% : % $ +% . / )

, . .+ $ * %& % $ . $ %) * 9 : 7 + % % +' %

/ %$

% , $ " 1 6+

% + $ * )

% 9 ( % +

$ + $% ) $ $

$ ( + $ ) $ $ %

, + $ % *

/ $ + % + * $ % +$ % %& % %

) " + %

7 ! ,H / $ % * $ ) %

& ) $ .

' $ % ,

& %& , %

8 % $ % % '

%& % %

$ -

) % %

9 %

% % $ * * .% %% $ %$ ) % / (

. % % % / $ $ $ .% $ % ( %% % ( * $

$ % % %( % ), $ % % %% $ % $ ) /'

* " 9

+ $ %$ ) % * % % $ % $ % %$ $ % %$ ) % .$ 7 % %$ ) % / % % $ % , * % , * %$ $ ) % % $ 8 ( ( , $ * % ( % % / ) 4 * %% $

% E %(

%$ ) % % +$ $ % * %& ' %% % / $ % ( / ) $ % % %% ( $ )* %

" $" "

$ %

+ $ %$ ) % +.% % $ % A9 (

' (

% $ $ ) % / ( EW ' .0 $ * $ " "

: $ +

$ $ %% / . % % ,

+ $ $ ) % $ $ %

$ . %( $ % % ) % + 5 $ ) % 9 . +$

% &) % ), / ) 6+

$ $ ) $

$ $

* * * "

% $ %

" 3C "

! . % $ $ % % , 5 $ %% % 9 + $" " ' *

"

/ ' / % & ) % : % % ( + % . 7

) % * % $ %

% % + 7 $ * % " +

( * .$

" *

& $ / $

) . , / , % *

+6+--. 7 0 2 66 22 9 2 -: ; +0: 0 + + -7 0 ; . 0 : +-. / 05 23 +7 ; 1 +

, *

$ %

%&

%$

$ %

"

&

& $ / % , ) , ) *

8 %& / % ( %7 $ * . % , +$ . ) ( % .+ *

% / (

( ) % $ % $ % , %

%$ / % %$ ( %

* , * +%

"

02 3 2 6 < : 2 =+ > +?5 7 6+--. 7 0 2 6-7 0 5 . -. 7 0 +5 +6 @: 0 +A +1 +3 + -7 0 5 . -. / 02 0

?7 ; 1 +A +1 +2 3 -+6 7

" 3# "

&

7 $ % . / % ( % %

&$ / %% % &

8 5 ) 6 $ %

, 6* %/

. $ ) %

, -% . 5$

$ ).$ % % % -%* ,

"

% / % ( %(

% * , %

% -%*

-%6 )

02 3 2 6 < : 2 =+ > +?5 7 6+--. 7 0 2 61 2 A 2 ; . ; . 8 +6 @ 6 22 9 2 -: ; +01 2 . ; 2 1 +5 +68 2 -2 6-7 03 + -7 0 5 . -. / 02 08 2 1 5 +5 2 1 7

) % $ 8 ( % / $ % $ .$ " $ +$ +% %

) $ $ $ "

5 %) % 6. .

6+ 5 .% , /

5 $ *

" 6* "

) % 9% * $ ( % % $ %) % * * % $ % * $ % ) /

%& % $ %

$ % % % , ,

% $ %& $ % % Tipos $ * $ ) $ $ /

$ inicio . fin+ .%

) %&

$ ( + % 6+ % * ) % / )

% % + $" $ % 6+ $ % 9

5% %$

$ 5 )-

%/

Variables $ $ % % ( ) % . )% *

" 33 "

Inicio $ Fin $ % $ % % 5$ % / . $ 6* %* $ % % $ $ $% %$ *

% % % $ % %& %

* $

/ $ % % % $ % $ %" ) + ) 5( % % 8 $ 6 $ % / 7% 9 % , $ % $ % , ( ( ) $ % % *X Y %& % ( % VZ) / * $ * / $ ) % % + $ % +/ $ ( % % ( ) % % 8 * % * $ * + / % / % % % %% % ) ( % ) % )* % % ( ) % * * % $ % " ( %

% % +

$ % *> % + %& % $ + % % ' 9 leer (Num) / ' '( %& % %

% % % 8 ! (

( % +% .% " ) % %% %

5 $

( % 8 ) %

) % $ /

% %& * % % %

( % * , .

% 8 " % / + %

* % $ ( % %

%/ ' $ + % * +

$ % % % % %$ %

%% + /

( % $ % %& % /

6 % $ ' +$ % ( ! " !! , /

) % %$ % " % % % *

( ' $

% %&

) %

% 8 " * % '" % 8 "

/ escribir (Num) % , $ % + $

( ) % %% ' 9

leer ( %

escribir %& 9

$ ) %

%& (

) %

% ( & ;$

leer (a, b, c) escribir (a, b, c) " 3< "

! *

a, b . c
!

) %

% %

% 7

'

' % 8

% ./
[! % [% 7 [ [ [ [ %

+$ %
( $ 7 % ) % .%

%& %
5 + ). 6+ % % % *\ . %

% 9
% % *\ *\

$
\

"

Variables entero a, b, c Inicio leer (a, b) c a + b escribir (c) Fin % % 5 + % 9 ) % +. . %% 6* + + 7%$ )% % .7% * %&

$%

% % %

*\ 6* \

5 %

% / % +

7 $ %& %% ( % , +/

$ * % 5[\6* $

% ' %

( % % ) % % " "

% % $

/ %

$ (

$ ) % *

B
% $ % . $ % / %& % $ %& ( ) % 9 + 8 $ / "

( 5 ) % $

) % 6 + /

$ '

/ ( % * ( ) %

%&

( % 5$ % %%
a C\

5 % a+ % 6* /

% % / %

6. %& "

% % a 0 ...

% a a + 19
[

%& %

" 3@ "

!
#5 ' #5 ' #5 ' % % % %( % %( % %( % #6 \ 36 \ <6 \

a a + 1 ... a a + 1 ... a a + 1 $ . (

[ % [ % [ %

a a a

) ( + ( &/ , % ( % C+ #+ 3+ < ***

% * %

a a + 1 % 9 " a

" ]

( % 6. %& ( %

) % 5 $

5 6 % ( /
[ [ % [ %/

) % ) % * / a+ %

%6 / % ( % ) % % %
%& % % %

%& ( / %
%

( % ) % 5 ( (

5 (

% ) % 6*

% ( "

' % / -

5total . a6+ . total total + a9

total C* \ %

total

total 0 ... total total + a ... % % % , % / % %$ ) % *

%( % a\

a+ \

, ( % /

( '.

% 7 % %

/ a

% & + total

( % 5" ) % 6 6 ( % 5 %& 5"

) % / %& 6*

%& $ $ (

% %$ ) % $ % 6+ . * % %$ 5( % " * $ $ 5

%$ 7 %( %

$ %

( % 5$ , $ % 6+ ) % ( ) % *

+ 6* % ) % 6 5) % ,

" "

#
% % * $ % % $ $ % ) %+ 9% * / %% %+ % / % ( . & % ) % .% *4 $ % , ( * %$ " 8

#
$ . / & $ / * ( 9 " 3A " , % ' % % %$ * / % % * $ % $ %

+6+--. 7 0 2 66 26 : -2 5 2 02 0: 0 +6 2 -: 2 0 -. +

$ )
7

$ +

. %

+ % %
&

% ) 6 0 5 % %$ % ) 8**

%5

6$

#
% 8 ) % ;$ % % % " / 7 % , ( ( &% , * * .% " 4# % + % % /

$ ) % / % )

) ) , , / $ "

% ), $ % . 8 , * % " )

* % % ,

" ( " ( % " +% " " % *

% 9% , / + $ "

* ) % +. + * $ % , %$ %

% ( $ ( ) % $ % ( %7 % ( % % . .
&

8 + *

, $

/ % . / ,

, % (

7 $ % *! /

$ % / $ % %

"

02 6 ; +2 6 ; 1 : -; : 1 +B 3 +6+--. 7 0 2 6-7 0 5 . -. 7 0 +5 +66 . 2 =A 1 22 6 ; +1 C 08 . 0 -: 3 +5 +6+ 3 + -7 0 5 . -. / 02 0

$ 9

+%

%/

$ %

$ %

si (<condicin>) entonces <accin1> <accin2> ... <accinn> finsi " 3B "

! % % ( $ , + / + accin1+ ac% )

condicin $ cin2+ ...+ accinn $ " * % $ ' 5OU6* % $ % " ces .

!

8 $ ( $ % finsi*

) / . 8 $ % * % $% )

si (...) enton-

%&

/ 7

% .

/ $ %

7 *

%$

variables entero a, b inicio leer (a, b) si (a > b) entonces escribir (El primer nmero ledo es mayor que el segundo) finsi fin
!

/ % *

/ $

variables entero a, b inicio leer (a, b) si (a = b) entonces escribir (Los nmeros ledos son iguales) finsi si (a <> b) entonces escribir (Los nmeros ledos son distintos) finsi fin

, * $ $ %( 5

$ ,

) ( + / 8 $ % , / % , $ % "

%&
&

% + +% +. / % .% " +

% / %/ % a = b . a <> b $ % 6* % ( *

9 %

) " "

$ 7 , , + % $ % $ % % % ( + ) % $ * , %

, %& %

% ,

% "

, *

% , "

( %7 % % 9 " 3D "

. ,

" +$

, ) *

< : D 2 E . 6 ; 2 0+--. 7 0 2 6-7 0 5 . -. 7 0 +5 +6; +0 ; 7A +1 +2 3 -+6 7

-7 =7A +1 +2 3

5 23 + -7 0 5 . -. / 0

$ 9

+%

%/

$ %

) %

si (<condicin>) entonces <accin11> <accin12> ... <accin1n> sino <accin21> <accin22> ... <accin2n> finsi condicin $ % 8 $ % , * % %/ % % ( cin12++ ...+ accin1n+ $ % ; accin21+ accin22+ ...+ accin2n+ $ * " $ % ces <acciones> sino <acciones> . ' 9
variables entero a, b inicio leer (a, b) si (a = b) entonces escribir (Los nmeros ledos son iguales) sino escribir (Los nmeros ledos son distintos) finsi fin

/ $ % / % % %& % $% ) ) ,

% $ % ,

, * accin11+ ac" % "

( si (...) entonfinsi* %( % % "

+ %$ ) %

% ,

$ % <*< % $

$ $ : %. % 7 % ! 9 %

) ( + . # *

) $ % ( & ;$ % $ % " 3I "

/ % +% : % %$

7 , , +

% ! 9 . , #

% $ *

+ "

$ *

variables entero num inicio leer (num) si ((num =7 5 2) = 0) entonces escribir (El nmero leido es par) sino escribir (El nmero leido es impar) finsi fin
& F

8 $ % % $ %& $ % . ) % * % $ 7 % $ % * % ( +' % ,

( +

, $ $ % + % 7 % $ % %% %&

) , %$ / ( 7 % $ % * . %$ % +$ % ( % $ $ % % % % $ * %& . / ) % + $ % / )$ ) % "

%& (

%& $ ( ( % + $ / % 7 % / $ 7 % %&% $ % ,

/ %

% , +$ % %% $ ) % %& % $ %"

si (<condicin1>) entonces <accin11> <accin12> ... <accin1n> sino si (<condicin2>) entonces <accin21> <accin22> ... <accin2n> sino si (<condicin3>) entonces ... sino ... finsi finsi finsi

#
% % ) % ,

&

. , " 3F "

% 6+ )- % %

5 ) ) % *

! * $ & ) % 9) % % %) % 5 ( % * $ % " " "

) . # " . ) $ % % % 6* $ % 7 % $ ) % * +% $ . , ( +

$ ! % &% &

$ & * 8

* ) % %% % $ $ %& $ % %.% %

% $ $ ( %/ $ % +% $ ) , $ ) % % , %) % 5 %) % ) 6* %% ! % % . +3 =2 0 7 6: 0 + +--. / 05 2 0 ; 1 75 2 3 ,: -3 25 2 ,2=7 5 . G . -+13 7 68 +3 7 1 2 6+3 =+-2 0 +5 7 62 0 3 +68 +1 . +,3 2 6< : 26 22 8 +3 H +0 2 03 + !! # !* % ( % % " % ( ) % / . % + % )" % , * . ( + ( % $ % % *
" %

I J
/ %) % ( %7 % , % % %) % * ( &. % ) 9

'

+% $ % %

+6+--. 7 0 2 61 2 A 2 ; . ; . 8 +66 7 0A 1 2 8 . +6+ 3 +2 8 +3 : +-. / 05 23 + -7 0 5 . -. / 05 2G . 0

% & / , ( ( 5 $ que (<condicin>)* ... repetir <accin1> <accin2> ... <accinn> hasta que (<condicin>) $ ) % * ( * )- ( $ ( % .

% $% ) % ) % 6.

( %&

repetir+ % $% )

7 (

" hasta

% %

$ /

$ ( ,

/ ; 7 5 +3 +2 6 ; 1 : -; : 1 +6 22 9 2 -: ; + +3=2 0 7 6: 0 +8 2 4 * +6+--. 7 0 2 65 2 0 ; 1 75 2 3,: " <C "

! * % "

-3 26 7 3 76 21 2 A 2 ; . 1 C 06 .+32 8 +3 : +13 + -7 0 5 . -. / 0K 6 ; +5 +1 2 6 : 3 ; +5 7 7 % , % % *

I J
. $ $ ( 9 ( % $ % % . % )

1 . =2 1 76 22 8 +3 H +3 + -7 0 5 . -. / 05 2G . 0?3 : 2 L 76 22 6 -1 . ,22 3 ,3 7 < : 21 2 A 2 ; . ; . 8 7

$ % % + 7 % $ ( 6. %& % $% ) ... mientras (<condicin>) <accin1> <accin2> ... <accinn> finmientras

% / (

& % $% ) , ( ( finmientras*

( 5

mientras $ %) % +

% B -7 02 3 $! % 2 3 -7 0 9 : 0 ; 75 2+--. 7 0 2 61 2 A 2 ; . ; . 8 +66 22 9 2 -: ; +5 2 + 08 2 -2 6 + +A : 2 5 26 : -2 5 2 1< : 2A +1 + +3 L : 0 +62 9 2 -: -. 7 0 2 65 2 3 A 1 7 L 1 +=+ 6 26 +3 ; 2 2 03 +6+--. 7 0 2 6 < : 22 6 ; C 05 2 0 ; 1 75 2 3 ,: -3 2 * ) / % ( % % % " $ %) % . % $ 5% $ ( $% 6; $ % + % $ ( &/ ( %7 % % + , " % %) % * ) $ $ 8 :+ ' * -7 0 5 . -. / 02 0 $ % * / '. M-7 02 3 $! % ) % ) / 2 3 &% !6 22 9 2 -: ; + -7 03 + 6 22 9 2 -: ; +2 3 ,: -3 2-7 03 + -7 0 5 . -. / 02 0 * ' / +$ % ) ) %

"

6 ; +2 6 ; 1 : -; : 1 +6 . 2 =A 1 22 6 ; C+6 7 -. +5 ++: 0 -7 0 ; +5 7 1 * . % ( / ) , ( % $ ( ) % . ' , % $ $ $ + & 8 - ' % & % ) ) 8 $ % % / 5 % ' *> 8 ( ) $ % % % " <# "

%& % $ 8 6 %

% $ * +% $ $ % , +$ % / 5 % ( % ( * 6* %

" " "

"

! 9

& * % ... % $

para var <valor inicial> hasta <valor final> [incremento <valor>] <accin1> <accin2> ... <accinn> finpara

! $ ) % , ( ." -

) % % para . % finpara + % var* var % ( % %+ % , incremento 5 / - $ ' / % ( ) % var % $ % % $ ) % 5 %

var

% ,

$ ( 5 6* % , ( & ( % $ var <valor inicial> %) % . % ( ) % $ + % ( % . / " * % % . $ % ( % $ %

" % ( %( % #6 .

" "

5 $ % B6* % 6* %& $

G $ % %

$ ( + $

$ ( & ) % + %

) % / % ( / . %

$ %
para... finpara 7

%/ ( %( ) % $ %% $ %

% $ )* / ) %

%* %& %& % $ $

) $ + 9

+$ % ( )

; . 3 . 4 +0 5 7 2 A 2 ; . 1
cont <valor incial> repetir leer (dato) <accin1> <accin2> ... <accinn> cont cont + 1 hasta que (cont = <valor final>) { Inicializacin del contador } { Inicio del bucle }

{ Obtencin de los datos } { Proceso de los datos }

{ Incremento del contador } { Control y cierre del bucle }

; . 3 . 4 +0 5 7 . 2 0 ; 1 +6
cont <valor incial>

...

mientras (cont < <valor final>) leer (dato) <accin1> <accin2> ... <accinn> cont cont + 1 finmientras )- ( / ) % %& " <3 "

{ Inicializacin del contador } { Control e inicio del bucle }

{ Obtencin de los datos } { Proceso de los datos }

{ Incremento del contador } { Cierre del bucle }

! . ( % ) ) / " $ % "

, % & % %

./ %

% $ %) %

*? % + %" cont cont + 1 $ % % % )

%) % * % +% %" + %" . / %" + cont cont - 1* $ %$

5leer (dato)6

%% (

%) % *

$ ) ) ( % $ *! ) 5%% . % / % % , %) % + ) + $ %& 9 % $ % / ( /

) % $ $ % + 6

) $ % ) % ) % $ %

% $ % % C( % * (

% $

8% ( % mientras* % %$ $ / . %) % * ( / $ + ( ) % , ( % $ %$ % % %) % * % $ / $ % / $ %) % +$ % $ * % % ) 5$ % % ($ % 6* ) $ ( %$ % / $ ( % % % , % . * ) %$ $% +. / -

% " " %

( ) ( % % % %) % .% , $ ) % % ) 5 ) ( 9

6* $ %) % .% ) % $ ( " %

$ %

leer (dato)

mientras (dato <> <centinela>) <accin1> <accin2> ... <accinn> leer (dato) finmientras

{ Obtencin de datos } { Control e inicio del bucle }

{ Proceso de los datos }

{ Obtencin de nuevos datos } { Cierre del bucle }

% repetir ... hasta que (<expresin lgica>) . para ... finpara+ % %& % $ % $ % *

7%

$ %

% mientras (<expresin lgica>) ... finmientras )*

#
% ) $ % % % 8 ( % * " # + % ( * 3+0 . 5 +=. 2 0 ; 7 . $ % %* 4 $ $ "

% $ . ) / %% $ % A : 2 5 26 2 11 2 +3 . 4 +5 7-7 0 -: +3 < : . 2 1 +5 23 +62 6 ; 1 : -; : 1 +68 . 6 ; +6 *> " << "

! ' ( 5 ) / . % $ ) ( %

) % . 6* %& 7 % +.% $ % $ ( / % %/

%* $ % % 7 % * %

$ % / +% 7 % *

6 ; 1 : -; : 1 +6+0 . 5 +5 +6 @+J ?,J 6 7 0+0 . 5 +=. 2 0 ; 7 68 C 3 . 5 7 6 M -J 0 72 68 C 3 . 5 7

$ % +

* , $ %
!

$ %

%% ) %

% % *

, $

$ %

/ %

8% %%

) % %$ 8

% " $ "

$
!

#
% / * % ) ) % % $ ( * % + % 7 5( % 7 % %) % % ) % $ ) % % % %$ ) % 9 $ * ) % . 5#C 7 % % ( ) % 6+ $ % % %) % 5 + % % $ * 9
{ { { { { { { { { % % % % %& % %& % ( ) % % C } C } }

% )

& 7

% "

%& $ % 6. $ $ % . / % $ %

6+ $ % % 5 /

/ $ 9 % %%

$ % / %% %

$ % " . . % " 6* "

variables entero num, cont, acu inicio acu 0 cont 0 repetir leer (num) acu acu + num cont cont + 1 hasta que (cont = 10) escribir (acu) fin

%) % } 7 } % $ ) % % 7 $ % . %) % } % ) }

} }

) %

% %

%& % $

) " <@ "

%&

*
!

$
/ % / % % * %$ ) % 9 5#C 7 6+ $ % / " ( ) % + ( " ) % 6+ 5( ) % 6 5( ) % 6* ! % . % 7 % 7 . % 8% * $ ) %& %) % * 7 % %& % "<3DBI* X / /- ) , ( % V 9
% ( ) % ) % 8% C\ \ 7 $/ : \

& 7

"

> ( ) % $ $ % ) % % $ * ) % $ % $ % % 7 % 5( $ % %) % . 8% $ % % . $ % % % ( % / / % . % ' $ $ % & % 7 % $ % / % % % % 7 %$ % ( ) % 8% 9 % ) $ %C5 6 % , VX > ( %& % %

[ [ [ % %7 % %

$ $
%

variables entero num, cont, may inicio may -32768 cont 0

%&% ( %& % %) % \ 7

repetir [ leer (num) [ si (num > may) entonces may num [ finsi [ cont cont + 1 [ hasta que (cont = 10) [ escribir (may) fin [

\ / %/ $ % &\ \ \ ') \

7 % . +$ % / % % 7 $ % . %) % \ ) % . 7 %

%
!

> ( *

% %

%&

.$ $

'
/ '. % 7 7 % ( & % 9 % % % % ) * 6* 5 ) $ $ ( 6* $ 5#C 7 * %$ ) % % $ M " N5" ) % % 6+ $ % / % . 5 6+ % % 6. % " " $ ( * , & 7 % /

%$ ) % ) ) % ( * 5%% $ % 7 / +X %* % % )

$ % % 7 7 ) ) +$

% $

% /- ( % %

%& C5 6+ % ( ) % ( % " %& % ) V ) $ % % % % $ M # " & N/ $ " % 7 ( + ) % ) " * % " <A "

! 7 7 ') % %% * 9 ( N ; ( N * /

( % % ) %( % " + % . ) +% > (

$ % , M %& %

% % , %

, M> 7 ) %
[

% . % $ $
% % (

variables entero num, cont logico hay inicio hay falso cont 0 repetir leer (num) si (num < 0) entonces hay verdadero finsi cont cont + 1 hasta que (cont = 10)

) %

[ [ [ [ [ [ [ [ % %7 % %

%&% ) %& % %) % \ 7 \

\ C\

7 % ( +$ % $ % & %( % $ " % 7 $ \ % . %) % \

\ '. \

si (hay) entonces [ % % , \ escribir (En el conjunto hubo al menos un nmero negativo) sino escribir (No se ley ningn nmero negativo) finsi fin
!

)
/ % 3 . L <8 K A8K 3 % %$ ) % % 8 6 % * ) ' ) $ ( % , .* 9 % (% % % / ( % $ % +. / % % % * $ ) % % $ ) % , 8 % % $ +$ "3 ' K3 C+# . $ / % $ ) % 9 $ 5( % $ % ( % $ % ( % % $ $ "3 . 3 58 + .6 $ C+#* %

$ /

variables real x, y inicio x -2 repetir y 3 * x ^ 2 + 5 * x + 2 escribir (x, y) x x + 0,1 hasta que (x > 2) fin

" <B "

+ , $ * '

% ( &$ & 8 : ) + $ % $ 8 $ % %& , $ / ) / % $ %

$ % %% ( , $ % +. / . $ % % %& ( % % % $ , '

%$ % $ $ ) % % $ ) % ( % * % +% % $ ) $ %

$ & % ) % % 7 . $ .$

$ (

+ "

* / ' * % $ $ ) % ) ) $ % 9% +$ / $ % +( % % ) + % &" $ , $ %

% / %

$ $ % + '(

/ % % $ % $ * )% / + )

$ %

* " <D "

/ V* % / % % Z) % % + % , % % , , * * / / '. $ % $+ $

) , ( + % % * $ $ % + % 5

$& +

$ % % % % 6* +

* . *+ . 7 % , . . $ ) % % / ( &/ ) % %7 % %

+X /% * . 7 % % ) + ' % * ) %

" "

/ $ $ $ ) % % % % $

%* % "

% $
52+ %

(
43.

$ % 9 12 52 3 95 17 83 43 25* %$ % ) .$ * ( &$ % 12+ % %3. ( 5 % 6' ) $ + $ $ % 25+ $ $ % 25 ) $ % / $ %% % ) ) % %/ % V % $ % +$ % / ( "#* ) / $ ) %

.$ % % )

%+ % 12 ) .$ % 25* $ +

% % ) " +

12 52 3 95 17 83

% %* ' / ), % ( $ .$ %& ) % $ % % .$ %$ $ %% *

9X $ ) / % %& % 25+ % % 7 % V $ %& $* $ 9 % *X % ) ( +% % , $ % 8% ( $ 7 " %/ 7 % 7% % ;$ , $ % + % 7 " ' / $ 12 52 3 95 17 83 43 25 -1+ $ 12 52 3 95 17 83 43 25. -1 % % / / $ / % % . + % * ), * %% , + % % $ %/ ) ) $ $ %$ $ + 7 % ) $ $ % / * + % / *! ) , * / $ $ + $ %$ % % %% $ $ %+ . / %$ $ $& +. %& " "

% +

) $ "

+ =C < : . 0 +5 26 2 -: 2 0 -. +6

" <I "

! ' ) % %& $ % $ % $ % " "

/ *

+ %$ 5 % 6* % . ) %

% ) ( % $ / % % % %/

% )

.$ ( )

% + % $ % * $ % %% 7 , %% 8 6 % % 6+ $ % / ;$ % $ 5 % $ +
!

. . +

* . % * % % % %

+ + $ . )- % * ! ' '+ % % & , $ % +. / * % ,

+ '(

, 8 , . +

" "

% .

* , / % % $ % 3+ %+ 6' % * % % %+ % / % % * $

% % 5

* (

$ ) %

% $ %

$ % $ $ %

5 * 7 ) % %& ) % / $ " " "

. ( +$ $

% ) $ %& %% % %

.$ % * $ 9M M

% $

$ ) % % )%

%$ 5

, %

$ % $ $ 6/ %& $ % ' % ) + % % $ % + % % %% 6

+ % %$ ) %

$ )%

% * %

8 / * %( +

" % $ / % /

Z $ $ '

%% ( % ( & % ) % .

%& $ (c = )* (c <> )*

$ / cont6 . ( ) % $ % % 5% %% c6+ $ * % 5 , $ % % % %) % + % . % % % . % % $ ) % ) ) % % $ %( $ ) % 9 5% %%
% % ( ) % }

" c

variables entero cont caracter c inicio cont 0 leer (c) mientras (c <> ) cont cont + 1 leer (c)

{ { { { {

/ %$ % % %

%& % % % % % 5 } %

} } %) % 6} }

" <F "

!
% % }

finmientras escribir (cont) fin

!

{ {

%) % %

, $ * % $ > ( % % . / %

$ % + / %$ ) % % % / % % 9

% %

% ,

$ % %

* ' M N

% %

"

5$ % % M N 6+ ( ) % / ( &% % % . ) % % , $ % * / % % M N + %/ *
[ % % ( ) % \

$ % $ )"

variables entero cont caracter c inicio cont 0 leer (c) mientras (c <> ) si (c = a) entonces cont cont + 1 finsi leer (c) finmientras escribir (cont) fin [

[ [% [ [( [ [% [

/ %$ % / % M N +% %

%& % % % % \ % %) % \ \ % M N% \

\ % M N\ % \

,
!

% % $ % *

%& % $

> ( $ % % $ % $ ( & % % % $ 5 %% . / % % ) max6* % 9 % $ % $% ) . * * % $% ) %$ ) % 9 % %

/ $ / % % 5$

/ * % % % ( &% % , $ % % + + $ . %& $ $ % , % ( ) %

%& %

" % "

% . * / % )% $% ) $ %

/ %

$ % ) 6+ ( ) % % . ) % +$ $ ) % +$ . % % % / +

$ "

7 %

+$ 6* ) ' 5% ( ) %

" @C "

variables entero cont, max caracter c inicio cont 0 max 0 leer (c) mientras (c <> ) mientras ((c <> ) and (c <> ) and (c <>,) and (c <>.)) cont cont + 1 leer (c) finmientras si (cont > max) entonces max cont finsi cont 0 si (c <> ) entonces leer (c) finsi finmientras escribir (max) fin

% 9 / % / % % $ % . c <> * " . ) % / % % $% ) $ $ 5% $ % 6+ % ) % 9 (c L ) or (c L ,) or (c L .)+ . / % / % $% ) * %/ %% ) %& %) % +$ % . * / % 7 %& % .- $ %& $ +$ % 7 % $% ) % % )+% % (c = ) " )) %) % *? % + % / 9 (c <> ) and (c <> ) and (c <>,) and (c <>.) / % 8 $ % $ %) % * ) % % . % $% ) * % % -%+ ( (cont > max)+ % 7 % $% ) % / % % ( $ % & %( % % max $ % cont % max cont " / ' '. $% ) . % * $ % $ % $% ) * 7 % + % % ( " +. / %) % $ ') % % +. %% % % % ) & ( %$ +$ % % % ) % . ( %( %& " * . -% % , $ % * ( & / + % % ) ) #C+ %& $ %
F

% ) %

) % $% )

%& *

% %( % % , %( 7 * $ % ,

$ ( 7 $ %

$ * %& " @# "

+ ' +$ '

"

,
!

$ %

%% 9

! $ % , %% % % % 7 % *

, / % / %$ ) % ) $ 7 * % / 9

% % 7 % % %/ +$ % 7 ( +. / 7 %

%+

/ %% * %

%"

+ % ;$ % ) % +$ 7% 9
{ { { { { { { {

( ) % + %% ) $

" + cont

variables entero num, cont inicio cont 0 leer (num) mientras (num >= 0) cont cont + 1 leer (num) finmientras escribir (cont) fin

% / %$

) % %& % } % % 5 } 7 % }

% / % 7 % 7 % 7 % %) % } %

7 7 %6 }

%}

$ V % % % BBCCC* X
!

% %% $ % / -V X $

% %

% , $ % @*# *X 3<#A A##BI BACC BBCCC IFID "# % % V

/% % 7

"

#
! % % / % % 5 ' %/ %7 % 7 7 % * % +% 7 ( 6. %
{ { { { { { { {

7 % %$ ) % 9 7

% +

/ %% *

/ %

"

%& % % %
% / %$

( * % 9
% ( ) % %& % 7 %

7 ) % %

% * % % $ 7 "

variables entero num, acu inicio acu 0 leer (num) mientras (num >= 0) acu acu + num leer (num) finmientras escribir (acu) fin

} % } 7 %% } % % } %} } }

% / % 7 % %&% % 7 7 % %) % } % 7

" @3 "

! *X /V*

$
!

% ,

$ % <*A

$ %

$
! % %$ ) % 9 . . * " 9 # 3 A I #C #D #@ 3A 3# 3C F "#* M N * 7 % % 7 % ) ) %& %( % " % ) % * 9 %7 % +% / 7 / % % * . / % 7 %* * % * / $ % %7 % $ N +$ % " " * 7 % + / . * % $ / % / "

, $ % + 9 # < A I F #C ## #@ #D 3C 3# 3A "#* > % $ ) $ 7 7 9

variables entero num, ant logico ord inicio ord verdadero leer (num) ant num mientras (num >= 0) [ % %

M 7 + % % / 9 %7 % % .

/ % , $ ) % +

$ ) %

% % "

) %

[ [ [ [

$ % %

/ % %$ 7 8% % 7 %

\ % $ \ $ 7 \ $ \ %\

% /

si (ant > num) entonces ord falso [ finsi ant num [ leer (num) [ finmientras [ si (ord) entonces [ escribir (La secuencia sino escribir (La secuencia finsi fin

8% $ 7 % \ %) % \ / % % , est ordenada) no est en orden)

$ % ) , $ ) % $ / % * & $

7 $ %

$ ;$ %/ $ +. % + , +% 7 $ % 9 " @< " 8 $ ) , $

% + % , * $ % '

, $

&

* %

" "

%*

) +

8 $ $ ) , (

%$ %& % $ * ,

% %& % )

) , & *

$ % $ % * /

" %$ " ($"

! ) % + / & ) + %% *** % 7 & + $ % / +

% ) . ) $ + $ ( 5 ' $ ' % $ % ,
!

% (+ $ / ) , $ % $ * % + ) ,

% , + $ % 6* ) % $ % .$ $ + + % *4 ( % $

+$

( %

% ( & $ ) % 9

+%

'
% / / % 8 / % % (% % $ ) %$ ) % $ * , 5 % * $ 7 % * % $ ( 9 % + % % ) , $ ) % ) ( % % $ / $ % % % % % $ ) % % * 7 ) % $ ) % % % ( ) % % / % C5 6. 9 ; $ ) ( % % 8 . + 6+ % ( / * % 8 @ ( +$ % %$ $ % $ ) % %$" " % % . $ $ %$ / % 8 / $ % 7 % % . * %

% %

) %+ . / %

% $ ) ') C+ "#

% +@5 6 $ ) *> 8 %&

variables entero nota real matr inicio

% . +$ % /

% % *

leer (matr, nota) mientras (matr <> 0 and nota <> -1) si (nota < 4 ) entonces escribir (El alumno, matr, desaprob el parcial) finsi leer (matr, nota) finmientras fin

% / $ % % ( % % % 5 9 % ) , + % ( / ) % *

$ % 5 + % , $ % % $

( % % , $ 6+ . % %

( % $ ( $ % 6 $ % %C5 6 $ ) % $

) % % %"

variables entero nota real matr inicio leer (matr) mientras (matr <> 0) [ [ % \ % % %) % \

" @@ "

leer (nota) [ % % $ \ si (nota < 4 ) entonces escribir (El alumno, matr, desaprob el parcial) finsi leer (matr) [ % ( % \ finmientras fin

( & 7 % % $ 5

$ ) ( / $ % ( ) % / 6* % %

8 %

7 %) % 5 / %

% 6 *

) %

$ ) % /

* %

" @A "

% * %.% $ ($% % / 8 %$ ) % $ %* ) % $ % * % $ / %% 9 % % % $ +% ( %% % $ %

$ % $ $ ) % % % 9

$% $ ) % $ $ % * * % $ %

% $ $ * . % , . $ +$ % * ). % + * % %/ . $ $ % % ), ($ % % %+ ' %%

% % (

" "

%$ ) %

: + ') * % $ % % % % $ " ( "

$ $ " %

%&

(-

$ % * " @B "

#
$ & 1 : " * ( % % + $ * * +.% $ * $ +$ $ % $ + " $ / % %% %% %& , % .% * % $ & $ % " %$ ) % $ $ . %% $ * ' % " " %"

. 6 2 N 7 2 6 -2 0 5 2 0 ; 2

, , / % % $ $ %&$ 9 %& . $ $

5 ) % / $ %& + %& % % . *

% $ ( %( * %

% % * %& % )

%6 , % ( ( ( , $ % % " " 9 "

$ ( & 9 % /

$% . % + %

)%

+ % % 5 % % 6/ ( ( 5% % 6* , ( % % * % )- $ % % , $ %$ , ( &/ ( . ( %( % / %% / % ( * % / $ ) ( *

% %

$ 7 % " % %% "

2 -: 2 0 -. +5 23 3 +=+5 7 6+

/ 5 : 3 7 6?6 : 61 2 ; 7 1 0 7 6

" @D "

2 -: 2 0 -. +5 23 3 +=+5 7 6+

/ 5 : 3 7 6?6 : 61 2 ; 7 1 0 7 6

% % % / 6* % % $ % % $% 5

% %

/ % / %% 5 %

$ % )& ) % % ) /

) . ) % $ )& ; %% 6. )) $ %

$ ) % $ % * %

$ % % / )

% % <*36* % ) + % $ 5 * ( ) % * %

% "

% 8 $ %

"

O
)+% % .) ) . / $ $ % 7 % $ ) % % %% +% * ( % %* % %& % * ( ( * % % % %% %

P
% $ %$ ) % % $ % .7% $ $ $ % / +% $ % %& ( % % %& ( % ) % * % % + % $ , % % ( (% + ( $ $ %* $ % % $ %+ $ $ % / $ $ : $ + % % "

$ ( $

$ $ %+ %

%%

( &/ %

#
& " " , % % %$ $ % % * %& %+ % % $ 9
procedimiento nombre([declaracin de parmetros]) [declaracin de variables locales] inicio

! " / * ( %( ( %

% % $ / %/ %

$ $

<accin1> <accin2> ... <accinn>

finprocedimiento

%$

$ ) /

% . " @I "

% $% ) +% %

! $ %$ . " % . ) 5 $ " * * " "

." % % $% ) % % +$ % %% % % 69

5( ( $ 5 ( (

) %

$ $ . % 6 + %

%$ *

6*

%% % % %% % %& $ % ( % / %& $

. % ) %

nombreprocedimiento([lista de valores])

#
) ( $ ) % $ % % %% 5$ , , $ $ % % $ $ & " * , + %% $ % + ; ) % %$ $ % % $ 9% $ % * ( % %+ % * % % +% 9 " " $ " * 9 ' " ' $ ( %$ ! *! % % % +% 9 $ + 8 $ $ % + $ 6+

%&

<tipo de datos> funcion nombre([declaracin de parmetros]) [declaracin de variables locales] inicio <accin1> <accin2> ... <accinn> retornar(valor) finfuncion { $ % ? }

% ) % " $% ) * %& * % ( %(

5 %% . ( ) % % % % % % ( % + ) . % 5( % / % %

)& +% * % ( 6 * ) , % %

6 + % $% ) * * % ( % % %&

% ( 5 % $6

% $ + +% ) / %

% , .

$ (%

(% )& retornar(valor)* 8 $ " %& , " ( ) % * % )

7 %( %

$ + % %% %& ( ) % . %& % ( ) % . % ( ) % ' % ( ) % .

' % ( % * (-

) %& % 8 $ +. / % % % 8 $ / % % %( % 9

" @F "

! % ( % 5$ * %& ) % " * $ 6+ % +% +

var nombrefuncion(lista de parmetros)

% %& % % ( %( % % %% % % ) % %

( ( % )

% $ . ).

) . ) % $ % %& *

$ % % (

#
) " $ + 8 % $ %% " " ( %( " * % ( % % % ( %( +% ' ) % . %& % , % $ , % % $ $ ( % ;% ($ $ % % %% $ * ( %( 6* ) % %% " C+ # ( % 5 , % . %% 9 % %% ) . % , % * + % % , " % % % / % % $ $ $ %+ *! " / ' % % . : . % % +

##
7 * $ ( % % ) % 9% * % "

&
$ +' % * ) % % , % % %& % $ ) % ( $ * % ( ) % % % % " AC " * . " + ) % % %& % % ( % % % % . % 5 %$ $ % % $ % % % % ( % ( %& % $ $ ) % 5. ) % 5 ( . " 5 6+ . / $ * ( ) % . % 8 % &* . " %/ . ( " " " " ) % 9% " ) % 6 %& 6 )% ' $ % %& " %

( ) % $ $ %6* ! / % % $ $% / % % ) / % * ! ) )+ ( $ ) % % % % / $ $ $ % $ ( ) % % % 6* ( % + $ %& % ,

% % . %$ -%* % +$ % / % % ) %

% 5 $% )& %/ ( ) % / % *! / % % % ( ) % % % $ ( % . ( ( &/ % % ( ) % % ( % & ) % ) %* $ % % ( % , ) % % )% + $ ) % $ % ) +

! % ( % / $ / % 9 %( % % % ( " 6+ . $ ) " %

) %

$ ) % +$ $ % ( %

) % % % )% * 4 + % %% * $ % %& % % / % ( ) % ) % ( ) %

$ $% . % % ( ) % + %& % % )& % % 5. % % 5 % % 6* % 9 %

=,. ; 75 23 +68 +1 . +,3 2 6

% $ % * % ) %+ % $ ! $ %

/ +% ( ) % a.b .% 6; x+ y+ z+ f+ g . h ) + % % % ( ) % % )% % ( ( % * :+ ( $ ) % + % % $ % % ( , $ % * ' % %

+ + ( ) %

) ( % % % * $ $ $ ) % / ( / $

% % % ) % % ) % ' $ . $ %

% . ( % ) %

$ %% '

% $ % $

) %

" * % )% $" $ &

$ ) % %$ + % ' ) % % %

% $/ : +

.$ +$ $

$ ) % % %%

#$
$ % $ * $ %& " A# " $ +. % " )& % % % + ) , %& $ % % * % / % % % % % % *! ) ( ) % "

%&

<tipo de datos> funcion nombre(<tipo de datos> nombreparametro, ...) procedimiento nombre(<tipo de datos> nombreparametro, ...)

$ , ( %(
x,

$ % +% 7
y

% %9 . ( ) % ( % ) % %

%%

% %

real funcion calcular(entero x, y)

% .

$ $ ( %(

* % $ 7 %+

% % $ ( % 6* 5 % ,

+ % $ $ % %

$ % 7

#$
% $ $ ) + $ %% %& % % $ % % * , % $ ( % %% $ $ . $ 5$ & % $ % % (% % 6.% % * 8 % $ $ +$ %+ . +% $ $ ( % % $ , * + / ) % % % $ , %& % %

% $

% #" $ ( 3" ! ) ) <" ! ) % + $ 9 7 +$ * %$ 6* % % $ $

) %

9 $ % % + % $ $ % 9 * % 7 % ) % . . . %7 % 7 % ) 7 %* + . $ " %* $ % % % $ % % % $ % $ $ % * , $ % % + %$ %+ % $ / % % ) $ 5 %$ % $ +. % % %% % * % ) % % % % % " "

% * $ $ %

% ) + + % +

" 7 "

#$
%

$ % * 8 $ $ + % * ( $ %& % %

%$

, ( .

$ ( $ % % 9 %$

% % %% ), , $ ,

( %

/ -

* ' %& +$ $ , $ $ ( % . %$ , $

$ , /

* $

" A3 "

&
$ %* $ %( % . % % 7 $ , $ $ , 8% ( / % $ + %$ % * % % 8 % % $ %$ %* / % . . % * ( % ( % 8 ) ( $ % $ % ) % $ $ , % $ % " . " % * % "

* %$ * %

$ +% % * ) /

%& ) % , * & $

%$ , $ % $ $ ,
!

$ ( % 0 75 2 8 : 2 3 8 2 $

8 + )+% 6 % % % $ % % ) % $ $ . % % %% 7 % %

% / * 8 " %% + % ( % %& %$ * + %

/ * %$ ( ) % % % $

$ $ % %& % $ % .

( $ %& % %

). % * " " "

$ 5( % % % + % 6*

%( %

+ ' 5

)-

%& M % &+ $ %

% %$ +$ % ) %$ N % ( ) 5

%$ *! + * ) % $ $ / 6 % $

+ .$ " / %& $ , $

$ % % % * ) % / $ ( ) % + %$ ) -%* , % ( $ / % $ ( % * $ 9 ( %

8 $ / $ ) / ) %

$ % $ / %$ $ ) % / % $ ( ) % $ %& % $

$" % " " *

%
ref

$ ( % * ( ) % % )% % % $ + + %$ $ $ %

%7 %& $ $ , , $ % 9

$ $

$ , * $ )

$ $

) ( " 8 $ %" $ ( % .

procedimiento hacealgo(entero x, ref y, ref z)

%$ / y.z %

$ $

) hacealgo+ % $ $ * $ *
( !

$ % %

( %

$ ( % + y . z

#$
% % $ %( % +. % 7 % ( % * / 6 2-7 A . + % " % %

$ / % $ % " A< " %

%& %$ ,

" + %$ % % ,

. % ( %7 % * %/ %$

* ( % ( % ) %

! ) ( * + % 7 % * 6 )- %% % $ ) / " . $ 7 ) % $ )& % $ / $ * % $ %

%% ( $

* %$ % % % % ) % % $ $ % )$ &

%( %

% + 5

%/

%$ $

+$ % / * % ) ( , $ $ %$

$ %

$" % * ( %( *

) ) +$ 7 % ( % ) $ % ( %( % ( % + %
!

( % , $ ( % * $ , % $ % , $ % 9

) (

#
% . % % % $ % % % ( %$ ) % ) / $ ) % / $ % % )% * .$ % ) ) % $ %* % $ % .% $ 9 ( %( + ) % +$ % % % " ) % $ ) 7 % % "

( ) %

variables real a, b inicio leer (a, b) escribir(a, b) intercambiar(a, b) escribir(a, b) fin [ % [ [ %% [ % % % % % % \ % ) $-

% \ %

) \ ) \

procedimiento intercambiar (real ref a1, ref b1) real aux inicio aux a1 [ %( % % ( ) % a1 b1 [ 8% $ $ b1 aux [ $ % % \ finprocedimiento

) % ( %

\ \

% ' , $ %

% % % V

( % % +X % %

) ) * %

$ ) %

%& %

) % /

8%

" %

* X & V

) (

variables real a, b inicio leer (a, b) escribir(a, b) intercambiar(a, b) escribir(a, b) fin

" A@ "

procedimiento intercambiar (real a1, b1) real aux inicio aux a1 a1 b1 b1 aux finprocedimiento

#'
* ) % % $ %/ ( % +. $ ) % % ) ( %( ( ) % 5$ 6* %+ ) % )% % )% + / . % (( * ) % % ) 7 $ ) % % %& $ $ % )% * ( ) % * . % ' ) % %& (+ . " $+ %& ( % ( % % % ) % ) % ( % * 6. $ % . % ' % )% ( % % % %% % ( ) % % %* % )% + ' * $ % ) %& * ) % (%& ( " $ " +$ " ( " ( ) % + ) ( " ($ "

)- + %

%& $ ) % % )% 5 (

%/ % $ % % * % $ ) ( * +

% $ $ ) .
!

#)
!

#
% $ % % $ 9 % $ +. / % % * / ) % ( %( % P ( % *
3

%( % *

%( "

+/ % %

) %$ ) %

* %

($

$ ) % +$ %

%( -

Real funcion areacirculo(real radio) real pi, area inicio pi 3.141592 [ area pi * radio ^ 2 retornar (area) finfuncion
!

%( %

[ % %

( %

) % +$ \

% % \

#
+ % / % ) %( % %( % % " AA " % +/ ) % . %( % $ % % *

!
3

% % , $ $ % $

%$ ) %

9 % +% % $ % % +$ % " $ " -

) % % P 3PP * $ ) % %( (+. / 5 2 ,25 2 8 7 3 8 2 15 7 68 +3 7 1 2 6 * % *

procedimiento circulo(real radio, ref area, ref circun) real pi inicio pi 3.141592 area pi * radio ^ 2 circun 2 * pi * radio finprocedimiento
!

[ [ [

% % % %

%( % % \ %

( \

) % \

#
% 7 % %$ ) % $ $ %* % 9 %& ( ) % $ % $ 7 . .$ % % $ ( % % % * / * % . + % + %( % +% . %$ "

variables real a, b, c inicio leer (a, b, c) escribir(El mayor es, mayor(a, b, c)) escribir(El menor es, menor(a, b, c)) escribir(El valor central es, central(a, b, c)) escribir(La suma es, suma(a, b, c)) escribir(El promedio es, promedio(a, b, c)) fin real funcion mayor(real a1, b1, c1) real may inicio si (a1 > b1) entonces si (a1 > c1) entonces may a1 sino may c1 finsi sino si (b1 > c1) entonces may b1 sino may c1 finsi finsi retornar (may) finfuncion

" AB "

real funcion menor(real a1, b1, c1) real men inicio si (a1 < b1) entonces si (a1 < c1) entonces men a1 sino men c1 finsi sino si (b1 < c1) entonces men b1 sino men c1 finsi finsi retornar (men) finfuncion real funcion central(real a1, b1, c1) real cen inicio si (a1 > b1) entonces si (a1 < c1) entonces cen a1 sino si (b1 > c1) entonces cen b1 sino cen c1 finsi finsi sino si (b1 < c1) entonces may b1 sino si (a1 > c1) entonces cen a1 sino cen c1 finsi finsi finsi retornar (cen) finfuncion real funcion suma(real a1, b1, c1) inicio retornar (a1 + b1 + c1) finfuncion real funcion promedio(real a1, b1, c1) inicio retornar ((a1 + b1 + c1)/3) finfuncion

" AD "

'

Z * % % $ ), % 7 $ % ) $ * % 8 % 5%% % * )- ( &+ , % *

$ % +

% $

' % &

%%

% %$ % $ +$

%& %( %

$ % +

+ " , ) % "

$ % $ * ) +$ % * $ $ 6* ) % $ % ( %% 9%

%% $

, $ 8

. * +$ 5%% % %

+ $ ( %7 %% * % . % " $ % . 6.%

( % % * %& 9 9% $ % )' % %

. % % % 7 %

$ )% $ % <* " AI "

$
% $ % ( & ! $ / 7 ( % ( 9 * / % * $ + ! $* ' + % $ / % $ +$ / % ) $ ( ) % $ ) $ $ + % ) $ % / % $ * ) * $ * % " ) % + $ % * & " $ * ) % $ % % $ % % , + $ / $ $ % % % ( ( ) %

$
% . % 8 % . $ % % , % % $ % * , $ $ 9% $ %. / $ , $ % $ $ - 5 $ 5 / $ , $ ; %$ % , +$ % * % $ % ) . $ % ' + . / %) / $ % . $ / / %$ + % , $ $ $ % $ $ * +$ 9 " AF " % % $ $ % . +. 7 % " & % %$ / . $ ) % 5 % % $ ) % * %) 6 / % 6 1 & / % $ % / % # & % * / % $ $ $ % +% 7 % * % % , $ * ' $ ; " $ " / % % : % $ $ / % % % " ' ./ +% $ % " 9 $ % +% / $ $ % & $ 5 $ * .% / %% $ ( $ % % ( $ " % * $ %% $ % , ) * 6 & %$ . $ % 6* * % $

&

$ ! $ %

( % $ % 6

) ( , %

$ 5

! % %

$% % % '( )% %

% '(

$
& " ; ( " 3 " < + + ) % $ #" = $ 3" ;$ <" * % #" 3" % % : $ +/ ( 6* * %( % % % * +/ % * @" % % + % % * % $ )% % " BC " % % $ ), % 7 $ % $ % + % ) $ ' % $ % % ( % % $ % % * % 5$ , $ % + 7 7 % ) $ % & %$ + * ) . (% % % " " . % % % % % * $" %( " % " % $ 9 : , . ( + & ( * / % / / 9 ; * ' 8 &; $ * " ( % % % % % $ . , * * . / ' $ %$ % + % + % .

<"

( $

! $ $ %$ % 9 %

5 5 % $ 6*

) + % , % $ / ( % % / % % # 3

( %

) % 6 ) .% % * % % /

% %

<tipo de datos> nombre[dimensiones]

$ % + 9 % 7 ( % ( % % 9 < 7 , $ $ % + % % @ A ' % * ( ) % $

5(

6 %%

entero datos[20]

% 6+ $ / , *

( $ %

7 ), % % %

5 )

$ * % . ( "6+ $ % / $ % + )%& $

( % ) $ %& + %

% / ( % $ % + % ( ) % 8% *

% ' " ( ) % % $

%" / " ) % 5 % % ( % " %

B $

#C ## #3 #< #@ #A #B #D #I #F 3C % ( & + % ' % % % ) %$ % . %I % . (% /- $ " 9

( *! ' ;$

% #C

datos[1] 10 datos[14] 8

% #C # $ % $ $ $ $ %$ ' ) V 3

% V < V @ + V A $ (-

$ V B $ * ) % V D V I

9 V F ) + $ $ % % , / $ ( ( % % * V V V V I V V V V V V #C ## #3 #< #@ #A #B #D #I #F 3C $ $ % $ / % % $ +% %( % % 5 #.% . % $ %& % % $ % $ 7 $ 7 * +. / , % % % " "

) ( (-

( % 6* ! ' ' + % ) ; + % %&

$ ( % %/ 8 $ ( % % ( % * % ( ) % + %

$
%+ * " " % " " % $ ( % . % % % % % % % + %% $ % / $ * % % * % " B# " % * * %& ) " % 9

" " " *

%& ) 7/ $ ) %$ $ ) % 9%

% *

( % *

$ % %& $ % $ %

$ % ( , .

% ( %

% 9% % % ( & * %

( %

.% + 8 %

"

$ % *

$ $"

$# &
/ " %( " , 7 % 3. ) $ %& V # ( ( % V 3 % % % % , 9
real datos[10]

$ % $ $ % ( % 6* $ ( + %$ ( %( 3C * V < V @ V A V B B*<

% % $ % $ % * * % %

. $ $ % *

% % ( * ) % 7 B*<9 %/ 6. % 7 #+ % . % % ; + %

* *

57 %

+% # 5$ %( $ ( *

% % % % 9 "

entero datos[20]

) % +%

V D

V I /

V F

V V V V V V V V V V V #C ## #3 #< #@ #A #B #D #I #F 3C ( * +$ % / B*<9 & % 7 % +% % " % )

7 ( $ % +$ ( %%

( % %&

<tipo de datos> nombre[dimensin]

% &( * %& % , $ % %$ 8

) %

/ ( % % *

&(

) % $ $ -

%. % +

$ %

$ %& .) 7/ ( "

%& % $ %& 7 % ( $ % +. / (

* %

%% *

$#
( ) % + , %& $ % +$ ( % % $ %( % % % +% " B3 " (
*

%& $

% ( % 9

"

datos[1] 10 datos[5] 3,141592 datos[10] 457893,147

/ %
datos[11] 0

( %

$ 8

/ % % % %

' 6* , % % /

% *

5 %(

% .$

& % %

+ $ "

$#
% $ 8% 5. $ %& 9 % 6 % % %( ( % .% + % % % %& "

) %

leer(datos[1], datos[2], datos[3]) escribir(datos[1], datos[2], datos[3])

$#
%5 $ ) % 6* % %& / * % / ( % $ , $ % 9 % % %% 6* (

J
% %& %& %( % ( * ( % ) % % %& ) % ) ( % % % $ % / $ %( % % %( %% %( + $ +% / % / % % $ % % ( ) % ( 5 " $ % "

%& "

para i 1 hasta 10 escribir (datos[i]) finpara i 1 mientras(i < 11) escribir (datos[i]) i i + 1 finmientras i 1 repetir escribir (datos[i]) i i + 1 hasta que (i = 11)

%$ ( & % $ *

% %

% %( *

( +

% . %

/ %(

+ %&

$#
%&

&

$ % & %

% " B< "

! . ) $ "

$ *

/ $

$ %

+%

$##

' * 9 2 =A 3 7$

+$

%%

$ %

% $ % * $ %$ ) % ) % .

$ % %

% * 9

<#

% $ +$ % / %( $ % %( +%

) $ <# 3 %

% % * . $ ( % * #

* %

<# %

variables real temp[31] entero i inicio para i 1 hasta 31 leer (temp[i]) finpara fin

%$ ) % $ ( * $ %* % $ % %$ ) % %

/ $

% $ 7

% 8 + %(

. %

" "

9 2 =A 3 7$ $ % . % % 9 % +) 7 . $ %( +. / $ % * )% / . ( ) % % 8% % $ + % % " * ) % / * )% * % $ $ % 8 * % <# %

' ) : % % % % / ( ) % 8%

+$ % / % . $ %

variables real temp[31], max entero i, dia inicio para i 1 hasta 31 leer (temp[i]) finpara 1 temp[1] 2 hasta 31 (temp[i] > max) entonces max temp[i] dia i finsi finpara dia max para i si

" B@ "

escribir(El da ms caluroso del mes fue el , dia) fin

, ( ) % 5 +) %/ ) % 6* .

$ % +$ .6 $ +

% % #^ .

$ .% %

% %(

%( * ) %

+ &

$ .6 . %

%& % " '

$ % & %

5(

5(

9 2 =A 3 7$ % $ 8 * % %$ % % 5 % $ * $ %$ ) % , $ % $ 8 ) % . ) ( $ <# %$ 6; . % ) * % % * 9 $ ) % $ $ 8" $ % % % $ $ 8 8 $ % <# %$ % "

variables real temp[31], med, sumtemp entero i inicio para i 1 hasta 31 leer (temp[i]) finpara sumtemp 0 para i 1 hasta 31 sumtemp sumtemp + temp[i] finpara med sumtemp / 31 para i 1 hasta 31 si (temp[i] > med) entonces escribir(El da , i, super al promedio del mes) finsi finpara fin

% (

)- ( / ) % /

% %

sumtemp sumtemp + temp[i] / % sumtemp*

%(

%&

9 2 =A 3 7$ %$ % %( $ %& % % / 8 % $ %$ ) % * % + * + % . % $ % % % 9 % , $ % @*D+ $ ' ( 9 $ + ' % ) % % % % % % % % % % % . . % ( % % 7 . * % / % % / % $ )" *

$ ) % %& ( % * % (

" BA "

variables real matr[100] entero i, nota[100] inicio para i 1 hasta 100 leer (matr[i], nota[i]) finpara para i 1 hasta 100 si (nota[i] < 4) entonces escribir(El alumno , matr[i], desaprob el examen) finsi finpara fin

9 2 =A 3 7$ # / $ % ) ( D $ . 6* % % ) * $ > ( %& % $ % %% % ( 5 9 $ % $ % %* $ . / %$ ) % % % 9%) 5 % % %/ @. % . % $ ) % 8 $ $ % % % $ / %6 . $ 9 % % $ $ % . % % % % % . % %+ % $ 5 % * +% % $ " $ % $ %6* $ % 8 % .% $ % . % ') / @6+ ) ( * % $ * % 5 % % $

) ( $ / D6+ $ ( % %

5 % % %

variables real matr[50], prom[50] entero i, nota1[50], nota2[50], nota3[50], nota4[50] inicio para i 1 hasta 50 leer (matr[i], nota1[i], nota2[i], nota3[i], nota4[i]) finpara para i 1 hasta 50 prom[i] (nota1[i] K nota2[i] K nota3[i] K nota4[i]) S 4 finpara para i 1 hasta 50 si (prom[i] < 4) entonces escribir(El alumno , matr[i], est libre) sino si (prom[i] < 7) entonces escribir(El alumno , matr[i], regulariz) sino escribir(El alumno , matr[i], promovi) finsi finsi finpara fin

" BB "

$$
$ % * 1 $ * $ , %+ % % % % % & > $ % .% &%% % % : ) % % . * % % $ ' % % * * / % ' % $ & %

<tipo de datos> nombre[filas, columnas]

$ % +$ 9 / ( % % $ +$ / % *
# 3 < @ #

real datos[4, 6]

% ) . % * $

( / ( % % %

( )

) % ( % %

$ ) % % .%

% % * % $

$ % / %

),

% "

<

% ) %& % % * % $ ) %

$ %/ + ( %

( $ +

( ( % :% % % . $ % $ ' % *

:%

% %

* %

7 % / $ $ +

$$
( % % % & %& % 9
datos[1,3] 10 datos[4,5] 3,141592 datos[3,1] 4567,89

( % 3,141592 % / % * 9
# 3 < @ ? ? 4567,89 ? #

+ %( % %
? ? ? ? 3

10

% % . %( %

%
4567,89 ? ? ? ? @

% % $
? ? ?

% $ %
? ? ? ? B

% ; % %

10 ? ? ? <

3,141592 A

)%/ $ 6 %

$ ' ( %

% * " BD "

5/ 5 %( %

$ %

, %/

$$
% + %& . %% 6+ $ % / * % % % 5 % % & % % $ % % %% % $ % 6. % % . % . % % % * %$ ) % / + % % 5 % % %% % % ( ) % 6* +$ % % / ( 6 $ + +% $ %% ( 5% ) 5 ) %& + % % $ ( , %6* ) % % 5 &% % %% % $ ) $ * % + "

% " "

para i 1 hasta 6 leer (datos[1,i]) finpara

! %

+$

'

) %

% 9

para i 1 hasta 6 leer (datos[2,i]) finpara

' % % ( $ % % % . % & * % + ) % ( * 5 . 7 %( % % % ( &$ $ %

% % *

) % % 6+

% . % % 8

% & & ( $ $ %+ % / % + % % * $ % &

) % ) * % + / % % % % % % / 9 ) / $ %& 8 # %

( ( )

% %

( ( &/ % % %

"

para i 1 hasta 4 para j 1 hasta 6 leer (datos[i, j]) finpara finpara

, $

! + %& %

i.j

( $

) % %&

$ #. ( %

) %

* % $ % ( + % $ i.j.%

%& %& % $ %
j

( % * ( % % & 5j %%
j i 5i

) % *! #+ * % * $ %

% . % % "

% 6* & ( % % $ ( % 9

D6+ (

i 5 36 $

%$ & * % ( %&

#* . * ) % %% % % + )

% ) ) % $ +% % 9 %

%&

" "

" BI "

para i 1 hasta 6 para j 1 hasta 4 leer (datos[j, i]) finpara finpara

% % $ % % 7 % % % .

+$ ( 5 % , % % ( % * % $ $% . $ %$ *

% % & $ %*

% $ . % %

% 6 * % .

+% % $ % % % 7 9 %

&

entero datos[5,5]

/ %%

% . %

para i 1 hasta 5 leer (datos[i, i]) finpara

/ $ $ %9

% $

para i 1 hasta 5 leer (datos[i, (6 - i)]) finpara

( %

$$
%&

% * 9 $ % , $ % +% % $ % % %* . % & $ 9 %$ ) % _ #+ #` % _ #+ #` & 9 2 =A 3 7$ $

%%

%%

$ %

$ & % ./ % % & *

% % $ % ) *

% (

% ) %

/ % _ #+ #` $ / % $ *

) %& &. ) * % % .

;$ %" % * ) +

variables real mat_a[10,15], mat_b[10,15], resul[10,15] entero i, j inicio [ % $ &5 a6 $ para i 1 hasta 10 para j 1 hasta 15 leer (mat_a[i,j]) finpara finpara [ % &5 9\

a ) 6$

9\

" BF "

para i 1 hasta 10 para j 1 hasta 15 leer (mat_b[i,j]) finpara finpara [ % % % % \ [. % % % % &5 %6 \ para i 1 hasta 10 para j 1 hasta 15 resul[i,j] mat_a[i,j] + mat_b[i,j]) finpara finpara [ % % para i 1 hasta 10 para j 1 hasta 15 escribir(resul[i,j]) finpara finpara fin % % & %\

9 2 =A 3 7$ ' / $ % ) ( D $ . 6* % % $ ) % % % % $ % % $ *
variables real alum[50,2] entero i, notas[50,4] inicio [ [% % % % % ) % $ _+#` 9\ % % .% % \

% %* $ . / %$ ) % % %

$ 9%) 5 % % %/ @. % . $ ) % % $ % 9

% 8

% .% $ % .

) ( $ / D6+ $ ( % %

5 % % %

% ') / @6+ ) ( *

% $ * % 5 % % $

% / % . % %

% & $ %$ $ 8 9 %

% , $ % B*A* $ * % %/ +% $ %.% $ * % . % 9 % $ * / & 6* > ( %& % % %

+$ .% $ % .$ % + % $ % %

%(

% . / ) "

para i 1 hasta 50 leer(alum[i,1], notas[i,1], notas[i,2], notas[i,3], notas[i,4]) finpara [ % % % &% % %$ % 9\ para i 1 hasta 50 alum[i,2] notas[i,1] K notas[i,2] K notas[i,3] K notas[i,4])S 4 finpara [ % % % % &% $ % %9 \

" DC "

para i 1 hasta 50 si (alum[i,2] < 4) entonces escribir(El alumno , alum[i,1], est libre) sino si (alum[i,2] < 7) entonces escribir(El alumno , alum[i,1], regulariz) sino escribir(El alumno , alum[i,1], promovi) finsi finsi finpara fin

$ +$ $ % +% $ ) % %& % % %

) ( +%

$ * 7 % * % * % %

' +%

% $ % % / % (

"

( (

( *

) %

$'
+$ ( % 9 %& .+ $ . % _ #C+#C+#C+#C` 6 ) % $ % , % $ $ % + % $ $% 5 % / % :+ $ +$ % % $% $ % $ % * % $
!

+' : . $ ( / $ %% * : &5 ,

( + $ $ % % .% % / % * $ % $ $ %

6* "

* $ " "

#CCCC $

$)
% % * %% 8 6 7 * % % E / % . % %% % / % ( % $ + $ % + %& % %& + ( $ ' ( 3C 5 " D# " *
caracter cadena[20]

$ % @

. %

+ + ,

9 + 5 / % $ 6* + % 6$ * " " $ % % * ,

% $

% ), %% $ ( +% 3C

5 7 % 8 + ) % % + & ) *

% ,

%& % % % $ 9 . % %( 6* 5 +% %

% /

! $ %$ , + / % % $ % % % % . %& % ( " , %* ( " " "

% ) % % $

% (

$ ;$ *

$ ( $ % % $ 9 : 0 ( % *

$ %+ % %& $ $ , $ % +$

$ %

% / ' ( % )-

% ( % %

cadena Cadena de caracteres

cadena[1] cadena[2] cadena[3] cadena[4] cadena[5] cadena[6]

C a d e n a

>

( %

(
[%

% 9
\

cadena[1] Cadena de caracteres

7 % $ % ! % %(

% %% +

$ ) % + %% ( % %

, )
[ [

+$ 7 %
% %

/ * +$
7

% % %

( 9
\ \

leer(cadena) leer(cadena[1])

$ % %

% %

' $ / %% ( + % $ %

% $ %$ . % % $ .

% %

+$ % * % $

% % * %

" + " "

% 9

/ $

/ % *

+%

cadena Esto es una cadena de caracteres larga.

+$ '. ( % %/ %/

% $ $

% % + (

% % * %

Esto es una cadena d+ $

/ $ $ ( % 9

% +

* $ ) % / $

para i 1 hasta 20 escribir(cadena[i]) finpara

% ( %

'

/ +

$ *X $

/ $ %

% %

) ) V
!

"

$)
( / $ '+. % , * $ % + % +$ ) / % " D3 " % % * % % 9 % ( %

* +$ ) % %

'" /

! %6 ( $ % * % " +

caracter nombres[20]

% .% % $ + % %

% )

/ % ( ) * ( $ $

+$ + + ( %

/ $ ( $ % % % ) % * + ( % / ( /

) 5( ( % ) ) 9 & ( % $ % . + +

caracter nombres[20,30]

) ( +$ ' % ) ME%

( .% % %

% % %

% %% N

% . +/ ' 9

nombres[1] Blanca Celeste Amarilla

% % $ % % +

% % %

( ) ) .

) + % $ % 5 %"

% ( 6*

' + % * "

para i 1 hasta 20 leer(nombres[i]) finpara

% % %

X & &+

% $ % $ % % ( (
para i 1 hasta 20 leer(nombres[i]) finpara

& V % * %9 % / / % % 9 )% % % % . % .

% $ % *

(- & % $

caracter nombres[20,30]

& 69

)- $

&

para i 1 hasta 20 para j 1 hasta 30 leer (nombres[i, j]) finpara finpara

% % % % ' ) 9 2 =A 3 7$ ) / % $ * % $ % + % % & + & *

/ /

%$ % ) % % %

% % % , $ % B*D /

/ %

)-

% $ %* % % $

% * % % + % 9%) 5 % % " D< " ) . % 8 $ ) ( $ % .

') / @6+

! / % D6+ $ % ( 5 % % % "

% 5 % % ) ( $ * % %

) ( D %$ ) % % %

$ . 6* . % % . 9 )

. /

%/

@. %

+ 9

) *

variables real alum[50,2] entero i, notas[50,4] caracter nomb[50,30] inicio [ % % % $ % + ) . \ para i 1 hasta 50 leer(alum[i,1], nomb[i]) leer (notas[i,1], notas[i,2], notas[i,3], notas[i,4]) finpara [ % % % &% % %$ % \ para i 1 hasta 50 alum[i,2] notas[i,1] K notas[i,2] K notas[i,3] K notas[i,4])S 4 finpara [ % % % % &% $ % %\ para i 1 hasta 50 si (alum[i,2] < 4) entonces escribir( % % , alum[i,1], nomb[i], % ) ) sino si (alum[i,2] < 7) entonces escribir( % % , alum[i,1], nomb[i], % & ) sino escribir( % % , alum[i,1], nomb[i], $ ( ) finsi finsi finpara fin

$
Z % *X Y % % ) % $ -%V % ( % %& * %/ % % $ % $ ( % / %& ; ) ( -% + % % $ % / %% $ * " D@ " + % %% % % / ( ) % +% * ) % % . $ % % ( $ 7 % $ % %& $ + %& % % % % , % / . % / % % $ ) %& % $ ) % ' % $ % * % ) % $ " "

/ ( ( ) % 9 %$ , $ * (- & % % ! + %$ % % , $

$ ( % + % $ %& $ % ( $ ) % * $ $ *

%" "

%&

% + % % %+ $ ) ) % "

! ) % ( " $ & % N % " %

7 % % % % % 5 % % % ) %* %

' ' % +) ( %

% 6+ $ %

( % ) , % M

" DA "

'

() *

/ % . # ( % % *

% $ * ! ' '+ $

, $ ) ( % $ % $ % $ % $ %/ ) % +$ & * ) $ %& $ * / $ % ) % $ / $ % .% . * , % * $ % / * ( &/ %

$ % %

"

) # %

) * %

* %$ # *

) / $ $ %

% / % % % & %

"

% * $ & ) % $ # $ % # +% '

$ % $ % % % * ) +% $ % 8 + ) / % % % / ( %% + / )- % %

# % % $ 8 $ % $ %

" DB "

'
/

F %

B
* & $ % * $ 8 %& % & ( * 8 ( $ / ) % % % % 6* ;$ * % ) , ( % $ % + +% / ) 7/ ( %& 9% # ) %/ ) 7" )"

) 7/

$ / *Y % 5 8%
F %

% 7 % ) $

$ ) 7/

%$ & . % % ) 7" % &" .% #

'
% $ ) ( $ 6* ) % . % $

) ) / & $ %$ ' %% % % % , $ % )% v <C 5 6 %

, & 5 + $ + %& * $ (

5$ %

$ % $

( % ) 7/ %*

6 ' %

% 6+ %*

% %/

"

% E7 / $ entero 5 % %

) % % $ ) % % 9 % dato %& ) % ubic %

) 7/ $ % %( : % % 5 $ % $ % % % $ * $ %+ % (

% busqueda* +C . / $ buscar . tam6* ( % ) * ) % dato %

) % pos ) +% (

) " 8" )"

variables entero v[30], dato, ubic inicio Leer (dato) ubic busqueda(dato, 30) ... fin entero funcion busqueda(entero buscar, entero tam) entero i, pos inicio pos 0 para i 1 hasta tam si (v[i] = buscar) entonces pos i finsi finpara retornar (pos) finfuncion [ [ % ' % % %% $ ) %( % ) 7/ $% 7 v\ +$ %$ % \ \

[ % %

%(

5' " DD "

%6+ .

% 7 %

! C / % 7 %( 6 % * % ) % pos % % ) % % / ( % ) 7/ * $ %( ' % %+ % % % ' * % % % % % $ 9 * %( % *

( . % % 7 % 7 ) ( % %$ 8 / % % $ ) 7/ ) % ) ) +. / / % % $ % &$ ) %

* ( ) % pos % ( % i 5$ - $ %( %( +( % / % % $ % $ $ + %

%& + % 9 % * , C %

% )%

entero funcion busqueda(entero buscar, entero tam) entero i, pos inicio pos 0 i 1 mientras ((i <= tam) and (pos = 0)) si (v[i] = buscar) entonces pos i finsi i i + 1 finmientras retornar (pos) finfuncion

% % mientras . % % 8 / %( & % )

( ) , %( 5$ $ * ,

( %

$ %

mientras

repetir*

C / $ $ % +$ 6* $

% ( ) % pos+ % ) 7/ * $ * %& % ) 7/ % )

$ C ( %( % $ % ) ) * & $ / , %$

% /

) $ % + %" $ $"

'

F %

% ( %

) 7/ % *

$ %

) %

% 6*

5% ) %

" ("

% ) 7/ ) $ % % ) %/ ' %% % %( " + % % % % ) 7/ % &+ ) " 7 % ) 7/ ' % ' ' % & / %( % %* %( " . % ) . % + % % & / .% ) 7/ " 7 % '+ $ % / %$ $ 9 ) ' %% %( % % % % '* % ) % + % ' .% ) 7" / 7 $ % & / * $ ( %( $ ( & $/ : $ ' ' %% % ) ' / $ %& ( . % % $ + % . / %( % ) % % * ( , % / " DI " ( %( % ACR %

! / ) ( , % ) 7"

% /

) % ) (

/ *

%& % ) 7/

variables entero v[16], dato, ubic inicio Leer (dato) ubic binaria(dato, 16) ... fin entero funcion binaria(entero buscar, entero tam) entero ini, med, fin, pos inicio pos ini fin med 0 1 tam (ini + fin) div 2 [ [ % ' % % %% $ ) %( % ) 7/ $% 7 v\ +$ %$ % \ \

[ % %

mientras ((ini <= fin) and (buscar <> v[med])) si (v[med] > buscar) entonces fin med - 1 sino ini med + 1 finsi med (ini + fin) div 2 finmientras si (v[med] = buscar) entonces pos med finsi retornar (pos) finfuncion

$ %% (

) , ( A # : % % D 3 %( $ ) %

% $ #B % #C <

) * ## @ #3 A

$ $

% ) 7/

% ) ( <# #3

% ) ( 8 $ % + << #< @# #@ @3 #A @A #B

+ $

#A B

#D D

3C I

3< F *

3@ #C

3B ##

& + % % ) $ ) %/ ' % ) 7/ ) %/ ' % ) 7/ * 5 C 6* & % %

9 % ) 5 ( ) % ini+ med . fin ( ) % pos % $

% , $ % 6. %& $ "

buscar6*

% 7 % % $

, $ % % ) 7/ % 7 #A 5 $ $ % ( ) % % % ) 7/ + %& % ( ) % pos C5 / 7 ) 6+ ini #5 % $ % %( 6+ fin #B 5$ " %( 6. % % % $ % 5med6 n fin . ( " 35 ( 6+ % $ % %( 5med I6* % % 9 " DF "

! 3B <# % << ( % ( @# @3 @A

#C

##

#3

#A

#D

3C

3<

3@

%) % *! % $ % + % #A $ med 5/ ( % I6 5D6 . ( % % ( A > ( % / / ' %( % ( D #C

(ini <= fin) and (buscar <> v[med]) - +% v[med] > buscar )-

5 %( % ' % 3C6* 15 % fin D6 . 3 5 med L @6* ## #3 #A #D 3C 3<

%(

+ ' % % ( 3@ %( % 3B
med

% <# <<

+$ % / +$ % / $ $ % fin % ( % n 5#6 fin 9 @# @3 @A

% %) % *! %

(ini <= fin) and (buscar <> v[med]) - +% v[med] > buscar '

ini % ( % $ med 5/ med 5 med L B6* (

%( 5 % #A ( % @6 15 % #D 3C 3< 3@

% % ini 9 3B

& / A6 . <<

% ( +$ % % +$ % % ##6* ' ( % % @# @3 % @A

A ' % %

#C

##

#3

#A

<#

% % $

pos $

+% %( %

(ini <= fin) and (buscar <> v[med]) % . v[med] = buscar ( $ % / med 5A6 / %( % ( % $ % * %( %

%) % * $ % & %C ( %

*
F %

'
% $ $ % % ) 7/ ( > % ) V % )9 ) , ) 7/ ) % % % ) 7/ % ) %& % $ % $ ) ( / *

) ( ( % ) 7/

$ % %* +X

+. / % ) 7/ / $

) ( $

"

%( ) ( $$ 9 *

) % % $ $ ;$ % ) 7/ %$ % ) 7/ ) 7/ ) %&

% . % $

/ % ) % $ ) + 5 % % $

% %

) % $ % %( ) $ ' %% % 7 %

" $ * % % % " )

/ % % % /

$ ) 9

$ * * $ % $

$ ) $ ) % 7 % % $ $ ) %( / ( % % $ + * ! $$ ) + %( ) % % %+ $ % / $ ) % ) 7/ ( $ / $ ) % ) % % ) * 9 $ $ $ $ %& $ 9 $ " IC " $ $ $ $

+ %/ ' $ ) $ %( $ ) %

%( 6* + % $ 8 $ $ ) $ ) % % ) 7/ / %$ ( %

' ( % " "

% ( % + ( % + ( % + / ( % 3 "# ( %

+ $ ) % *

! $ ) 9 ) ? ' %$ ! ,@0% 7 / % %

+ V $ % ) % 5>6 $ $ %$ % ? % % ) 7/ ( % % ( %

( $ 5 ) ) ' %%

> % +X %( 3 " # b >*

% ) 7/ % % $ >S3 $ ) + / ,@0%A 0 @ B 7 ! ,@0%C ,D / 7 ! %& % 6* ( , ) % ) 7/ * % %

+% ) 7/ ) % /

'
$ +. % / / , , % % , % 8 % % % " $ $ % % % ( A ) < c D @ #C F % % ( ## #@ % #3 #B $ ( % $ 9 #A #F #D 3A + ( 9a 3C 3# ( / % ( * % * 7 , ( $ % +b ) . 7 * $ * " . . % % 9 * " * .% ) ( % $ ( %( $ $ % % * % ( . ( ( " 8" .

%$ ( + $ ( ' % ( ( * %

'

/ % $ % $ %3 % a[1]+ * ( a+ j % % ( b+ . k % % ( % ( * 9 7 A ) <
,

a.b/ b[1]+ % %4 % / ( ) % c6+ $ / ), & #5 % $ #A #F #D 3A 3C 3#

c+

$ ) ( / %$ b[2]+ % %5 / " 5%% i % %( % $ % ( & # ( 6+ % "

D @

#C F

## #@

#3 #B

%$ $ % $ % + % b[1] c[1] + A D #C

$ c $ % ## #3 #A %5

% % %3 #D % 3C

% $ ( 3#

a . b :% c. %( / $ a.b * % % 9

$ %( % $ % $

( $ 9 %3

" I# "

) < <

@
,

#@

#B

#F

3A

' $ %5 A ) < <

( %( $ % a[1] %4 b[2]9 + % 9 D @ @
H

% $ #D 3A 3C

%4 3#

a . b :% b[2] c[2] .

$ (

"

#C F
,

## #@

#3 #B

#A #F

' c[3] . A D @ @ #C F
,

$ % ## #@ #3 #B

%5 #A #F

a[1] % #D 3A

%F ( 3C 3#

b[3]+ a . c+

% % b9

%A$ % /

) < <

A
H

b+ % 15 a. $ A ) < <

( a+ % 16 ' D @ @ #C F A

$ b+ % 17 ## #@ D #3 #B F

%( c % 7 a; % 9 a+ % 19 b+ % 20 . % 21 $ 9 #A #F #C #D 3A
,

b; % 10+ % 11+ % 12 a+ % 14 a* / %% % % %(

3C

3#

## % &+

#3 % /

#@

#A $ %

#B

#D

#F

3C % %

3#
H

$ % + % 25 % %

% ( b[7] c[16]* / % (

( %$

5 $

+ %$

a+ b . c % )% intercalacin %

.$ % 9

procedimiento intercalacion(entero tam_a, entero tam_b, entero tam_c) entero i, j, k inicio i 1 j 1 k 1

" I3 "

!
b. % ( $ c % (a b) %% \ \

[ [

$ %

) % %) %

$ $

% %

mientras ((i <= tam_a) and (j <> tam_b)) si (a[i] < b[j]) entonces c[k] a[i] i i + 1 sino c[k] b[j] j j + 1 finsi k k + 1 finmientras [ [ $ ) % % , $ % $ a c % b c \ \

mientras (i <= tam_a) c[k] a[i] i i + 1 k k + 1 finmientras [ [ $ ) % % , $ % $ % b c ( 7 a c $ ) \ \

mientras (j <= tam_b) c[k] b[j] j j + 1 k k + 1 finmientras finprocedimiento

$ * % ( %

tam_a+ tam_b . tam_c

$ %

% '( .%

( * %

a+ b . c

" % "

'( ( '( /

. %& '( *

$ +

7 %

'
* +

B
& ( % %& '( * % $ ' + ( . % $ * ( % % % % ) 7/ / % & % % ) + % * ) / 5 " I< " % : %& % % 6* % %% %$ ) * % % % % %& , % % % / % % % % * % %& 7 % % * * % / + -% 5 " "

) , 8 ;

% ( 6* 8 $

$ %& ) % 7 " ( %

! % / $ %& * * $ %%

, ) . %% $ %

5%% +$ % %% +

" %

'

Z. #" 3" <" % #" 3" <" 9 %

&

$ $ $ . $/ : % $ $ $

%% % % %

$ * $

% .$ $

$ %

9 * *

/ % $ $% 7 % )

%& $

% )

* * *

'
% % % % $ $ % / $ % & % % ( * " " E " " % ) % $ , ' 8% + % % % % % + % * , ( $ %% + ) ( % ( F F % ) % $ ) ) $ F + %( ( I F $ # % #A / # % " I@ " 6. %I #A 9 # 9 < #3 A D #@ % #A+ $ ## 8 I " < #3 A D #@ ## 8 ) I $ % #A ( # < v #C % #3 A D #@ ## %% % % 8 I . ( 8 % , ) $ % % $ 0 2 L 1 . ; +6 6* ' $ % )" ) % 8% 9 %( % % $ % & ' % % ' % * $ % ' ' ( &/ "# ( + 9 % $ + % + + + % , * %$ / $ %& 9 %$ % $ % * & %% % % % . , , $ * * . ( $ "

%& ( ) % % % % $ %$ % %) % % % $ % 7 %

% % ) " 8% / % " % 5 %$ $ 6* ! + ) % " $ % %( *

%F % $ ) %I % ( ) % 8% % I9 # < #3 A

5 % %% 5 % . $ % & %F D #@ ##

! ' #@ ## % F* 8 $ % & # "

$ % & -

' 7 ( % ( ' ( ( ( ( ( ( ( ( ( ( ( ( (

% F I $ I $ # # # # # # # # # # # # # < < < < < < < < < < <

'+ . / ) #A % F % $ F I I I I #A F F F F I A A A A A A A v % D D D D D I 9 #A

% #A % #9 <

) #3 A D

< )

#3 . #3

A $ A A A

#@

## % <*

%# I

D D D D D D ' #A #A

#@ #@ #@ #@ #@ #@ #@ #@

## ## ## ## ## ## ## ## ##

8 8

< <

#A #A

#3

8 #3 8 #3 8 8 8 8 A A D D

#A #3 F F I I I I I I $ 9 #A #3 #3 F F F F F F

A # #A #A #3 #3 #3 #3

8 #@ 8 #@ 8 ##

#A #@ #3 #A #@ #@ %

##

#A #A %$

8 ## 8 ## $ % % 6+ %

##

#3

/ %( insercin

. % )% 5

procedimiento insercion(entero tam_v) entero i, j, aux inicio para i 2 hasta tam_v aux v[i] j i mientras (aux < v[j-1]) and (j > 1) v[j] v[j-1] j j 1 finmientras v[j] aux finpara finprocedimiento

" IA "

'
% 8% $ ) / ' %% % % $ % $ % ) % ( % ) $ % 7 % $ % % % $ % * % $ % $ ( % + %$ % ) % I $ % ) ( ( $ %/ ) $ F # ( %I ( ( ( ( ( ( ( ( ( ( ( ( ( ) # # # # # # # # # # %( % $ # # I < +% < < < < < < < < < < $ #A A A A A A A A A A % , % $ 35 #A #A F F 9 F F F D D D D D D D $ % / " IB " I I I I ) I I I I I #3 #3 #3 #3 #3 #3 #3 F F F # #A #A #A #A #A #A #A #A ## #3 #3 #3 $D D ' F F F #@ #@ #@ #@ #@ #@ #@ #@ #@ #@ #A ## ## ## ## ## ## ## ## $ $ $ $ $ $ $ $ $ $ D D I I A A I I #C #C + % % )" I % #* $ %F/ ' %% I I #A #A % F #A ) %( % $ < < % $ $ #3 #3 ' %% #5 A A % $ 9 69 #3 #3 A A D D #@ #@ ## ## $ $ A A ' %% D D 8% $ , $ % pos < % % %( 9 #3 % 5@6 % A D #@ $ ## $ % % " 8% pos+ % 69 @ @ ) % A. % " v % #C % % * %& % % + $ 9 $ % % * * * %% %& ( % % + % % % $ ) % * % % ) % %

$ % % / % $ % ( ) % $ % $ "# ( + + " E " " $ % % ) % "# ( ( .% ( ( % $ +/ F )

' %% % % ( ) % $ % ( ) % #@ #@ % %< ## ## $ $ % % $

% -$

! * $ % %& $ %$ % ( ) + * $ % " %

%$

) %

* > ( 6+ % $

' %& % ( / % % ' %% % #@ . $ '. ) - $ + / %(

% % #3 . ) +. / ) % %

v $ $ seleccin

. % )% 5 % % 9

procedimiento seleccion(entero tam_v) entero i, j, pos, aux inicio [ %) % 8 %&$ / %( tam_v - 1 ( \ para i 1 hasta tam_v - 1 pos i [ ) % %&$ ) % $ % ( % % $ \ para j i + 1 hasta tam_v si (v[j] < v[pos]) entonces pos j finsi finpara [ ( [ ( [ $ [ . % ) % pos ) % aux ( % % ) % %&$ %& % $ i 5$ % $ pos ( % ) % $ % $ % % 6 % * \ \ \ \

aux v[i] v[i] v[pos] v[pos] aux finpara finprocedimiento

'
) %& . % : " " " . %( %( $ $ %& ( $ F % I #A $ ' % / * ) $ ) % "# ( , % % * % $ % . # $ % ( < ( % " ID " * ) % #3 + 8% A ; D #@ % ( $ ## + v % #C % ) 9 8 %& % ( ) % " $ $ 9 * ) % $ ) / % $ % $ $ * %/ % . ( % * %$ % $ % "# ( + % $ % $ $ ( % $ )- $ ) ) 5 $ * % 6$ %

! #@ ## 8 I

8%

% ( F

) 9 I #A # < #3 A D

% (

% I

) F #A $

9 # %F ( ) < #3 A # < #3 % #A+ ) 9 D #@ ## 8 # A D #@ ## 8 7 % $ "

% #A . % #* ( I F #A

% ( % #A % #A %

9 I F # %$ % D+ % #A ' ' F # < #A < #3 A D #@ ) $ % % $ ## $ $ #@ #@ #@ #@ * %& %& % $ ( ) / #A #A #A #A #A %I ## % #A ) ( 7 8 % <+ % #A % #3+ + ( $ % & * % % 9 " ) % #@ %( + % #@ . % #A % ##* % 7 % $ + $ % . 7 #3 A %F D #@ + % #3 #3 . #@ #3 #3 ## ## ) % ## ## #3 #3

% / % A+ % #A $ % & % % & / * ( I

8 % F; % +$ % / ) +$ 8 8 8 8 7 . ') %& % ( ) * $ % % ) % 6+ %

) %F % #3 % ##* %

& ( % $ %#. %F % <* % $ % A . % #3 % D; % $ % % 9 ( ( ( ( ( I # # # < < % / $ % ) * ) * ) / / %( $ $ %& < I A I # < 9 F A D A D I % F A

D D F F

) %&

) % 6+ % %

5 :% $ $ ( ) % % / :% ( % % $ ( %$

8% %

% +/ %

$ . % )% 5 $ intercambio 9

procedimiento intercambio(entero tam_v) entero i, j, aux logico ordenado

" II "

inicio i 1 ordenado falso [ %) % 8 %&$ / %( tam_v - 1 ( \ mientras ((i < tam_v 1) and (not ordenado)) [ ) % %&$ ( % ) 7 * \ ordenado verdadero para j i hasta tam_v - i si (v[j] > v[j+1]) entonces ordenado falso aux v[j+1] v[j+1] v[j] v[j] aux finsi finpara [ ( [ ') [ ( finpara finprocedimiento ) % ordenado verdadero ) +$ % %( ) % aux %&$ %& % / . ) %7 % % % %) % . 8 \ * \ * \

'
% % $ $ $ ) ( ! * $ % $ , % $ % & $ % 6+ +% ) + , ) % $ + $ % $ % +

%% % 6* % % % . % % %

$ %

% %

% seleccin* $ intercambio

insercin 5 % $ 5 * ( % +$ % % " + %

$ ( &/ % % seleccin* ( & *

% ,

$ $

'
' +$ % $ $

&

% , + % 6 ) * %

( & , +$ % $ % ( ,

% * ) %$ % , $ ;% 8 $ * , * % * ( % % 5

/ $ % ( $ / %

$ $ . %

$ %% % + ' ) +$ % -

$ $ %

" " *

? % . $ % $

/ % " % " +

. / ) % $

( & +$ $ % / ) % )

" IF "

'
) % % %$ $ $ % + 5

"

J
$ ) 6/ % % $ + % . * % ( % ( % " " "

$ insercin directa+ $ (% % % intercambio* 7 % / % ) 6 $ %% ( . + % / 5%% * %$ $ S3 5 ( 6+ % * ( &/ %& ) +% 35 + %% ) 6' #+ $ $ % % %& % % % intercambio* $ intercambio % ' %% + $ % E " " " " ) % 8% $ %( % ( + % ( ) $ $ +% % ) % %$ % $ %( salto+ ( F % 6+ F I % #A % #A # < I #A ) # / % % v #C % 8 $ % < #3 A D $ #3 $ ( #3 ) % A A D 8% D #@ $ #@ % ## ) 9I %A5 6. %< #3 $ % % salto* / ' I #A #@ I #A #@ + % ## 5 ## ) +$ $ ( % %& 39 < #3 ## % #@ 9 % % * ( $ $ 5 % 6* % ( % ) $ ) % % -

insercin directa+ . / " $ % $ 5 % 6+ % / % * % $ $ ) / . %& 9 ## % ## L% % A* ) 69 % A % % A " % S35 % % 9 * $ & / C* . ) * ( "

' $

% % % % salto L A9 # <

/ % ) 5 F
salto

$ + $

%F

A+ ) %& % % #3 5 6+ % I ) 6+ % # % #@ 5 ) 9 A D % #@ . < # < A. ##+ %

A . #A D* ) 6+ % #A 6* % % / ( $ 3 A

%D5 %

( ( #3+ A I+ D %( % ) (

F #A+ #

$ 9F * 3 5salto S 36 5 "

( %( 9 salto S 3 L 3* 6 7 / F A D #

% %

) 9F D+ A #+ F <+ F I+ #A ##9 % $ %F %D $ " ) +% $ %A %#. )) * %F$ " $ %% %D5 %$ ) 6+ %F %/ $ %<$ ( ) * % A 5/ $ %% % #6 $ % #3 5 ) 6+ % F 5/ $ %% % <6 ) % I* $ % #3 . % #A $ ) + " " FC "

! ) #@ #A 3. #@ #A #A+ 5 % %/ / % % % $ % 3 ) 5 $" 6+ $ , ) 9 % ( % C* # ) . %& 3 % " 9

% '. ( ( %( ) 9D (

% F . % #@+ $ D # < . #3 < # D < % A % ##+ A I % I

% #A . % ##* % #3
salto

% $

##

9 ## F+ ## 39 ' % F #3 #3+ F 3 $ #@ . #3 salto L #* % % . % % #3 . ) $ #@ #A $ ( salto %

< % /

( D+ # A+ D ) ( %( ? %

$ I+ A ##+ I ( % salto $ )- ( #+ F9 < % +. / % A %$ D I / %

+% % intercambio6+ $ $ *
salto

<

#+ D %

A . ## ( # % % %

## (

+$ % / )

procedimiento shell(entero tam_v) entero i, aux, salto logico interc inicio salto tam_v div 2 [ %) % 8 [ ' / %( %&$ / / % % , \ \

mientras (salto > 0) interc verdadero mientras (interc) [ [ ) % $ , % % '. ) % \ \

interc falso para i 1 hasta tam_v salto si (v[i] > v[i+salto]) entonces interc verdadero aux v[i+salto] v[i+1] v[i] v[i] aux finsi finpara fin mientras [ [ [ ( ( ) % interc verdadero ) +$ % %( 7 ) % aux %&$ %& % / ) %7 % . %$ % ') * . \ \ * \

salto salto div 2 finmientras finprocedimiento

" F# "

'
) % ( % % $ +$ % / ( ) % % ( & ( / % $( * & * % ( % / % E " " " " " " " % $ % $ +. +% % % % $( % % & / ( $ 5$ % % , ) % % + % & / ) * + % % ( % + % % % $ ( %

%
%( % % ' $ / % %

% % $( ) ' /

% & %% " * %/ * ( % ( % % % % * % % ' ) ( % . / % $( + . ' ' % & / ) ( % $ ' / ) ( % " ( $ 9 % & / % % . % ' % . * 7 ') % $( * %$ $ $ '. $ * " % %( % $ $ % % 9 * * %6* ( % . / % $( ( % / % $( ) % * * + ) % % % * %( A % #3 A D ' %F A D D #@ #@ %& $ / % $( #@ ## v #C % ## % <* % 9 i+ . . / ##

/ $ % $ ' / 7 '. ( % / $ % $ + %& ( $ % ( F % ( ) ( F 8 $ % I ) % I #A & j* ' 5 j6 F . # , %I ) ( # ) < %& % + % . '9 % ; ( %$ I I % #A

' & / $ % % ) $ % $ 9 # % $( #

' ) )

% ) ( #3

% $(

* "

%& < / %

/ .

0 2 L 1 . ; +6 9 %

' & / % $( + . $ %

% % & / #A 7 % #A F # ,

9 & / 5 i6 %# $ #3 9 #3 . I #3 A & / A :% % & / ) D

#@ j #@ / % $( )

## & ## % * 5 % ' ( $( ' . % $( $ % ' " i+ $ % /

. / % $( % $( 9 #A F

+$ D

? ) +. / % ( % $ & /

%&

$( + $ % +$ % / % 9

$ %( %#$ % / )/ - 5 6* % #3 . % $ % 9 # < #A F I

% $( 6. ) % & / D #@

## ,

" F3 "

! D / D , #@ #@ $ % #A % % #39 #A $( ') * 5 i6 . $ ;. %A % #A ' ' % ( / % ' #A %

) ( 7 % ) * ( % % $( 6. ' / $ % 5$ j6+ $( ( % % %I % (

% # <

:% ##

9 F I ' %% I ( A ( % A %( % I D 9 % $( % % $( ) D % A

i.j' # i5 j # < < % ## & / & ## F 6 i+ F

#@ 5/ . ) %D #3 #@

( $ 5$ ') / $ 6. % & / $( % ## / / - 9 # < . % & / ## F &

' %7 % +$ % / 5 % #36 / 7 . A , ## ) $ & / . / #3 #@

) 9 ( % ( % % ( $ ( + ) % > %* %% . 5Y % % H ( M +$ / 9 # < ) A + D ) $ % / %& I % % ) ( N 6+ %& % F $( ## #3 #@ #A +$ ' ( % $ + 7 6+ $ * ) " " " . $ % % ' %& * % % " 5 % # # < + ' %% < % A A F ) D , F #3 ) ## #3 ) #@ % $( #@ #A % #A / 9

%F. %D/ D ) , i.j

'
% 9 $ 4 + 8 $ ? 7 / % * / %& % -

$ . ( +

5Y H '. ( % (

% $ % +-

% * %&

" ) ' % * * $ % % $ % "

%+ .) 5 $ % % 6* " F< " $ + % .$ % ( $ ) 6 ) % -

% +% %& $ $/ : 5

! ) % % * " ) %

% $ . $

, 8%

% /

% %% (

" F@ "

$ % #* #*#

7 0 -2 A ; 7 6 : 0 5 +=2 0 ; +3 2 6 &
#*#*# #*#*3 #*#*< #*#*@ ! % % % % % % ) % ) % ) %

3
3 3 3 3

#*3
#*3*#

$ %

%
% %

<
<

#*< ! : #*@ $
#*@*# #*@*3 #*@*< #*@*@ #*@*A #*@*B ! !

< @
@ A A A A A

? % , > " ' , > % % ,

#*A
#*A*# #*A*3 #*A*< #*A*@

,
, , , / E , >( % % >( %

A
B B B D

#*B #*D #*I

$ , $ % %

D D I ## ##
$ $ % ! ## #3

$ % 3* +; 7 6? E A 1 2 6 . 7 0 2 6 3*# ! 3*3 $ !
3*3*# 3*3*3 % $ !

3*< G ) % 3*@ 8 $
3*@*# % % 8 $ $

#< #@
#@

3*A 3*B 3*D $ % <* <*#

$
3*A*#

#A
#A

$ ) 1 7 L 1 +=+-. / 0 6 ; 1 : -; : 1 +5 +

#B #D 3C

<*#*# <*#*3 <*#*<

) ! : ! E " FA "

3C 3C 3C

<*3 <*<
<*<*# <*<*3

.
$ $

33 3<
3< 3<

<*@
<*@*# <*@*3 <*@*<

+
% $

%
E

3@
3@ 3A 3A

<*A
<*A*# <*A*3 <*A*< <*A*@

%
% % ( $ (

3A
3A 3B 3F <<

<*B $ % @* @*# @*3 @*< @*@

$ %

<@ ' <I <F @# @< $ @D @I @F AC AC A#

, A3 A3 A<

1 7 -2 6 +=. 2 0 ; 75 2 2 -: 2 0 -. +6 / % 7 ) ,

$ % A* 1 7 L 1 +=+-. / 0 7 5 : 3 +1 A*# % A*3 A*< ? A*@ $ A*A c ) % G ) % A*B

A*B*# A*B*3 A*B*< $ $ % % , -

.?

A*D A*I

% , $ % !

AA AA #) AF AF BC B# B3
6 ( " FB " B3 B< B< B< B@

$ % B* 6 ; 1 : -; : 1 +6 6 ; C ; . -+6 B*# ! B*3 % $ B*< % B*@ $ % B*A G

B*A*# B*A*3 B*A*< B*A*@ B*A*A . %5 , %& $ %

B*B
B*B*# B*B*3 B*B*< & , $ %

BD
BD BI BF

B*D B*I
B*I*#

%
%

% ?,
?,

D# D#
D3

B*F

$ %
% E7 /

D@ '$ DD
DD DI IC

$ % D* H 6 < : 2 5 +? 1 5 2 0 +-. / 0 D*# E7 / ! +

D*#*# D*#*3 D*#*< E7 / E7 / $ % E %

D*3 D*<

% D*<*# D*<*#*# D*<*#*3 D*<*#*< D*<*#*@ D*<*3 D*<*3*# D*<*3*3 D*<*< ! $ $ $ $ ( & $ $ ) % ! ! ) ! ! ! Y H 5 ' %%" & 6

I# I<
I@ I@ IB ID IF IF FC F3 F<

" FD "

ALGORITMOS Y ESTRUCTURAS DE DATOS

CAPTULO 8

ESTRUCTURAS DINMICAS LINEALES

INTRODUCCIN
En captulos anteriores se han desarrollado las estructuras de datos estticas. stas permiten el manejo de un gran volumen de datos bajo un solo identificador, pero estn limitadas a la declaracin inicial en cuanto a su tamao. A partir de este captulo se comenzarn a estudiar las estructuras de datos dinmicas, comenzando por aquellas de organizacin lineal. Estas estructuras de datos permiten manejar en forma dinmica (de all su nombre) al conjunto de datos, por lo que no requieren la definicin del espacio de memoria al momento de programar. El uso dinmico de la memoria permite crear estructuras de datos que se adapten a las necesidades reales de los programas. Como veremos, estas estructuras de datos son muy flexibles, ya sea en cuanto al orden, la estructura interna o las relaciones entre los elementos que las componen. Para su construccin, se requiere el uso de apuntadores: un tipo de dato que permite almacenar la ubicacin de otro dato; una estructura de datos llamada registro: una coleccin de datos que constituyen un nuevo tipo de datos y la implementacin fsica de un tipo abstracto de datos. Estos elementos son necesarios para la implementacin de las estructuras dinmicas. En cuanto a la clasificacin de las estructuras de datos dinmicas, las hay lineales y no lineales. Esta clasificacin hace referencia al orden de acceso a los elementos que la constituyen. En este captulo, se tratarn exclusivamente las lineales pilas, colas y distintos tipos de listas. Comenzaremos por los conceptos de registro, tipo abstracto de datos y puntero, necesarios stos para la implementacin de cualquier estructura dinmica.

- 92 -

ALGORITMOS Y ESTRUCTURAS DE DATOS

8.1 ESTRUCTURAS DINMICAS

Una limitacin que se presenta con las estructuras de datos estticas es la necesidad de conocer la cantidad de datos a procesar al momento de programar, para asignar el espacio de memoria. Esto rara vez sucede y adems, para distintas ejecuciones la cantidad de datos puede variar. Ante esta dificultad, las estructuras dinmicas no requieren la definicin del espacio de memoria, a stas se asigna el espacio durante la ejecucin del programa. Una estructura de datos es dinmica cuando la asignacin del espacio de memoria requerido se realiza durante la ejecucin del programa. Esto permite que la estructura ocupe ms o menos espacio de memoria de acuerdo a la necesidad de datos durante la ejecucin del programa. Existen diferencias claras respecto de los arreglos: - En la declaracin no se indica una cantidad mxima de elementos, puesto que esto vara durante la ejecucin del programa. - El conjunto de elementos que constituye la estructura, no necesita de un espacio contiguo de memoria. - No se utiliza un ndice para referenciar a los elementos, sino un puntero. - Existen limitaciones en cuanto al acceso a los datos: el acceso a los elementos de las estructuras dinmicas lineales es nicamente secuencial. Para la implementacin de estas estructuras es necesario conocer previamente algunos conceptos no vistos hasta el momento: registro (un tipo de datos definido por el programador), tipo abstracto de datos (una herramienta con la que se especifican datos y operaciones vlidas con ellos) y punteros (un tipo de datos especial que se utiliza para almacenar direcciones de memoria). Estos sern los temas a tratar previo a la construccin de estructuras de datos dinmicas.

8.2 LA ESTRUCTURA REGISTRO

Constituye uno de los tipos de datos estructurados ms utilizados. Permite agrupar datos de distintos tipos con cierta conexin lgica bajo una estructura nica. Por ejemplo, los datos correspondientes a un alumno pueden consistir de una matrcula, un nmero de documento, su nombre, su domicilio, su fecha de nacimiento, una direccin de correo electrnico y un promedio de notas. Esto puede involucrar datos de distintos tipos (cadenas de caracteres, nmeros enteros, nmeros reales). Este tipo de datos lo debe definir el programador segn las necesidades del algoritmo (de hecho, el registro es un tipo de datos definido por el programador). Definiremos Registro, como una estructura compuesta de un conjunto de valores con las siguientes caractersticas: - Los valores pueden ser de distintos tipos, es decir, es una estructura heterognea. - Los valores almacenados en un registro se llaman campos y cada uno tiene un identificador (un nombre, similar a una variable). - El espacio de memoria ocupado por un registro es fijo, esto lo convierte en una estructura esttica. En el apartado 3.2 (Partes de un programa) se vio que la primera parte est reservada para la declaracin de tipos de datos no estndares. El registro constituye un tipo de datos no estndar, por lo que deber declararse en este espacio.

8.2.1

DECLARACIN DE REGISTROS
Para la declaracin utilizaremos la palabra reservada tipo en nuestro pseudocdigo. La decla- 93 -

ALGORITMOS Y ESTRUCTURAS DE DATOS racin requiere un identificador (nombre para el tipo) y un cierre con la indicacin fintipo. Entre el encabezado de la declaracin y el cierre se declaran los campos que lo constituyen, cada uno como una declaracin de variables. Tomemos como ejemplo el dado para un tipo llamado alumno, mencionado anteriormente:
tipo alumno real matricula caracter documento[8] caracter nombre[20] caracter domicilio[25] caracter fecha_nac[10] caracter e_mail[25] real promedio fintipo

Una vez que se declar al nuevo tipo de datos, ste se agrega a los ya conocidos tipos simples estndar, por lo que la declaracin de una variable (llammosla alum) de tipo alumno, se har:
variables alumno alu

Podemos ver a esta estructura de la siguiente forma:

alu

Cuando sea necesario hacer referencia a un componente (campo) de la estructura alumno en la variable alu es necesario nombrar a la variable, y para hacer referencia al campo se usa un punto y el nombre del campo. Por ejemplo, para asignar datos de un alumno a la estructura haremos:
alu.matricula 94879 alu.documento 12345678 alu.nombre Juan Gomez alu.domicilio 9 de Julio 1245 alu.fecha_nac 10/12/1940 alu.e_mail jgomez@servidor.com.ar alu.promedio 8,75

Una vez que los datos se han almacenado, podemos imaginar que esta estructura puede verse as:
alu 94879 12345678 Juan Gomez 9 de Julio 1245 10/12/1940 jgomez@servidor.com.ar 8,75

Donde toda la estructura se almacena bajo el nombre alu. Cuando se quiere utilizar uno de los componentes se deber hacer referencia al nombre de la variable (alu) y al del campo correspondiente, como cuando se almacenaron los datos. Esta estructura no es un arreglo. Finalmente, la fecha de nacimiento de los alumnos, tambin pueden considerarse como estructuras compuestas por da, mes y ao. En este caso, declararemos primero la estructura fecha y luego la utilizaremos en la declaracin de la estructura alumno:
tipo fecha entero dia entero mes entero ao fintipo tipo alumno real matricula caracter documento[8]

- 94 -

ALGORITMOS Y ESTRUCTURAS DE DATOS

caracter nombre[20] caracter domicilio[25] fecha fecha_nac caracter e_mail[25] real promedio fintipo

Obsrvese que es necesario declararlas en el orden indicado: primero el tipo fecha y luego el tipo alumno ya que la estructura fecha se utiliza en la estructura alumno.

8.3 TIPO ABSTRACTO DE DATOS

Una de las tareas de todo programador es la abstraccin de datos. Esto implica caracterizar objetos del mundo real de tal forma que puedan ser implementados en un programa. En la programacin estructurada, esta abstraccin se logra identificando atributos mensurables que pueden ser representados a travs de datos y atributos funcionales que caracterizan a su comportamiento. Un objeto del mundo real no puede ser representado por datos de tipo simple. Por ejemplo, el tipo alumno del ejemplo anterior requiere una estructura de datos. Pero la estructura declarada no es suficiente, tambin se debe programar las operaciones que un alumno real puede realizar, como ser matricularse, rendir exmenes, calcular su promedio. Es evidente que la estructura de datos y las operaciones programadas forman un conjunto. As, la representacin de un objeto del mundo real en un algoritmo requiere un tipo de datos definido por el programador ms la programacin de las operaciones que el objeto puede realizar. Este conjunto se denomina tipo abstracto de datos. Luego, un tipo abstracto de datos incluye: - La especificacin de la estructura de datos que representa a los elementos del tipo. - La especificacin de las operaciones permitidas sobre el tipo. - El tratamiento de ambos elementos como una unidad. Entonces, definimos tipo abstracto de datos como un conjunto conformado por un tipo de datos definido por el programador ms un conjunto de operaciones definidas sobre ese tipo que le otorgan una funcionalidad. Lo define el programador segn las necesidades del programa. No debe confundirse los conceptos de tipo de datos, tipo abstracto de datos y estructura de datos. Son tres conceptos distintos. Un tipo de datos es un conjunto de datos con caractersticas similares vinculados a un conjunto de operaciones para manipularlos que tienen una representacin interna en la mquina. Un tipo abstracto de datos es un modelo conceptual conformado por un tipo de datos definido por el programador ms un conjunto de operaciones definidas sobre ese tipo a travs de mdulos de cdigo. Una estructura de datos, es la implementacin fsica de un tipo abstracto de datos utilizando una coleccin de datos de tipo simple u otra estructura. Como puede deducirse, un tipo abstracto de datos constituye el resultado de una abstraccin del mundo real que debe implementarse con una estructura de datos. Puede decirse que es un concepto que debe ser implementado en su totalidad: los almacenes de datos y la funcionalidad requerida. Las pilas, colas, listas y los rboles constituyen tipos abstractos de datos que sern tratados a partir de este captulo. La mxima expresin de este concepto se encuentra en la programacin orientada a objetos. En ella los objetos del mundo real se modelan a travs de tipos abstractos de datos constituidos por atribu- 95 -

ALGORITMOS Y ESTRUCTURAS DE DATOS tos de los objetos reales (elementos de datos) y funciones que los manipulan (cdigo de control), encapsulados en unidades llamadas clases. Durante la ejecucin del programa, los objetos se generan dinmicamente en base a las clases.

8.4 PUNTEROS
Como los elementos de las estructuras dinmicas de datos no necesariamente se almacenan en forma contigua en la memoria, se necesita conocer su ubicacin. Esta ubicacin est dada por una direccin numrica especial en la memoria de la mquina. Las direcciones de memoria no estn constituidas por nmeros enteros ni reales, tienen un tratamiento especial (tema no contemplado en este material). Cada celda de memoria posee su propia direccin de memoria. As, almacenado un dato en la memoria, ste puede ser ubicado a travs de su direccin de memoria. De hecho, una variable es una representacin simblica de la ubicacin de memoria donde se guardan datos. La direccin de memoria a su vez, puede ser almacenada en una variable especial: un puntero. Un puntero es un tipo de variable, en la que se almacena la direccin de memoria de otra variable o el valor especial Null que indica que el puntero no tiene almacenado ninguna direccin vlida de memoria. Por ser una variable, debe ser declarado en el espacio de declaraciones de variables; pero a diferencia de stas, en su declaracin se antepondr una al nombre dado. Todo puntero contiene adems informacin sobre el tipo de datos al cual apunta, por lo tanto, se lo declara de un cierto tipo de datos. El puntero solo podr apuntar a datos del tipo indicado en su declaracin. La siguiente es una declaracin vlida para un puntero que apunta a datos de tipo entero: entero p Que indica la declaracin de un puntero de nombre p que podr apuntar a datos de tipo entero. Sin embargo, el puntero p no puede recibir datos, solo direcciones de memoria. Cmo se logra una direccin vlida de memoria para almacenar datos. Los lenguajes de programacin que soportan la asignacin dinmica de memoria proveen de una accin especfica para ello. En nuestro pseudocdigo, esta operacin se har con la palabra reservada nuevo, una funcin que requiere la indicacin del tipo de datos a almacenar y cuyo resultado es una direccin de memoria libre o el valor Null si no se encuentra: p nuevo(entero) El resultado de esta operacin es la asignacin al puntero p de una direccin de memoria libre en la que podr almacenarse nmeros enteros, o bien el valor Null que indica que no se encontr un espacio libre para datos. Grficamente, esta situacin se representa de la siguiente forma: p El esquema representa a un puntero p apuntando a un espacio de memoria asignado por la funcin nuevo en el que se podr almacenar los datos, estos ltimos deben ser del mismo tipo al indicado en la declaracin del puntero y en la solicitud de memoria (en el ejemplo el tipo es entero). Decimos que este espacio de memoria fue asignado dinmicamente durante la ejecucin del programa, mientras que el puntero ocupa un espacio esttico de memoria. Un puntero que no tiene asignado una direccin de memoria, no puede ser utilizado para almacenar datos.

- 96 -

ALGORITMOS Y ESTRUCTURAS DE DATOS

8.4.1

OPERACIONES CON PUNTEROS

Supongamos las siguientes declaraciones de punteros: entero p, q

Es vlida la operacin de solicitud de memoria para datos de tipo entero y asignar la direccin de memoria devuelta a uno de ellos: p nuevo(entero) a partir de esta operacin, es vlida la siguiente: q p sta indica que tambin el punteo q apuntar al espacio de memoria asignado en la operacin anterior, podemos graficarlo de la siguiente manera: p q Es vlido tener varios punteros sealando al mismo dato. Otra accin vlida es asignar el valor Null a un puntero, sin embargo ser necesario que otro puntero posea almacenada la direccin de memoria asignada dinmicamente, caso contrario el dato almacenado se perder: q Null el resultado de esta operacin lo podemos graficar de la siguiente manera: p q donde p apunta al espacio de memoria asignado dinmicamente, mientras q no posee una direccin vlida de memoria (representada con la en el puntero), es decir, su valor es Null. No debe asignarse a ambos punteros el valor Null, ya que en ese caso se perder el espacio de memoria asignado dinmicamente. Pero NO ser vlida la siguiente accin: p 4 Para almacenar un dato en el espacio de memoria asignado dinmicamente, se deber utilizar el operador de direccionamiento: . Luego, para asignar un valor a la celda de memoria apuntada por p se deber escribir la siguiente accin: p 4 esto dar el siguiente resultado: p Finalmente, el espacio asignado dinmicamente con la funcin nuevo deber ser liberado antes de la finalizacin de la ejecucin del programa. La funcin nuevo, es una interaccin entre el programa que realiza la solicitud de espacio de memoria y el sistema operativo. El espacio de memoria asignado dinmicamente queda indicado en tablas del sistema operativo como espacio de memoria ocupado, por lo que antes de finalizar la ejecucin del programa que realiz la solicitud, ste deber liberarlo, as el sistema operativo lo sealar en sus tablas como espacio libre. Si el programa finaliza y el espacio asignado dinmicamente no se libera, el sistema operativo lo seguir registrando como espacio ocupado aunque ningn programa lo est usando: el resultado es espacio de memoria que no se puede utilizar. Para liberar el espacio de memoria asignado dinmicamente utilizaremos la accin liberar(puntero), una interaccin entre el programa que utiliza la asignacin dinmica y el sistema - 97 -

ALGORITMOS Y ESTRUCTURAS DE DATOS operativo, para que este ltimo actualice sus tablas indicando que el espacio de memoria sealado por el puntero se encuentra ahora disponible. La accin liberar(puntero), asigna al puntero el valor Null y se escribe: liberar(p) Si bien el puntero asume el valor Null despus de liberarse el espacio de memoria asignado dinmicamente, el resultado obtenido no es el mismo que se obtiene asignando este valor al puntero. En el primer caso, se libera el espacio de memoria dinmico y se asigna el valor Null al puntero, en el segundo caso solo se asigna el valor Null al puntero, pero el espacio de memoria asignado dinmicamente no se ha liberado (se pierde su direccin de memoria). Con lo que se ha desarrollado hasta el momento sobre el uso de punteros y asignacin dinmica de memoria, puede observarse que no se obtienen ventajas respecto del uso de variables estticas, ya que adems del espacio asignado dinmicamente para el dato es necesario un espacio para el puntero. Si necesitramos almacenar diez datos, sera necesario declarar diez punteros, ya que cada puntero puede almacenar a lo sumo una direccin de memoria y no se estara haciendo uso eficiente de esta. Como el puntero solo puede apuntar a un dato, se necesita un mecanismo capaz de crearlos dinmicamente junto al espacio para almacenar datos. Esto significa que, al solicitar espacio de memoria para almacenar datos, tambin se debe solicitar espacio para un nuevo puntero. De esta forma siempre habr un puntero libre al cual se podr asignar otra direccin de memoria. De todas formas ser necesario declarar al menos un puntero en forma esttica al cual asignar la direccin de memoria del primer bloque. Esto lo podemos representar de la siguiente forma: p donde la parte en gris junto a los datos representa a un puntero. De esta forma es posible solicitar otro espacio de memoria similar y asignar su direccin a este puntero, representado de la siguiente forma: p El puntero p apunta a un espacio de memoria compuesto por datos y un puntero, este ltimo tambin apunta a otra estructura similar. El ltimo puntero posee el valor Null, aqu representado con la indicando el final de la estructura. Obsrvese que enlazando de esta forma estructuras compuestas por datos y punteros obtenidos dinmicamente, la nica limitacin es el total de espacio de memoria disponible (espacio libre de memoria). El ltimo esquema representa a la estructura lista enlazada simple, una de las estructuras dinmicas lineales que estudiaremos en este captulo.

8.4.2

NODO

Para la construccin de las estructuras dinmicas, durante la ejecucin del programa es necesario solicitar espacios de memoria para datos y punteros, y enlazarlos como en el esquema anterior. Cada componente de la estructura completa es, a su vez, una estructura compuesta por un espacio para datos y uno o ms punteros. A los elementos componentes de las estructuras dinmicas los llamamos nodos. Entonces, definimos nodo a cada elemento de una estructura dinmica que se construye en base a una estructura de registro formada por campos de datos y uno o ms punteros. Estos elementos se generan dinmicamente durante la ejecucin del programa. p
puntero nodo

Para su creacin, ser necesario declarar un nuevo tipo de datos: un registro formado por datos (de cualquiera de los tipos conocidos) y al menos un puntero a otro nodo. Supongamos que se necesita una estructura para almacenar datos de alumnos tal como se ejemplific antes en este captulo en el apartado registros. Al tipo alumno se deber agregar un puntero (de tipo alumno): - 98 -

ALGORITMOS Y ESTRUCTURAS DE DATOS

tipo fecha entero dia entero mes entero ao fintipo tipo alumno real matricula caracter documento[8] caracter nombre[20] caracter domicilio[25] fecha fecha_nac caracter e_mail[25] real promedio alumno sgte fintipo

Para almacenar datos de un alumno, se necesita un espacio de memoria de tipo alumno y para almacenar su direccin ser necesario un puntero (tambin de tipo alumno):
variables alumno alu

En el cuerpo principal del algoritmo, se solicita espacio de memoria para almacenar datos de un alumno. Si la solicitud de espacio de memoria no fall, ahora se puede almacenar datos en el nodo:
Inicio alu nuevo(alumno) si (alu <> Null) entonces leer(alumatricula) leer(aludocumento) leer(alunombre) leer(aludomicilio) leer(alufecha_nac.dia, alufecha_nac.mes, alufecha_nac.ao) leer(alue_mail) leer(alupromedio) alusgte Null finsi

liberar(alu) Fin

// contina el cdigo // esto cuando ya no se necesiten los datos del alumno y antes del fin // fin del algoritmo

Obsrvese la necesidad de utilizar el operador de direccionamiento , como tambin el . entre el nombre del campo fecha_nac y sus componentes da, mes y ao. Ahora poseemos los conocimientos necesarios de las herramientas bsicas para comenzar a estudiar las estructuras dinmicas lineales. En primer lugar, estudiaremos los TAD (tipos abstractos de datos) pila, cola y lista, para luego implementarlos con listas enlazadas simples.

8.4.3

COMPARACIONES ENTRE PUNTEROS

Supongamos las siguientes declaraciones de punteros: entero p, q

Es vlida la operacin de comparacin por igualdad (verifica si ambos punteros apuntan a la misma direccin de memoria) o por desigualdad (verifica si los punteros apuntan a distintas direcciones - 99 -

ALGORITMOS Y ESTRUCTURAS DE DATOS de memoria). Tambin es posible verificar si un puntero posee (o no) el valor Null. No es vlido otro tipo de comparacin (por ejemplo, no es vlido verificar si un puntero posee almacenado una direccin de memoria superior a otro, es decir, no es vlido la comparacin por mayor o menor). Entonces, solo son vlidas las siguientes comparaciones:
si (p = q) entonces // operaciones cuando p y q apuntan al mismo espacio de memoria finsi si (p <> q) entonces // operaciones cuando p y q no apuntan al mismo espacio de memoria finsi si (p = Null) entonces // operaciones cuando p no apunta a un espacio de memoria vlido

finsi

8.5 TAD PILA

La pila es una de las formas ms simples de organizar elementos en el mundo real. Por ejemplo, apilamos platos, libros, camisas. Constituye una superposicin de objetos en la que cada nuevo elemento se ubica sobre todos los anteriores y en todo momento es adems el primero que se puede recuperar. En la vida cotidiana decimos que el ltimo objeto que colocamos en la pila se encuentra en su tope, es el ltimo que se ubic all y el primero que retiramos. En informtica, este concepto se implementa a travs del TAD Pila y su aplicacin es muy amplia. Por ejemplo, en un programa los retornos desde los mdulos se realizan en el orden inverso al efectuado en los llamados, esto se logra apilando las direcciones de memoria de las lneas de cdigo que esperan continuar la ejecucin y desapilndolas cuando finaliza el mdulo (la implementacin de esta pila es tarea de los compiladores). Tambin el Sistema Operativo utiliza pilas durante la ejecucin de los programas. Si bien estos ejemplos no requieren la intervencin del programador, resultan tiles para resaltar su importancia. Definimos Tipo Abstracto de Datos Pila a una coleccin dinmica de elementos homogneos en la que el ltimo en entrar es el primero en salir. Por este motivo se las denomina LIFO, siglas en ingls de ltimo en entrar, primero en salir (Last In, First Out). Una pila es un TAD dinmico homogneo al que slo se tiene acceso al elemento que se encuentra en su tope. Sus operadores bsicos son apilar, desapilar y pila_vaca, aunque para este TAD, tambin se pueden definir otros operadores auxiliares. Las caractersticas del TAD Pila son: - Los elementos son del mismo tipo, esto la convierte en una estructura homognea. - Los elementos se recuperan en el orden inverso al que fueron almacenados. Por eso su forma de acceso se denomina LIFO (Last In, First Out). - La cantidad de elementos que contiene la pila puede variar a lo largo de la ejecucin del programa. Por esta razn, es una estructura dinmica. El TAD Pila puede ser implementado con arreglos o con listas enlazadas simples. En esta ctedra se utilizar la ltima opcin. Debido a esto, cada elemento que constituye la pila ser un nodo construido en base a una estructura de registro formada por datos (segn el caso particular del problema a resolver) y un puntero para enlazarlos.

- 100 -

ALGORITMOS Y ESTRUCTURAS DE DATOS

8.5.1

EL CONCEPTO PILA
Para comprender el concepto se utilizar un ejemplo.

Supongamos que es necesario apilar paquetes de arroz en un almacn. Como estos paquetes tienen formas irregulares, es conveniente colocarlos previamente en cajas y apilar estas ltimas. El procedimiento a seguir lo podemos sintetizar con los siguientes pasos: - Buscar una caja vaca. - Llenar la caja con paquetes de arroz. - Cerrar la caja. - Apilarla. Estos pasos se repiten hasta que no queden paquetes de arroz o no se consiga una caja vaca. Cuando se necesitan paquetes de arroz, los pasos a seguir son: - Bajar la caja que se encuentra en el tope de la pila. - Abrirla y tomar los paquetes de arroz - Descartar la caja. Anlogamente, en la programacin las cajas estn representadas por nodos vacos y los paquetes a introducir en ellas por datos. Luego, los pasos a seguir en el proceso de pilas sern: - Solicitar espacio de memoria para un nodo nuevo. - Cargar datos en el nodo. - Asignar el valor Null al puntero incluido en el nodo. - Apilar el nodo. Estas operaciones slo podrn llevarse a cabo si la primera accin no fall, es decir, si hay espacio libre de memoria para albergar un nodo nuevo. Cuando se necesite procesar los datos que se encuentran en la pila, los pasos sern: - Desapilar el nodo que se encuentra en el tope de la pila. - Procesar sus datos. - Liberar el espacio de memoria, o introducir el nodo en otra estructura. Estas operaciones se podrn realizar mientras haya nodos apilados, cuando ya no los haya, diremos que la pila est vaca. Algortmicamente podemos imaginarnos a este TAD de la siguiente forma:

En el esquema, se observa una pila cuyo tope est sealado por el puntero Tp, y un nodo que no pertenece a ninguna estructura apuntado por p. Este ltimo puede ser apilado.

8.5.2

CREACIN DE PILAS

Los lenguajes de programacin no disponen de un tipo de datos simple para implementar el concepto de Pilas. Esta es la razn por la que es necesario programar el TAD Pila para implementarlo. - 101 -

ALGORITMOS Y ESTRUCTURAS DE DATOS Como lo implementaremos utilizando listas enlazadas, la creacin de Pilas implica la declaracin de un tipo de datos para los nodos y la posterior programacin de las operaciones apilar, desapilar y pila_vacia. Podemos decir entonces que en la pila se estarn almacenando nodos de un tipo declarado para tal fin. En la seccin 8.4.2 vimos un ejemplo de la creacin de nodos. Estos nodos constituyen las estructuras de datos de los elementos del TAD. Junto a las operaciones propias de un TAD, permitirn la construccin de estructuras de datos que respondan al concepto del TAD particular.

8.5.3

OPERADORES DEL TAD PILA

Como se mencion, cada tipo abstracto de datos requiere la definicin de las operaciones permitidas con l, esto se refiere a la necesidad de escribir el cdigo para implementarlas. Para el TAD Pila son tres los operadores bsicos: apilar (colocar un nodo en el tope de la pila), desapilar (sacar el nodo del tope de la pila) y vaca (para verificar si existen nodos apilados).

LA OPERACIN APILAR
La operacin apilar coloca nodos en el tope de una pila. Para ello, es necesario pasarle la direccin de memoria del nodo a apilar y la direccin del tope de pila sobre la que se apilar el nodo mencionado. Tomando el esquema anterior, la operacin apilar ubicar el nodo sealado por el puntero p sobre el actual tope de la pila apuntada por Tp.

Situacin antes de apilar el nodo sealado por p en la pila apuntada por Tp

Como resultado, el nodo apuntado por p se almacena en la pila siendo su nuevo tope (apuntado por Tp) y el puntero p queda en Null:

Resultado despus de apilar el nodo sealado por p en la pila apuntada por Tp

Ahora la pila se compone de cuatro nodos, y el puntero p puede utilizarse para otra operacin, ya que se encuentra libre. Apilar, puede ser implementado como una funcin o como un procedimiento. Recordemos que las variables que sern modificadas dentro del mdulo deben ser pasadas por referencia. Como son dos los valores a modificar por la operacin (el puntero al nodo y el puntero al tope de la pila), conviene implementarlo como procedimiento pasando los punteros por referencia. La sintaxis de su encabezado ser: - 102 -

ALGORITMOS Y ESTRUCTURAS DE DATOS procedimiento apilar(tipoPila ref nodo, tipoPila ref tope) Por lo que el llamado a apilar el nodo apuntado por p deber realizarse de la siguiente forma: apilar(p, Tp) Si lo implementamos como funcin, su encabezado ser: tipoPila funcion apilar(tipoPila ref nodo, tipoPila tope) Y el llamado a apilar se har de la siguiente forma: Tp apilar(p, Tp) Volviendo al ejemplo de alumnos presentado anteriormente, supngase que es necesario apilar los nodos para su posterior procesamiento. El algoritmo requiere un puntero para el tope de la pila: llamemos a este punteo TpAlu. Asumiendo que se ha declarado el tipo alumno como se vio anteriormente, el cdigo para apilar un nodo con datos de un alumno en la pila apuntada por TpAlu ser:
variables alumno alu, TpAlu Inicio alu nuevo(alumno) si (alu <> Null) entonces leer(alumatricula) leer(aludocumento) leer(alunombre) leer(aludomicilio) leer(alufecha_nac.dia, alufecha_nac.mes, alufecha_nac.ao) leer(alue_mail) leer(alupromedio) apilar(alu, TpAlu) finsi

Fin

// contina el cdigo // fin del algoritmo

Antes del final de la ejecucin de este algoritmo, es necesario liberar cada uno de los nodos de la pila (no incluido en el ejemplo an).

LA OPERACIN DESAPILAR
La operacin desapilar toma el nodo del tope de la pila, se lo pasa a un puntero auxiliar (en los esquemas es el puntero p) y actualiza el puntero que apunta al tope de la pila (representado por Tp). Como resultado, el nodo que se encuentra en el tope de la pila antes de ejecutarse esta operacin, ya no pertenecer a ella; pero no ser eliminado de la memoria de la mquina, estar sealado por el puntero auxiliar. Para esta operacin, es necesario que el puntero auxiliar previamente se encuentre en Null, ya que tomar la direccin del nodo desapilado. Tomemos el siguiente esquema previo a desapilar:

Estado previo a la ejecucin de desapilar

- 103 -

ALGORITMOS Y ESTRUCTURAS DE DATOS Despus de desapilar, el resultado ser:

Estado posterior a la ejecucin de desapilar

Ahora la pila se compone de dos nodos, y el puntero p seala al nodo desapilado. Obsrvese que el puntero que enlazaba al nodo desapilado con el siguiente nodo de la pila (componente interno del nodo) ya no apunta a este, su valor fue reemplazado por Null. Esto tambin debe realizar la operacin desapilar. Tambin desapilar puede ser implementado como una funcin o como un procedimiento. Nuevamente, como son dos los valores a ser modificados por esta operacin (el puntero al nodo y el puntero al tope de la pila), conviene implementarlo como procedimiento pasando los punteros por referencia. La sintaxis de su encabezado ser: procedimiento desapilar(tipoPila ref nodo, tipoPila ref tope) Por lo que al realizar el llamado para desapilar un nodo ser: desapilar(p, Tp) Si lo implementamos como funcin, su encabezado ser: tipoPila funcion desapilar(tipoPila ref tope) Y el llamado a desapilar se har de la siguiente forma: p desapilar(Tp) Tomando nuevamente el ejemplo de alumnos, supngase que se debe procesar los datos de uno de ellos. Ahora ser necesario desapilar el nodo que se encuentra en el tope de la pila. Con las declaraciones ya vistas, la operacin ser:
Inicio

// cdigo de creacin de la pila, presentado anteriormente si (not vacia(TpAlu)) entonces desapilar(alu, TpAlu) procesar(alu) // aqu se debe hacer algo con el nodo desapilado finsi
Fin // el cdigo contina // fin del algoritmo

Antes del final de la ejecucin de este algoritmo, es necesario liberar cada uno de los nodos de la pila (no incluido en el ejemplo an). Obsrvese que la operacin desapilar est condicionada a que la pila no se encuentre vaca, este control lo realizamos con la operacin vacia que se tratar a continuacin. Con respecto al nodo desapilado, hay una observacin que se debe realizar: despus de - 104 -

ALGORITMOS Y ESTRUCTURAS DE DATOS procesar sus datos, o bien se lo libera o bien se lo coloca en otra estructura basada en el mismo tipo.

LA VERIFICACIN DE PILA VACA

Obsrvese que es imposible desapilar nodos cuando la pila se encuentra vaca, por lo tanto, antes de ejecutar el procedimiento desapilar es necesario verificar si hay nodos apilados. Esto lo realiza la funcin vacia. Vacia, es una funcin que requiere como parmetro de entrada la indicacin del tope de la pila que se desea verificar, y devuelve verdadero o falso segn se encuentre o no vaca. Luego, la sintaxis de su encabezado es: logico funcion vacia(tipoPila Tp) Volviendo al ejemplo de la pila de alumnos: Antes de finalizar la ejecucin del algoritmo que la cre, es necesario destruirla. Destruirla significa liberar todos los nodos que la componen (uno a uno). Esto lo hacemos con un bucle hasta que no queden nodos en la pila:
variables alumno alu, TpAlu Inicio // cdigo de creacin de la pila, presentado anteriormente // aqu representa al proceso de los datos mientras (not vacia(TpAlu)) entonces desapilar(alu, TpAlu) liberar(alu) finmientras

Fin

// el cdigo continua // fin del algoritmo

El cdigo contenido en el bucle mientras, desapila y libera todos los nodos que componen la pila hasta que no haya ms nodos en ella.

8.6 TAD COLA

La cola es otra forma de organizar elementos en el mundo real. Por ejemplo: para poder acceder a los servicios de un cajero, primero se debe esperar a que ste atienda a todas las personas que llegaron previamente, es necesario esperar para ser atendido. La cola est constituida por un conjunto de objetos en la que cada nuevo elemento se ubica al final de los anteriores (constituyndose en el ltimo) y en todo momento solo el primero puede ser atendido. De esta manera, los objetos que constituyen la cola se atienden en el mismo orden en que fueron llegando. Es particularmente til en informtica, y su ejemplo ms visible es la impresin de documentos. Cuando se envan varios documentos a imprimir, se crea una cola de espera para ser atendidos segn el orden de envo. Tambin los procesos durante su ejecucin deben respetar colas. Definimos Tipo Abstracto de Datos Cola a una coleccin dinmica de elementos homogneos en la que el primero en entrar es el primero en ser atendido. Por este motivo se las denomina FIFO, siglas en ingls de primero en entrar, primero en salir (First In, First Out). Una cola es un TAD dinmico homogneo al que slo se tiene acceso a un elemento: el que se encuentra al principio de ella. Sus operadores bsicos son encolar, desencolar y cola_vaca, aunque (al igual que en Pilas), para este TAD tambin se pueden definir otros operadores auxiliares. - 105 -

ALGORITMOS Y ESTRUCTURAS DE DATOS Las caractersticas del TAD Cola son: - Los elementos son del mismo tipo, esto la convierte en una estructura homognea. - Los elementos solo se pueden recuperan en el orden en que fueron almacenados. Por eso su forma de acceso se denomina FIFO (First In, First Out). - La cantidad de elementos que contiene la cola puede variar a lo largo de la ejecucin del programa. Por esta razn, es una estructura dinmica. El TAD Cola puede ser implementado con arreglos o con listas enlazadas simples. Al igual que para el TAD Pilas se utilizar la ltima opcin.

8.6.1

EL CONCEPTO DE COLA
Para comprender el concepto se utilizar un ejemplo.

Supongamos que estamos en un supermercado haciendo compras. Para pagarlas, debemos esperar en la cola a ser atendidos. Bsicamente los pasos son: - Ubicarnos al final de una cola de espera correspondiente a una caja. - Esperar hasta que se desocupe el cajero. - Acceder a la caja a pagar los productos. - Retirarnos. Llevando este ejemplo a la informtica, los productos comprados seran los datos a procesar, el canasto que los contiene sera el nodo, la cola de espera de personas con productos estara representada por otros nodos conteniendo datos y el paso por caja para pagar sera el proceso a efectuar. Los pasos a seguir en el proceso de encolar nodos sern: - Solicitar espacio de memoria para un nodo nuevo. - Cargar datos en el nodo. - Asignar el valor Null al puntero incluido en el nodo. - Encolar al nodo. Al igual que en pilas, estas operaciones slo podrn llevarse a cabo si la primera accin no fall, es decir, si hay espacio libre de memoria para albergar un nodo nuevo. Cuando se necesite procesar los datos que se encuentran en la cola, los pasos sern: - Desencolar el nodo que se encuentra en la salida de la cola (prximo a ser atendido). - Procesar sus datos. - Liberar el espacio de memoria, o introducir el nodo en otra estructura. Algortmicamente podemos imaginarnos a este TAD de la siguiente forma:

Tres nodos en una cola de espera

Donde el puntero E (entrada, final o ltimo nodo de la cola) seala al ltimo nodo ingresado en la cola, y el puntero S (salida, inicio o primer nodo de la cola) el prximo a ser atendido. Como puede observarse, el TAD Cola requiere dos punteros para su implementacin, y al igual que en el caso de las pilas, para los nuevos nodos ser necesario un puntero auxiliar.

8.6.2

CREACIN DE COLAS

Los lenguajes de programacin tampoco disponen de un tipo de datos simple para implementar Colas. Por esta razn es necesario programar el TAD Cola e implementarlo sobre estructuras conocidas. - 106 -

ALGORITMOS Y ESTRUCTURAS DE DATOS Como lo implementaremos utilizando listas enlazadas, la creacin de Colas implica la declaracin de un tipo de datos para los nodos y la posterior programacin de las operaciones encolar, desencolar y cola_vacia. Como ejemplo, consideremos la cola de una caja en un supermercado. Para representarla podramos crear una estructura de datos para los nodos compuesta por la cantidad y la descripcin de los artculos comprados y el importe total a obtener en el proceso (por el cual se espera). La estructura de los nodos sera:
tipo carrito entero cantidad caracter descripcion[100] real importe carrito sgte fintipo

Esto implica que tambin en las colas se almacenan nodos de un tipo declarado para tal fin. Esto se realiza con punteros que debern ser declarados en el espacio de declaracin de variables. A continuacin se presentan las operaciones propias del TAD Cola que permitirn la construccin de estructuras de datos que respondan al concepto cola.

8.6.3

OPERADORES DEL TAD COLA

Las operaciones bsicas permitidas sobre el TAD Cola son tres: encolar (colocar un nuevo nodo al final de la cola), desencolar (sacar el nodo del inicio de la cola) y vaca (para verificar si existen nodos en la cola).

LA OPERACIN ENCOLAR
La operacin encolar ubica nuevos nodos al final de la cola de espera. Para ello, es necesario pasarle la direccin de memoria del nodo a encolar (puntero al nuevo nodo) y las direcciones de entrada y salida de la cola (punteros de entrada y de salida). Tomando el esquema anterior con tres nodos en la cola de espera, la operacin encolar consiste en ubicar un nuevo nodo (aqu sealado por el puntero p) al final de la cola (apuntada por E).

Estado previo a encolar el nodo sealado por p al final de la cola sealada por E

Como resultado, el nodo apuntado por p se almacena al final de la cola (apuntado por E) y el puntero p queda en Null:

Estado de la cola despus de encolar el nodo

Despus de ejecutarse la operacin encolar, la cola se compone de cuatro nodos, y el puntero p puede utilizarse para otra operacin, ya que se encuentra libre. Una vez ms, esta operacin se puede implementar como funcin o como procedimiento. Implementada como procedimiento, la sintaxis de su encabezado ser: procedimiento encolar(tipoCola ref nodo, tipoCola ref entrada, tipoCola ref salida) - 107 -

ALGORITMOS Y ESTRUCTURAS DE DATOS Por lo que el llamado a encolar el nodo apuntado por p a la entrada de la cola apuntada por E deber realizarse de la siguiente forma: encolar(p, E, S) Si lo implementamos como funcin, su encabezado ser: tipoCola funcion encolar(tipoCola ref nodo, tipoCola ref entrada, tipoCola salida) Y en este caso el llamado a encolar se har de la siguiente forma: E encolar(p, E, S) Siguiendo con el ejemplo de la cola de espera de la caja del supermercado, para encolar los carritos necesitaremos al menos tres punteros: uno para representar carritos nuevos (nodos nuevos): crr y dos para la propia cola: Entrada y Salida. El cdigo para encolar un nodo con datos de los artculos contenidos en un carrito ser:
variables carrito crr, Entrada, Salida Inicio

// lneas de cdigo previas a la creacin de un nodo

crr nuevo(carrito) si (crr <> Null) entonces leer(crrcantidad) leer(crrdescripcion) crrimporte 0

// el importe se obtiene cuando se atiende al carrito

encolar(crr, Entrada, Salida) finsi // contina el cdigo Fin // fin del algoritmo

LA OPERACIN DESENCOLAR
La operacin desencolar consiste en tomar el nodo que se encuentra a la salida de la cola (en el ejemplo sealado por el puntero de salida S), asignar su direccin a un puntero auxiliar que debe estar en Null (en el ejemplo es p) y eliminar el enlace entre este nodo y la cola. Internamente, ser necesario trabajar con los punteros de entrada y salida de la cola, todos parmetros necesarios en esta operacin. Tomando el esquema de tres nodos presentado anteriormente, el nico nodo que puede salir de la cola es el que se encuentra sealado por S:

Estado previo a desencolar el nodo sealado por S (inicio de la cola)

Como resultado de desencolar, el nodo que se encontraba apuntado por S estar sealado por el puntero auxiliar p:

Estado de la cola despus de desencolar el nodo

- 108 -

ALGORITMOS Y ESTRUCTURAS DE DATOS Despus de ejecutar la operacin desencolar, la cola se compone solo de dos nodos, y el puntero p seala al nodo desencolado. Una vez ms, esta operacin se puede implementar como funcin o como procedimiento. Implementada como procedimiento, la sintaxis de su encabezado ser: procedimiento desencolar(tipoCola ref nodo, tipoCola ref entrada, tipoCola ref salida) Por lo que el llamado a desencolar el nodo de la salida se deber realizar de la siguiente forma: desencolar(p, E, S) Si lo implementamos como funcin, su encabezado ser: tipoCola funcion desencolar(tipoCola ref entrada, tipoCola ref salida) Y en este caso el llamado a desencolar se har de la siguiente forma: p desencolar(E, S) Para desencolar un nodo de la cola de espera del ejemplo (la cola de la caja del supermercado) una opcin es:
variables carrito crr, Entrada, Salida Inicio

// cdigo de creacin de la cola, presentado anteriormente

si (not vacia(Salida)) entonces desencolar(crr, Salida, Entrada) procesar(crr)

finsi

// aqu se debe hacer algo con el nodo desencolar (podra ser liberarlo) // el cdigo continua // fin del algoritmo

Fin

En este ejemplo, procesar(crr) podra ser asignarle un importe a los artculos comprados (almacenados en el nodo) y acumular ese importe al total que la cajera deber rendir al final de su turno. Una vez que se realiz el proceso de los datos, el nodo podr ser liberado o bien se lo deber ubicar en otra estructura.

LA VERIFICACIN DE COLA VACA

Evidentemente es imposible desencolar nodos cuando la cola est vaca; por lo tanto, antes de ejecutar el procedimiento desencolar es necesario verificar si hay nodos en ella. Esto lo realiza la funcin vacia. Vacia, es una funcin que requiere como parmetro de entrada el puntero de salida de la cola que se desea verificar, y devuelve verdadero o falso segn esta se encuentre o no vaca. Luego, la sintaxis de su encabezado es: logico funcion vacia(tipoCola salida) Volviendo al ejemplo de la cola de carritos del supermercado: Antes de finalizar la ejecucin del algoritmo que la cre, es necesario procesar todos sus nodos y destruirla. Destruirla significa liberar todos sus nodos (uno a uno) hasta que quede vacia: - 109 -

ALGORITMOS Y ESTRUCTURAS DE DATOS

variables carrito crr, Entrada, Salida Inicio // cdigo de creacin de la pila, presentado anteriormente // otras lneas de cdigo previas a la destruccin de la cola mientras (not vacia(Salida)) entonces desencolar(crr, Salida, Entrada) procesar(crr) liberar(crr) finmientras // el cdigo continua Fin // fin del algoritmo

El cdigo contenido en el bucle mientras, desencola, procesa y libera todos los nodos que componen la cola hasta que no haya ms nodos en ella antes de finalizar la ejecucin del programa.

8.7 TAD LISTA

La lista es otro TAD lineal. Se deriva del concepto de listas del mundo real, como por ejemplo una lista de alumnos. Se constituye de un conjunto de objetos vinculados de tal forma que cada uno posee un predecesor (excepto el primero) y un sucesor (excepto el ltimo). Considerando las operaciones que se pueden realizar sobre este TAD, resulta ser el ms verstil de los TAD lineales. Definimos Tipo Abstracto de Datos Lista a una coleccin dinmica de elementos homogneos con un orden lgico en ella, tal que cada elemento tiene un nico predecesor (excepto el primero) y un nico sucesor (excepto el ltimo). En informtica, este TAD se implementa a travs de la estructura dinmica lista enlazada, que se tratar ms adelante en este captulo. Las caractersticas del TAD Lista son: - Los elementos son del mismo tipo, esto la convierte en una estructura homognea. - Los elementos se recuperan a partir de uno que constituye el inicio de la lista. - La cantidad de elementos que contiene la lista puede variar a lo largo de la ejecucin del programa. Por esta razn, es una estructura dinmica. - Es de acceso secuencial, es decir, para acceder a un elemento es necesario acceder a todos los elementos previos. Las operaciones tpicas del TAD Lista son insertar un nuevo nodo, recorrer la lista para procesar sus datos, buscar un nodo que cumpla con un criterio dado, borrar un nodo de la lista y borrar la lista completamente; pero tambin se pueden definir otras operaciones adicionales de acuerdo a las necesidades del caso donde se la utiliza. Como el TAD Lista se implementa con listas enlazadas, sus operaciones sern desarrolladas conjuntamente con la estructura lista enlazada simple.

8.8 LISTAS ENLAZADAS

Las listas enlazadas son estructuras de datos dinmicas que se constituyen con nodos. Recordemos que un nodo es una estructura generada dinmicamente en base a un tipo registro definido por el programador que se constituye con dos o ms campos: un puntero de enlace y uno o ms campos de - 110 -

ALGORITMOS Y ESTRUCTURAS DE DATOS datos. La estructura del registro se crea para representar a un objeto del mundo real de acuerdo a la abstraccin que de ste se realice. Definimos entonces: Una Lista Enlazada es una estructura de datos dinmica lineal formada por un conjunto de elementos homogneos denominados nodos, donde estos no necesariamente ocupan posiciones contiguas en memoria, pero mantienen un orden lgico entre ellos. Cada elemento de la estructura posee un nico predecesor (excepto el primero) y un nico sucesor (excepto el ltimo). Decimos que el orden de los elementos que constituyen la lista (los nodos) es lgico puesto que est sealado por punteros que los enlazan. Al no ocupar necesariamente ubicaciones contiguas en memoria (es decir, sus componentes pueden aparecer fsicamente dispersos en la memoria), se necesita el uso de punteros para mantener la estructura. Posee las mismas caractersticas del TAD Lista, del cual deriva. Existen distintas implementaciones para esta estructura, la ms utilizada es la lista enlazada simple. Otras implementaciones son la lista doblemente enlazada, la lista circular y la lista circular doblemente enlazada. Como se ver ms adelante, los TAD Pilas y Colas se pueden implementar utilizando listas enlazadas simples, con restricciones en cuanto a las operaciones permitidas (solo se permiten las operaciones propias de cada TAD).

8.8.1

LISTAS ENLAZADAS SIMPLES

Las listas enlazadas simples constituyen un caso particular de listas enlazadas, donde cada nodo posee un nico puntero de enlace: un puntero al nodo sucesor. Definimos lista enlazada simple a una coleccin de nodos con un orden lgico dado por la posicin dentro de la estructura, tal que a cada uno de ellos se accede mediante el puntero de enlace del nodo anterior. Este concepto la hace una estructura de acceso secuencial unidireccional (solo se puede recorrer en un sentido, el indicado por los punteros de enlace). Como cada nodo posee un puntero al nodo siguiente, podemos graficar a esta estructura de la siguiente manera:

Una lista de datos con cuatro nodos

Donde el puntero L siempre debe estar indicando al primer nodo, y el sentido de recorrido est dado por los punteros. El ltimo nodo de la estructura almacena el valor Null en su puntero de enlace al nodo siguiente puesto que no lo posee, este valor Null indica adems el final de la lista. Para ejecutar las distintas operaciones sobre esta estructura, ser necesario utilizar punteros auxiliares.

8.8.2

IMPLEMENTACIN DEL TAD LISTA

Para la implementacin del TAD Lista utilizaremos listas enlazadas simples.

Como todo TAD, el TAD Lista requiere la especificacin de tipo de datos que represente a los elementos de datos que constituirn la lista. Esto nos lleva nuevamente a la creacin de un tipo de datos registro definido por el programador.

8.8.2.1 ESPECIFICACIN DE LOS DATOS

Tomemos como ejemplo simplemente una lista de nmeros (los algoritmos no difieren si se trata de otro objeto, como puede ser una lista de alumnos). Para crear una lista, es necesario crear una estructura de datos para los nodos: - 111 -

ALGORITMOS Y ESTRUCTURAS DE DATOS

tipo numeros entero numero numeros sgte fintipo

Creadas las estructuras de datos para representar a los nmeros, a continuacin se crean las variables necesarias para la construccin y mantenimiento de la estructura de la lista de nmeros:
variables numeros num, aux, ant, L

Donde num ser utilizado como un puntero auxiliar para sealar nodos en la lista y L ser el puntero a su nodo inicial. Tanto aux como ant sern utilizados como auxiliares en los procesos. A continuacin se debern implementar los mdulos correspondientes a las operaciones propias del TAD Lista: insertar un nuevo nodo, recorrer la lista para procesar sus datos, buscar un nodo que cumpla con un criterio dado, borrar un nodo de la lista y borrar la lista completa.

8.8.2.2 DESARROLLO DE OPERADORES

Cabe aclarar una vez ms que los operadores que se desarrollarn a continuacin, no son los nicos que se pueden definir sobre el TAD Lista, como tampoco es nica su implementacin. En cada caso se desarrollar un solo algoritmo. Recuerde que todos los operadores se pueden implementar como procedimiento o como funcin segn resulte ms conveniente. Comenzaremos con el proceso de recorrido (acceder sucesivamente a todos los nodos de la lista para procesar sus datos).

LA OPERACIN RECORRER
Es la operacin ms simple sobre listas. Consiste en utilizar un puntero auxiliar que comienza apuntando al nodo cabecera de la lista y desde all, acceder secuencialmente a todos los dems para procesar los datos. Lo desarrollaremos como un procedimiento (tambin puede ser implementado como una funcin). El encabezado del procedimiento es:
procedimiento recorrer(tipoLista inicio)

El procedimiento recorrer necesita como parmetro la direccin del nodo cabecera (segn el algoritmo particular, pudiera requerir otros parmetros). Si se implementa como funcin, el valor de retorno depender de cada situacin particular.
tipoDato funcion recorrer(tipoLista inicio)

Para el ejemplo planteado e implementndola como procedimiento tenemos:

variables numeros num, L Inicio

recorrer(L)

Fin

// acciones previas a la insercin de nuevo nodo // llamado al procedimiento de recorrido // contina el cdigo // fin del algoritmo principal

procedimiento recorrer (numeros rc) inicio mientras (rc <> Null) procesar (rc) rc rcsgte // ac se procesa el nodo (o se llama a un procedimiento) // y se avanza al siguiente nodo

- 112 -

ALGORITMOS Y ESTRUCTURAS DE DATOS

finmientras finprocedimiento

El procedimiento recorrer necesita como parmetro la direccin del nodo cabecera. Desde l, se procesa los datos del nodo y se avanza al siguiente hasta acceder a todos los que componen la lista.

LA OPERACIN BUSCAR
El nico mtodo de bsqueda sobre listas la bsqueda lineal. No se puede realizar bsqueda binario puesto que para aplicar este mtodo se necesita un medio de almacenamiento con direccionamiento directo a sus elementos. Con arreglos se tiene acceso a cualquier celda a travs del ndice. Sobre listas no se puede hallar el nodo central sin recorrer toda la estructura. Buscar podr ser implementado en una funcin o en un procedimiento segn convenga.
variables numeros num, L entero n Inicio

leer (n) buscar(n, L)

Fin

// // // //

acciones previas a la insercin de nuevo nodo se lee el dato a buscar llamado al procedimiento de bsqueda contina el cdigo

// fin del algoritmo principal

procedimiento buscar (entero dato, numeros rc) inicio mientras (rc <> Null) si (rcnumero = dato) procesar (rc) rc Null sino rc rcsgte finsi finmientras finprocedimiento entonces // ac se procesa el nodo o se llama a un procedimiento // se proces el nodo buscado, se puede salir del bucle // no es el nodo buscado, se avanza al siguiente

Como parmetros, buscar necesita el dato a buscar y la direccin de inicio de la lista.

LA OPERACIN INSERTAR
Insertar se implementar asumiendo que previamente se ha creado el nodo y almacenado datos en l. La operacin insertar tan solo har que este pase a pertenecer a la estructura. La sintaxis de su encabezado si se la implementa como un procedimiento ser:
procedimiento insertar(tipoLista ref nodo, tipoLista ref inicio)

Por lo que en el ejemplo, el llamado a insertar el nodo apuntado por num deber realizarse de la siguiente forma: insertar(num, L) Si lo implementamos como funcin, su encabezado ser:
tipoLista funcion insertar(tipoLista ref nodo, tipoLista inicio)

Y el llamado a insertar utilizando las variables del ejemplo de nmeros se har de la siguiente forma: - 113 -

ALGORITMOS Y ESTRUCTURAS DE DATOS L insertar(num, L) Para implementar la operacin, asumamos que la lista de nmeros debe estar ordenada ascendentemente por nmero. El mtodo de ordenamiento que se aplica sobre listas enlazadas es el ordenamiento por insercin directa. Esto significa que la lista ha de construirse ordenadamente (no ordenarla posteriormente), por lo que antes de insertar un nuevo nodo se deber realizar una bsqueda para hallar su ubicacin. Para esto es necesaria una funcin de bsqueda auxiliar que devuelva la direccin del nodo detrs del cual se deber insertar el nuevo (su anterior): buscarAnterior. Esto es necesario puesto que el puntero sgte de este nodo deber apuntar al nuevo. Veamos la siguiente situacin:

Nuevo nodo a insertar en la lista

Para poder insertar el nodo conteniendo el 12, es necesario posicionar un punteo sobre el nodo que posee el 10 (ser el anterior del nuevo nodo), ya que su puntero siguiente deber sealar al nuevo nodo (usaremos el puntero local auxiliar ant). Para la insercin, se deber reemplazar el valor Null del puntero siguiente del nuevo nodo por la direccin del nodo que almacena el 15 y en el siguiente del anterior la direccin del nuevo nodo. Esto lo podemos ver en el siguiente grfico, representado por punteros graficados en lneas punteadas.

Punteros a modificar para insertar el nuevo nodo en la lista

Luego, el procedimiento inserta necesita la direccin del nodo detrs del que se deber insertar el nuevo. Esta direccin se obtiene con la funcin buscarAterior. Asumiendo que se declararon los punteros como se vio en el pargrafo anterior,
Inicio

num nuevo(numeros) si (num <> Null) entonces leer(numnumero) numsgte Null insertar(num, L) finsi

// acciones previas a la insercin de nuevo nodo

Fin //

// contina el cdigo // fin del algoritmo principal En el procedimiento, L estar representado por ini y num por nv.

- 114 -

ALGORITMOS Y ESTRUCTURAS DE DATOS

procedimiento insertar(numeros ref nv, numeros ref ini) numeros ant inicio ant buscarAnterior(nvnumero, ini) si (ant <> Null) entonces nvsgte antsgte antsgte nv sino nvsgte ini ini nv finsi nv Null finprocedimiento numeros funcion buscarAnterior (entero dato, numeros rc) numeros ant inicio ant Null mientras (rc <> Null) si (rcnumero > dato) entonces rc Null // encontr la ubicacin, se puede salir del bucle sino ant rc // se guarda la direccin del nodo actual rc rcsgte // y se verifica el siguiente finsi finmientras retornar(ant) finfuncion // se retorna la direccin del nodo anterior // // // // // el sgte del nuevo apunta al nodo del 12 el sgte del anterior apunta al nuevo nodo no hay anterior, se inserta nueva cabecera el sgte del nuevo apunta a la cabecera el nuevo nodo es la nueva cabecera de la lista

// hacemos que el puntero de nuevos nodos sea Null

La funcin buscarAnterior recibe como parmetros el nmero contenido en el nodo a insertar y la direccin del nodo cabecera. Realiza un recorrido sobre la lista con el puntero rc buscando la ubicacin donde se debe insertar el nuevo nodo, cuando la encuentra retorna la direccin del nodo anterior (almacenada en el puntero ant). Obsrvese las diferencias entre esta bsqueda y la presentada anteriormente: en esta, interesa la direccin del nodo anterior, en la que se present anteriormente interesaba hallar el nodo que contiene los datos a procesar. Despus de ejecutar el procedimiento insertar, el resultado es el siguiente:

Resultado de insertar el nuevo nodo en la lista

LA OPERACIN BORRAR NODO

Antes de eliminar un nodo de la lista es necesario redireccionar los punteros que la mantienen unida de forma tal que los dems nodos puedan ser recorridos. Si no se redireccionan correctamente estos punteros se pierde parte de la lista (situacin no deseada). - 115 -

ALGORITMOS Y ESTRUCTURAS DE DATOS Tomemos como ejemplo la siguiente lista ordenada de datos y digamos que se necesita buscar y sacar de ella el nodo que contiene el 15:

Lista que tomaremos como ejemplo

Para sacar este nodo de la lista tambin ser necesario trabajar con su anterior, puesto que se deber redireccionar el puntero siguiente de este nodo al siguiente del que se borrar. Una vez que se hizo esto, el nodo a borrar queda fuera de la lista y el espacio de memoria que ocupa puede ser liberado (o se lo puede insertar en otra estructura). De hecho, borrar un nodo de la lista implica previamente sacarlo de ella. Luego, nuevamente necesitamos un proceso auxiliar buscarAnterior, pero hay diferencias respecto de la funcin que se present anteriormente: en este caso se debe buscar el dato por igualdad y retornar dos direcciones: la direccin de su nodo anterior (o Null si es el nodo a borrar es el primero de la lista) y la direccin del nodo a borrar (o Null si no se encuentra). Obsrvese que son tres las situaciones que se pueden presentar: 1- el nodo buscado no se encuentra en la lista (nada para borrar), 2- el nodo buscado para borrar es el primero: se debe actualizar el puntero de inicio a la lista (no existe un anterior), 3- se est por borrar cualquier otro nodo (se debe actualizar el puntero siguiente del nodo anterior al que se borrar). Como hay dos valores de retorno, la bsqueda para borrar el nodo se implementar como un procedimiento al cual se pasan parmetros por referencia (los punteros ant que seala al nodo anterior y bor puntero que seala el nodo a borrar), adems del dato a buscar en la lista. Al iniciar el proceso de bsqueda del nodo a borrar y su anterior, el puntero que sealar al nodo a borrar (puntero bor) se debe posicionar apuntando al primer nodo y el que sealar al anterior (puntero ant) en Null:

Estado inicial del proceso de bsqueda

Despus de la bsqueda, la situacin es la siguiente: el puntero bor seala el nodo a borrar, y el puntero ant al anterior.

Punteros sealando los nodos que intervienen en el borrado

Se observa en el grfico un lazo desde el nodo apuntado por ant al siguiente del nodo que se ha de borrar. Este lazo se logra con la operacin antsgte borsgte
variables numeros num, L entero n

- 116 -

ALGORITMOS Y ESTRUCTURAS DE DATOS

Inicio

leer (n) borrarNodo(n, L)

Fin

// // // // //

acciones previas al llamado a borrar se lee el dato a buscar en el nodo llamado al procedimiento de borrar el nodo con el dato n contina el cdigo fin del algoritmo principal

procedimiento borrarNodo(entero num, numeros ref ini) numeros ant, bor inicio bor ini buscarAnterior(num, bor, ant) si (bor <> Null) entonces si (ant = Null) entonces // el nodo a borrar no tiene anterior: es el primero ini inisgte // se borra primer nodo, hay una nueva cabecera borsgte Null // el nodo a borrar no pertenece ms a la lista sino // el nodo a borrar est entre otros nodos. antsgte borsgte // el sgte del anterior, pasa a ser el sgte del nodo a borrar borsgte Null // el nodo a borrar no pertenece ms a la lista finsi sino // no se encontr el nodo buscado (bor = Null) Escribir (El dato (nodo) buscado no est en la lista) finsi liberar(bor) finprocedimiento procedimiento buscarBorrar (entero dato, numeros ref rc, numeros ref ant) logico encontrado // variable lgica que se utilizar para salir del bucle inicio ant Null encontrado falso mientras ((rc <> Null) and (not encontrado)) si (rcnumero = dato) entonces encontrado verdadero // encontr el nodo, se puede salir del bucle sino ant rc // se guarda la direccin del nodo actual rc rcsgte // y se avanza al siguiente finsi finmientras // se sale del procedimiento: si el dato est, entonces rc indica su direccin // si no se encontr, rc y ant son Null finprocedimiento // liberamos el espacio de memoria del nodo // punteros locales

El nuevo lazo entre el nodo que contiene al 10 y el nodo que contiene al 20, es necesario para no perder parte de la estructura.

- 117 -

ALGORITMOS Y ESTRUCTURAS DE DATOS

LA OPERACIN BORRAR LA LISTA

Esta es una operacin que se debe ejecutar antes de finalizar la ejecucin del algoritmo. Consiste en eliminar toda la lista, es decir, todos sus nodos. Despus de ejecutar esta operacin, el puntero de inicio a la lista (puntero L) estar en Null, por lo que no podr realizarse ninguna operacin con l, excepto crearla nuevamente. El algoritmo ms simple para esta operacin es utilizar un puntero auxiliar que seale al primer nodo de la lista, hacer que el puntero al inicio seale el siguiente y poner el valor Null en el siguiente del sealado por el auxiliar:

Puntero auxiliar sealando el nodo a borrar

A continuacin se libera el espacio de memoria del nodo apuntado por el auxiliar. Estas operaciones se repetirn hasta que no haya nodos. Se implementar con una funcin a la que se pasa la direccin del primer nodo y se retorna el valor Null para almacenar en el puntero al inicio de la lista (puntero L), sealando que la lista est vaca.
variables numeros num, L Inicio

L borrarLista(L)

Fin

// // // //

acciones previas a la insercin de nuevo nodo llamado a la funcin para borrar la lista contina el cdigo fin del algoritmo principal

numeros funcion borrarLista (numeros ini) numeros aux, bor inicio mientras (ini <> Null) aux ini // ini inisgte // auxsgte Null // liberar (aux) // finmientras retornar(Null) finfuncion el puntero auxiliar seala el primer nodo el puntero de inicio pasa al siguiente nodo se desenlaza el primer nodo de la lista se libera el espacio de memoria ocupado por el nodo // punteros auxiliar

Existen otras operaciones sobre listas, como ser combinar dos listas, localizar ltimo nodo, etc.

8.8.3

IMPLEMENTACIN DEL TAD PILA

La implementacin de la pila utilizando listas enlazadas simples, requerir definir un formato para los nodos, es decir, definir un tipo registro compuesto por los datos a procesar y un puntero. Luego ser necesario declarar al menos dos punteros: uno para la manipulacin de nodos no apilados (que no forman parte de la pila) y el otro para indicar, en todo momento, el tope de la pila. Como ya se sabe, para la implementacin de las estructuras que responden a un Tipo Abstracto - 118 -

ALGORITMOS Y ESTRUCTURAS DE DATOS de Datos, se necesita crear una estructura para los nodos. Este tema ya fue tratado con anterioridad, cuando se desarroll el TAD Pilas. Solo resta la implementacin de las operaciones apilar, desapilar y vaca presentadas en su momento.

8.8.3.1 DESARROLLO DE OPERADORES

Como se vio anteriormente, son tres los operadores bsicos para la implementacin de Pilas:

LA OPERACIN APILAR
Como la implementacin de pilas se hace a travs de listas enlazadas simples, la operacin apilar consiste en un caso especial de insercin: el nuevo nodo siempre se inserta al inicio de la lista. De acuerdo a lo desarrollado anteriormente, apilar se implementar en un procedimiento cuyo encabezado es: procedimiento apilar(tipoPila ref nodo, tipoPila ref tope) En su desarrollo, simplemente se deber hacer que el puntero siguiente del nuevo nodo (el puntero al nodo nuevo es nv) seale al tope de la pila, que este nuevo nodo pase a ser el tope y finalmente asignar el valor Null al puntero del nuevo nodo:
procedimiento apilar(tipoPila ref nv, tipoPila ref tope) inicio nvsgte tope tope nv nv Null finprocedimiento // el nuevo nodo apunta al actual tope de la pila // el nuevo nodo pasa a ser el tope de la pila // el nuevo nodo ya no est sealado por el puntero auxiliar

LA OPERACIN DESAPILAR
La operacin desapilar consiste en sacar nicamente el nodo que se encuentra en la cabecera de la lista y sin liberar el espacio de memoria que este ocupa. De acuerdo a lo desarrollado anteriormente, se implementar el procedimiento desapilar, cuyo encabezado es: procedimiento desapilar(tipoPila ref nodo, tipoPila ref tope) Para su desarrollo, simplemente se deber hacer que el puntero auxiliar (en el desarrollo llamado ds) seale al tope de la pila, el tope apuntar al siguiente y finalmente asignar el valor Null al puntero siguiente del nodo desapilado (sealado por el puntero auxiliar ds):
procedimiento desapilar(tipoPila ref ds, tipoPila ref tope) inicio ds tope tope topesgte dssgte Null finprocedimiento // el puntero auxiliar seala al tope de la pila // el tope de la pila pasa a ser el siguiente nodo // el nodo desapilado no tiene siguiente

Observe que no es necesario verificar dentro del procedimiento si existen nodos apilados antes de desapilar, puesto que, como se vio anteriormente en el desarrollo del TAD Cola, esto se realiza antes del llamado a la funcin.

LA VERIFICACIN DE PILA VACIA

La operacin vacia consiste en verificar el tope de la pila (puntero a la cabecera de la lista). Si - 119 -

ALGORITMOS Y ESTRUCTURAS DE DATOS este puntero es Null (pila vaca) se devuelve verdadero; si apunta a un nodo (pila no vaca), se devuelve falso. Su encabezado es: logico funcion vacia(tipoPila Tp) Para el desarrollo de esta funcin se necesita una variable auxiliar de tipo lgica. Como esta funcin no modifica valores, el parmetro no se pasa por referencia:

logico funcion vacia(tipoPila Tp) logico vac // variable auxiliar que indicar si est o no vaca
inicio si (Tp = Null) entonces vac Verdadero // la pila est vaca: se devolver verdadero sino vac Falso // la pila no est vaca: se devolver falso finsi retornar(vac) finfuncion

8.8.4

IMPLEMENTACIN DEL TAD COLA

La implementacin de colas utilizando listas enlazadas simples tambin requiere definir un formato para los nodos, es decir, definir un tipo registro compuesto por los datos a procesar ms un puntero. Considerando que este tema ya fue desarrollado con anterioridad, simplemente se desarrollarn los algoritmos que implementan las operaciones encolar, desencolar y vaca. Recordemos que una cola necesita dos punteros: uno de entrada (ltimo nodo encolado) y uno a la salida (primer nodo de la cola). Los llamaremos E y S respectivamente.

8.8.4.1 DESARROLLO DE OPERADORES

Son tres los operadores bsicos para el procesamiento de colas:

LA OPERACIN ENCOLAR
La operacin encolar consiste en ubicar nuevos nodos al final de la cola de espera. Para ello, es necesario pasarle la direccin de memoria del nodo a encolar (puntero al nuevo nodo) y las direcciones de entrada y salida de la cola (punteros de entrada y de salida). Implementada como procedimiento, su encabezado es: procedimiento encolar(tipoCola ref nodo, tipoCola ref entrada, tipoCola ref salida) En el desarrollo del procedimiento encolar se deber hacer que el puntero siguiente del ltimo nodo de la cola apunte al nuevo nodo, que ste sea sealado como ltimo nodo y que el puntero al nuevo nodo sea Null. Como caso especial, cuando la cola est vaca tanto el puntero de entrada como el de salida deben sealar al nodo a encolar (por este motivo es necesario que el procedimiento reciba ambos punteros por referencia):

- 120 -

ALGORITMOS Y ESTRUCTURAS DE DATOS procedimiento encolar(tipoCola ref nv, tipoCola ref E, tipoCola ref S)
inicio si (E = Null) entonces S nv sino Esgte nv finsi E nv nv Null finprocedimiento // la cola est vaca, se inserta el primer nodo // el puntero de salida seala al nico nodo encolado // el nuevo nodo se ubica detrs del ltimo nodo de la cola // el nuevo nodo encolado pasa a ser el ltimo de la cola // el nodo pertenece a la cola, ya no est sealado por el // puntero auxiliar

LA OPERACIN DESENCOLAR
La operacin desencolar posee similitudes con desapilar: consiste en sacar nicamente el nodo que se encuentra en la cabecera de la lista sin liberar el espacio de memoria que este ocupa. Sin embargo, existe un caso especial no presente en Pilas: cuando la cola posee un nico nodo ste a su vez es tambin el ltimo; al desencolarlo, tambin se debe poner el valor Null en el puntero de entrada, no solamente en el puntero de salida. Por esta razn, se necesita pasar ambos punteros por referencia. De acuerdo a lo desarrollado anteriormente, desencolar se implementar como un procedimiento, cuyo encabezado es: procedimiento desencolar(tipoCola ref nodo, tipoCola ref entrada, tipoCola ref salida) Para su desarrollo, se deber hacer que el puntero auxiliar (en el desarrollo llamado ds) seale al primer nodo de la cola, el puntero de entrada seale al siguiente y asignar el valor Null al puntero siguiente del nodo desencolado (sealado por el puntero auxiliar ds). En el caso especial en que la cola posee un nico nodo, al desencolarlo tambin se asignar el valor Null al puntero de entrada (por esta razn es necesario pasar tanto el puntero de entrada como el de salida por referencia). procedimiento desencolar(tipoCola ref ds, tipoCola ref E, tipoCola ref S)
inicio ds S S Ssgte dssgte Null si (S = Null) entonces E Null finsi finprocedimiento // // // // // el puntero auxiliar apunta a la salida de la cola la nueva salida de la cola es el nodo siguiente el nodo desencolado no tiene siguiente se verifica si la cola qued vaca cola qued vaca: tambin el puntero de entrada es Null

LA VERIFICACIN DE COLA VACIA

Consiste en verificar si el puntero de salida seala un nodo o es Null. Si este puntero es Null significa que la cola est vaca y se devuelve verdadero; si apunta a un nodo (cola no vaca), se devuelve falso. Su encabezado es: logico funcion vacia(tipoCola salida) El desarrollo de esta funcin es muy similar al desarrollo de la verificacin de Pila vaca: - 121 -

ALGORITMOS Y ESTRUCTURAS DE DATOS logico funcion vacia(tipoCola S) logico vc // variable auxiliar que indicar si est o no vaca
inicio si (S = Null) entonces vc Verdadero sino vc Falso finsi retornar(vc) finfuncion

// la cola est vaca, se devolver verdadero // la cola no est vaca, se devolver falso

8.8.5

LISTAS CIRCULARES

Las listas enlazadas simples no permiten acceder directamente a cualquier nodo a partir de una posicin dada, siempre es necesario iniciar la bsqueda desde el primer nodo. En lugar de almacenar un puntero con el valor Null en el ltimo nodo, se hace que ste apunte al primero.

Lista circular

Presentan las siguientes ventajas respectos de listas enlazadas simples: - Cada nodo es accesible desde cualquier otro nodo. - No es necesario mantener un puntero sealando siempre a un nodo particular, debido a esto - No existe un primer nodo bien definido, ya que el puntero puede sealar cualquier nodo. - Se puede recorrer la estructura sin uso de punteros auxiliares. - La insercin ordenada no presenta casos especiales. Presenta el siguiente inconveniente: - Si no se cuida en el recorrido, se pueden producir bucles infinitos.

8.8.6

LISTAS DOBLEMENTE ENLAZADAS

Para todos los casos presentados anteriormente, solo es posible recorrer las estructuras en un sentido. Existen casos donde es conveniente recorrer la estructura en ambos sentidos. Para poder recorrerlas en ambos sentidos se necesita un puntero al nodo anterior. Estas listas son llamadas listas doblemente enlazadas. En la definicin del tipo de datos para estas listas, adems de los datos propios del caso, se debe incluir dos punteros: uno para sealar el nodo siguiente (al igual que en listas enlazadas simples) y uno para sealar al anterior. Los extremos almacenan el valor Null sealando que no existe un siguiente al ltimo nodo ni un anterior al primer nodo.

Lista doblemente enlazada

Presentan las siguientes ventajas respectos de listas enlazadas simples: - Cada nodo es accesible desde cualquier otro nodo. - 122 -

ALGORITMOS Y ESTRUCTURAS DE DATOS - No es necesario mantener un puntero sealando siempre a un nodo particular. - Se puede recorrer la estructura en ambos sentidos. Presenta el siguiente inconveniente: - Los algoritmos de insercin y borrado son ms largos. - Ocupan ms espacio de memoria (por el puntero adicional).

- 123 -

ALGORITMOS Y ESTRUCTURAS DE DATOS

CAPTULO 9

RECURSIVIDAD

INTRODUCCIN
En el captulo anterior se present el concepto de estructuras dinmicas y el de nodo. Como se observ, en la declaracin del tipo de datos para un nodo se hace referencia al propio tipo. Esto es una de las formas de la recursividad. En este captulo se plantear el concepto de recursividad y su uso para formular soluciones a problemas que por sus caractersticas requieren algoritmos que se llaman a s mismos. Se reescribirn algoritmos que ya se trataron anteriormente utilizando este concepto, como ser el caso del factorial de un nmero, el recorrido de listas enlazadas y la insercin ordenada de nodos en ella. Estos algoritmos nos irn introduciendo en el prximo captulo, cuando se tratarn rboles como un Tipo Abstracto. Finalmente veremos algunos aspectos que se deben tener en cuenta antes de decidir la implementacin de un algoritmo recursivo, por lo que tambin se har una comparacin entre soluciones iterativas y recursivas. - 123 -

ALGORITMOS Y ESTRUCTURAS DE DATOS

9.1 RECURSIVIDAD
Es una herramienta de programacin que permite resolver problemas evolutivos, donde un mdulo de programa se invoca a s mismo. Permite disear la solucin de un problema por resolucin de instancias menores del mismo problema. Usando la recursividad, el problema se resuelve parcialmente en distintas instancias de ejecucin del mismo algoritmo, donde cada una, en cierto sentido, es ms simple. Decimos entonces que, un mdulo es recursivo si dentro de l hay un llamado a s mismo. Si la solucin de un problema requiere un mdulo donde se realizan llamados a s mismo, decimos que el mdulo es recursivo. Otra forma de recursividad se da cuando un mdulo invoca a un segundo mdulo y ste, a su vez, vuelve a invocar al primero. Decimos que este es un caso de recursividad indirecta. La recursividad tambin se puede dar en las declaraciones de tipos de datos. Como vimos anteriormente, la declaracin de los tipos de datos para un nodo requiere un puntero del mismo tipo que se est declarando, es decir, hacemos referencia al tipo durante la propia declaracin del tipo. De acuerdo a lo sealado, en nuestro pseudocdigo no habr algoritmos completamente recursivos, solo habr procedimientos o funciones recursivas.

9.1.1 ASPECTOS A TENER EN CUENTA PARA EL USO DE LA RECURSIVIDAD

En primer trmino, se debe tener en cuenta que el llamado al mdulo dentro del mdulo debe estar condicionado, caso contrario se estarn haciendo infinitos llamados al mismo mdulo. Un mdulo tpico que utiliza la recursividad puede verse de la siguiente forma: procedimiento modulo(tipoDato dato1, tipoDato dato2,)
tipoDato var1, var2, inicio // declaracin de variables auxiliares // acciones previas al llamado recursivo // condicin que debe cumplirse para el llamado // llamado al mismo mdulo (recursividad) // acciones posteriores al llamado recursivo

si (condicin) entonces modulo(dato1, dato2, ) finsi

finprocedimiento

Obsrvese que en el llamado se debe respetar el pasaje de parmetros, donde el valor contenido en dato deber ser distinto en cada llamado. La solucin a un problema solo se podr obtener a travs de un algoritmo recursivo si el problema tiene un caso especial cuya solucin es inmediata, es decir, no requiere la solucin de una instancia menor del mismo problema. Veamos un ejemplo. El factorial de un nmero se define como: n! = n * (n-1)!. Como se puede observar, la solucin del factorial de n necesita que se calcule previamente el factorial de n-1, luego ste necesitar el resultado del factorial de n-2 y as sucesivamente. Finalmente se define que factorial de 0 es 1 (0! = 1), este constituye el caso especial que no requiere de ninguna solucin parcial. Entonces, podramos definir a la funcin factorial como: Si n = 0 entonces 0! = 1, sino n! = n * (n-1)! Reemplazando los smbolos de factorial por variables podemos resolver este problema utilizando un algoritmo recursivo. Ms adelante en este captulo se presenta la funcin factorial recursiva. - 124 -

ALGORITMOS Y ESTRUCTURAS DE DATOS Tambin deber tenerse en cuenta que el llamado que define a la recursividad (llamado al mdulo dentro del mismo mdulo) no puede estar en un bucle, debe estar en una estructura condicional. Otro aspecto es que toda solucin recursiva tambin tiene una solucin iterativa (con estructuras repetitivas). Entonces, cundo se debe utilizar la solucin recursiva y cundo la iterativa? Cules son las ventajas y desventajas del uso de la recursividad? Cuando la solucin del problema requiere un algoritmo con estructuras repetitivas poco claro o muy complejo y la solucin recursiva es simple de entender y programar utilizaremos la recursividad, caso contrario se recomienda utilizar estructuras repetitivas. Una desventaja de la recursividad es el excesivo uso de los recursos del sistema de computacin. Observemos nuevamente el ejemplo de cdigo presentado ms arriba: ste posee parmetros de entrada y variables locales. Como ya sabemos, cada llamado a un mdulo crea e inicializa variables locales y parmetros. Adems, como se mencion antes, es necesario almacenar en una pila el estado del algoritmo que invoca al mdulo y la direccin de retorno para restaurar la ejecucin de ste cuando finaliza la ejecucin del mdulo. Esto hace que las soluciones recursivas requieran muchos recursos del sistema. Para disminuir este problema, se recomienda que los mdulos recursivos utilicen pocas variables locales.

9.2 CONCLUSIONES
Como regla general tenemos: USAR RECURSIVIDAD SI: - Los algoritmos que resuelven el problema con recursividad son simples y claros. - Los algoritmos iterativos que resuelven el problema son complicados de entender. - Soluciones a problemas complejos. - Cuando el problema a resolver es de carcter recursivo (son ejemplos el factorial de un nmero y la serie de Fibonacci). - Cuando los datos involucrados en el problema estn organizados en estructuras que se definen recursivamente, como listas, rboles y grafos. DESVENTAJAS DE LA RECURSIVIDAD - Sobrecarga asociada con las llamadas a mdulos. - Una llamada puede generar un gran nmero de llamadas vinculadas recursivas. - La claridad compensa la sobrecarga? - El valor de la recursividad reside en el hecho de que se puede usar para resolver problemas sin fcil solucin iterativa. - La ineficiencia inherente de algunos algoritmos recursivos. - Excesivo uso de recursos de memoria y procesamiento. - El lenguaje de programacin a utilizar requieren tener manejo dinmico de memoria.

9.3 EJEMPLOS
A continuacin se presentan algunos ejemplos de uso de la recursividad a problemas que anteriormente se solucionaron con algoritmos iterativos.

EJEMPLO 9.3.1: Factorial de un nmero natural.

Como se mencion antes, el factorial de un nmero n se resuelve con un algoritmo recursivo que se invoca sucesivamente con valores menores a n hasta 0 (cero), donde se define que factorial de 0 (cero) es 1 (uno).

- 125 -

ALGORITMOS Y ESTRUCTURAS DE DATOS

variables entero n real fact inicio

// acciones previas al clculo del factorial leer (n) // se lee el nmero para el cual se calcular el factorial si (n > 0) entonces // si el nmero ledo es natural, se calcula el factorial fact factorial(n) // llamado a la funcin para calcular el factorial del nmero finsi // contina el cdigo fin // fin del algoritmo principal
real funcion factorial (entero n) real fact // variable local en la que se almacena el resultado inicio si (n <> 0)entonces fact n * factorial(n-1) // primero se debe calcular (n-1)! sino fact 1 // Se define: 0! = 1 finsi retornar(fact) // Se devuelve el valor obtenido finfuncion

EJEMPLO 9.3.2: Recorrido de una Lista Enlazada Simple.

La solucin iterativa de este problema tambin se present con anterioridad. Aqu se asume que se tiene una lista enlazada cuyos nodos solo contienen nmeros. Se recorre la lista para mostrar (escribir) su contenido.
tipo numeros entero num numeros sgte fintipo variables numeros L, p inicio

recorrer (L)

fin

// // // //

acciones previas , se crea la lista llamado al procedimiento recorrer (recursivo) contina el cdigo fin del algoritmo principal

procedimiento recorrer(numeros p) inicio si (p <> Null)entonces escribir(pnum) recorrer(psgte) finsi finprocedimiento // Se verifica si se lleg al final de la lista // no es el final: se escribe el dato contenido en el nodo // y se llama a recorrer (siguiente nodo)

EJEMPLO 9.3.3: Insercin de un nodo al final de una Lista Enlazada Simple.

La solucin consiste en hallar el ltimo nodo y hacer que su siguiente sea el nuevo nodo. Utilizamos la lista enlazada del ejemplo anterior. - 126 -

ALGORITMOS Y ESTRUCTURAS DE DATOS

tipo numeros entero num numeros sgte fintipo variables numeros L, p Inicio

p nuevo(numeros) si (p <> Null) entonces leer (pnum) psgte Null L insertar (p, L) finsi

// // // // // //

acciones previas , se crea la lista se solicita espacio de memoria para el nuevo nodo se cre el nodo leemos del nmero que se almacenar en el nodo el nodo ser el ltimo, no tiene siguiente insertar el nodo apuntado por p en la lista L

Fin

// contina el cdigo // fin del algoritmo principal

numeros funcion insertar(numeros p, numeros r) inicio si (r <> Null)entonces rsgte insertar(p, rsgte) sino r p finsi retornar(r) finprocedimiento

Comentarios sobre la funcin: se debe hallar el final de la lista (r = Null). Como el algoritmo es recursivo, si no se lleg a esta situacin lo volvemos a llamar pasando la direccin del nodo siguiente. Si estamos con el puntero de recorrido r en Null (final de la lista), hacemos que ste seale al nuevo nodo (r p) y retornamos su direccin. Al retornar, estamos saliendo del llamado (volvemos al nodo anterior) con lo cual la direccin devuelta (la del nuevo nodo) se asigna como siguiente del nodo actual (ltimo nodo) y el nuevo nodo queda al final de la lista.

EJEMPLO 9.3.4: Insercin de un nodo en una Lista Enlazada Simple Ordenada.

La solucin consiste en hallar la ubicacin del nodo en la lista y hacer que su siguiente sea el primer nodo que contenga un nmero mayor. Utilizamos la lista enlazada del ejemplo anterior (pero ahora ordenada). Como solo vara la funcin insertar respecto de lo ya presentado, solo se mostrar el cdigo de sta.
numeros funcion insertar(numeros p, numeros r) inicio si (r <> Null)entonces si (pnum < rnum) entonces psgte r r p sino rsgte insertar(p, rsgte) finsi sino r p finsi retornar(r) finprocedimiento

- 127 -

ALGORITMOS Y ESTRUCTURAS DE DATOS Comentarios sobre la funcin: como puede observarse, es bastante similar a la anterior. La diferencia se encuentra en la comparacin del valor almacenado en el nuevo nodo con los valores almacenados en los nodos de la lista para hallar su ubicacin: si el ordenamiento de los datos en la lista es de menor a mayor, se debe hallar un nodo que posea un valor mayor al que se est por insertar, hacer que ste sea el siguiente del nuevo nodo (psgte r) y retornar la direccin del nuevo nodo (r p). Por otra parte, si en la bsqueda llegamos a r = Null, significa que el nuevo nodo posee el mayor valor y debe insertarse al final. Los algoritmos recursivos para listas enlazadas simples no utilizan punteros auxiliares al nodo anterior; sin embargo, cada llamado crea nuevos punteros auxiliares, por lo que en cada nodo visitado se deja un puntero sealndolo. Como los dos ltimos algoritmos poseen dos parmetros (los punteros p y r), cada llamado crea un espacio de memoria para cada uno de ellos: El espacio total de memoria ocupado por la recursividad depende directamente de la cantidad de nodos que posee la lista. Estos ltimos algoritmos son importantes para comprender el ltimo tema de esta ctedra: Estructuras Dinmicas no Lineales, en especial los rboles. Los algoritmos no recursivos para construir y mantener rboles son sumamente difciles de interpretar, por lo que se utiliza la recursividad.

- 128 -

Ingeniera en Informtica Licenciatura en Sistemas de Informacin Profesorado en Informtica

ALGORITMOS Y ESTRUCTURAS DE DATOS

GUIA DE TRABAJOS PRACTICOS - 2009

ALGORITMOS Y ESTRUCTURAS DE DATOS

Gua de Trabajos Prcticos TRABAJO PRCTICO N 1 1. Escribir los algoritmos que resuelvan los siguientes problemas: a. Preparar mate. b. Preparar huevos fritos. c. Lavar el auto. d. Alistarse para ir al Instituto. e. Cambiar una lmpara quemada por una nueva. 2. Indicar cules de los siguientes nombres de variables no son vlidos en un programa: a. Precio f. X&Z b. 4x g. 4_X c. Apellido y Nombres h. Ape_Nom d. A34 i. A_34 e. Calle y Nmero j. Ao 3. Indicar cules de las siguientes constantes no son vlidas en un programa: a. 234 f. 3 b. 10.365 g. 5 mm c. San Martn 1.236 h. Salta 1.968 d. Hola i. 10 * X e. 10 x 3.69 j. 31/03/2001 4. Escribir las siguientes expresiones algebraicas como expresiones algortmicas: a. b. c.
b 4ac
2

e. 4 z f.

12 4

x2 y2 z2 4 3 r 3

25 30 x 5
1 x2 4

g. 2x 3 x 2

d. 4x 2 - 2x 7

h. 5 9 * 3 / 5 3

5. Si A = 5 y B = 10. Qu valor asume C en cada caso? a. C A B f. C (B - A) / (A - 3) b. C A * 5 B g. C 4 / 2 * 3 / 6 B / 2 / 1 / 5 ^ 2 - A c. C B A 25 4 * (A * B) / 2 h. C B ^ A (A / B) - 20 / B d. C 25 ^ (1/2) * 5 * A - B i. C (A B) / (B - A) e. C A - B / 2 A * 5 j. C A * B * 5 (B - A) ^ 3 6. Con qu valores finalizan A, B y C despus de las siguientes asignaciones? Realizar la prueba de escritorio.
A 10 B5 a) CB BC A 10 B5 c) C A*5* B B A B C

b) B 5

A2

C 3* A - 4 * B / A ^ 2

d) B 10

A5

C A B * 4^ 1 / 2 / 2

Pgina 1 de 15

ALGORITMOS Y ESTRUCTURAS DE DATOS

Gua de Trabajos Prcticos 7. Evale las siguientes expresiones lgicas: a) B .False.
(A and B) or (A and (not B)) A5 b) B 10 (A B) or (B 15) A 10 B True not (A 20) and B A .True.

f)

A 10 B False not (A 5) and (B and (A 20))

A 10 B True C " rbol" C " Casa" or (not B and A 123) A True B 236 X " Hola" (A or (B 158)) and X " Hola" and not B 25 A 258 B 147 C True not (((A B) or C) and (not C or ((B 478) and C))) A 125 B 98 C 45 ((C A) and (B 100)) or not ((C B) or (C 50))

g)

c)

h)

A True d) B False (A and B) or (A and (not B)) A 10 B False not (A 5) and (B and (A 20))

i)

e)

j)

Pgina 2 de 15

ALGORITMOS Y ESTRUCTURAS DE DATOS

Gua de Trabajos Prcticos TRABAJO PRCTICO N 2:

ESTRUCTURAS DE CONTROL
1. Escribir un algoritmo que permita ingresar por teclado dos nmeros e imprima su suma. 2. Escribir un algoritmo que permita ingresar por teclado un nmero y escriba su cuadrado. 3. Escribir un algoritmo que intercambie dos valores numricos ingresados por teclado. Ej: si A5 y B10, al finalizar el ejercicio los valores de las variables deben ser B=5 y A=10 4. Convertir una cantidad expresada en dlares a pesos. Se debe prever que el valor de conversin es variable. 5. Se ingresa una medida en metros. Se desea un algoritmo que realice la conversin de metros a pies y pulgadas (1 metro = 39.37 pulgadas, 1 pie = 12 pulgadas). 6. Escribir un algoritmo que permita calcular e imprimir la hipotenusa de un tringulo rectngulo dados los valores de sus catetos. Frmula de clculo: h a 2 b 2 , donde a y b son los catetos, h es la hipotenusa; los valores de a y b se ingresan por teclado 7. Escribir un algoritmo que calcule la superficie de un crculo. Frmula de clculo: S = 2 8. Realizar un algoritmo que, al ingresar por teclado el precio por Kg y la cantidad en Kg adquirida por el cliente de tres productos ( 6 variables) muestre: a.- El monto total en pesos correspondiente a la compra de cada producto. b.- El total en pesos de la compra realizada por el cliente. c.- Si el total es superior a $100, hacer un descuento del 10%. Informar el nuevo monto. 9. Escriba un algoritmo capaz de encontrar el mximo de dos valores (M y N) que se ingresan por teclado 10. Escribir un algoritmo que permita ingresar tres nmeros distintos entre s e imprima el mayor. 11. Desarrollar un algoritmo que permita realizar la suma de dos horas distintas ( HH, MM, SS) utilizando para el almacenamiento de dichas horas, variables de tipo numricas enteras. 12. Escriba un algoritmo que halle la media de tres valores A, B, C. El mismo debe informar los tres valores por separado y luego el promedio. 13. Las races de una ecuacin de segundo grado ax 2 + bx + c = 0 son reales si y slo si el discriminante dado por (b2 - 4ac) no es negativo. Se desea leer el valor de los coeficientes a, b, c e imprimir el resultado del discriminante. Realizar prueba de escritorio. 14. Realizar un algoritmo para determinar si dados dos nmeros ledos por teclado, uno es mltiplo del otro. 15. Escribir un algoritmo que muestre los nmeros impares entre 0 y 100 y que imprima cuantos impares hay. 16. Escribir un algoritmo que imprima la tabla de multiplicar del 2. 17. Escribir un algoritmo que imprima todas las tablas de multiplicar (desde la del 2 hasta la del 9). 18. Realizar un algoritmo que imprima e informe la suma total de la serie de nmeros 3,6,9,12,...,99.

Pgina 3 de 15

ALGORITMOS Y ESTRUCTURAS DE DATOS

Gua de Trabajos Prcticos 19. Realizar un algoritmo que permita ingresar un nmero, entero y realizar la suma de todos los nmeros que le anteceden, comenzando desde 0. Mostrar el resultado por pantalla. 20. Escribir un algoritmo que imprima la suma de los 1000 primeros nmeros naturales, es decir, 1 + 2 + 3 + 4 + ... + 998 + 999 + 1000. 21. Escriba un algoritmo para imprimir las coordenadas (X Y) de una funcin cuadrtica, de la forma Y = ax2 + bx + c, haciendo variar x en el intervalo [-20, 20] con un incremento de 2. 22. Escribir un algoritmo que calcule la suma de los cuadrados de los 10 primeros nmeros naturales. 23. Escribir un algoritmo que calcule el factorial de un nmero. El factorial de un nmero N se simboliza: N!, donde N! = N * (N-1)!. Slo existen factoriales de nmeros naturales y el cero. Se define 0! = 1. Ej: 5! = 5 * 4 * 3 * 2 * 1 * 1. 24. Dados 10 nmeros enteros, escribir un algoritmo que imprima la suma de los nmeros pares de la lista, cuntos nmeros pares existen y cul es el promedio de los nmeros impares. 25. Escribir un algoritmo capaz de encontrar todos los nmeros de tres dgitos que cumplan con la condicin de que la suma de los cubos de sus dgitos sea igual al nmero que la cifra representa. Ej que imprima 328 si se cumple que 328=3 3+23+83 26. Ingresar una a una las edades de un grupo de 50 alumnos y determinar la menor edad y en que orden ingreso el alumno. Ejemplo para n=5 alumnos, si las edades son: 13, 12, 11, 16, 15 entonces la menor edad es 11 y el alumno entro en el orden 3 de la lista. 27. Disee un algoritmo para calcular el resultado de la suma de los 100 primeros trminos de la siguiente serie: S = 1 1/3 + 1/9 1/27 + 1/81-. 28. Desarrollar un algoritmo que determine en un conjunto de cien nmeros naturales cuntos son impares, cuntos son mayores de 50 y cuntos estn comprendidos entre 25 y 45. 29. Realizar un algoritmo que imprima todos los mltiplos de un nmero M comprendidos entre otros dos nmeros A y B. (A<B). Los tres vales (M, A y B) se ingresan por teclado 30. Realizar un algoritmo que imprima los nmeros primos entre N y M. (N<M). 31. En una empresa trabajan N empleados cuyos sueldos oscilan entre $700 y $2000, realizar un algoritmo que lea el numero de legajo de cada empleado y el sueldo que cobra, e informe cuantos empleados cobran entre $700 y $1000 y cuantos cobran mas de $1000. Adems el algoritmo deber informar el importe que gasta la empresa en sueldos al personal. 32. Una empresa de construcciones necesita calcular para cada uno de sus empleados el total de horas trabajadas en el da, para ello se cuenta con la hora de entrada (hora y minutos) y la hora de salida (hora y minutos) de cada uno de ellos. Realizar un algoritmo que informe para cada empleado el total de horas trabajadas en el da y adems, informar el total de horas que trabaj el empleado que ms trabaj y el total de horas trabajadas por todos los empleados. 33. 500 personas completan un cuestionario sobre lectura de los diarios A, B y C. Efectuar un algoritmo que informe: a) Cuntos leen el diario A solamente. b) Cuntos leen los tres diarios.

Pgina 4 de 15

ALGORITMOS Y ESTRUCTURAS DE DATOS

Gua de Trabajos Prcticos c) Cuntos no leen ningn diario. d) Cuntos no leen el diario A, pero si alguno de los otros dos. e) Cuntos leen el diario A y otro ms. 34. 500 personas completan un cuestionario sobre lectura de los diarios A, B y C. Efectuar un algoritmo que informe: a) Cuntos leen los tres diarios. b) Cuntos leen A y B c) Cuntos leen B y C d) Cuntos no leen. 35. Se realiz un censo provincial y se desea procesar la informacin obtenida en dicho censo. De cada una de las personas censadas se tiene la siguiente informacin: numero de documento, edad y sexo (F o M). Realizar un algoritmo que lea los datos de cada persona censada (para fin de ingreso de datos, ingresar cero como numero de documento) e informe: Cantidad total de personas censadas, cantidad de varones y cantidad de mujeres, porcentaje de varones cuya edad varia entre 16 y 65 aos, respecto del total de varones, datos de la persona que registra la mayor edad. 36. En una tienda de artculos para caballeros al final del da se carga en la computadora las boletas que confeccionaron los distintos vendedores para saber cuanto fue la comisin del da de cada uno de ellos. Los datos que se ingresan (por boleta) son: el nmero de vendedor y el importe. Cuando no hay ms boletas para cargar se ingresa 0 como numero de vendedor. Teniendo en cuenta que el negocio tiene 3 vendedores y que el porcentaje sobre las ventas es del 5%, indicar cunto gan cada vendedor en el da. 37. En un club se registran, entre otros datos, para cada uno de los socios: Nmero de socio, edad, tipo de deporte que practica (1 tenis, 2 rugby, 3 voley, 4 hockey, 5 futbol). Realizar un algoritmo que permita informar cuantos socios practican tenis y cuantos futbol y el promedio de edad de los jugadores por deporte. 38. Una empresa de servicios de entregas, desea informatizar su sistema de clculo del costo de envo de encomiendas de entrega dentro del pas. El costo depende del peso (en gramos) de la encomienda. Se consideran solo tres rangos de pesos: Hasta 500 gr. el costo es de $9,50; hasta 1 kg. es de $18,50 y para paquetes de ms de 1 kg. el costo es de $20,00 ms $1,00 por cada 100gr. A partir de l kilogramo. La empresa no hace entregas de paquetes de ms de 5 kg.. Adems se deber tener en cuenta si el paquete debe ser de entrega con urgencia (U) o normal (N). Para envos con urgencia se recarga el valor final en un 15%.Realizar un algoritmo que, dando el peso de los paquetes, calcule el costo de envo de los mismos. El proceso finaliza con un paquete de peso 0 (cero). 39. Un atleta pierde en sus carreras, 100 gramos de peso por cada 50 m recorridos. La comisin organizadora de Olimpiadas desea un algoritmo que ingresando como datos el numero del corredor, peso (en gramos), la longitud del circuito(nunca menor a 50m) y el tiempo empleado (expresado en segundos) informe para cada corredor lo siguiente: Cuantos gramos perdi el corredor y cual es su peso final. Si ha perdido mas de 300gr de peso, pero menos de 450gr, indicar con un mensaje que necesitar vitamina A; si ha perdido mas de 450 gr necesitar vitamina C. Si el circuito tiene una longitud de 400m el tiempo record es 25 seg y si la longitud es de 250m el tiempo record es 15seg, informar si el corredor ha mejorado alguno de estos tiempos.

Pgina 5 de 15

ALGORITMOS Y ESTRUCTURAS DE DATOS

Gua de Trabajos Prcticos TRABAJO PRCTICO N 3 1. Realizar un algoritmo que permita ingresar una cadena de caracteres e informe cuntas letras a contiene esa cadena. 2. Se ingresa por teclado una cadena de caracteres, el algoritmo deber contar cuntas veces aparece la cadena de caracteres la dentro de la cadena ingresada. 3. Se ingresa por teclado una cadena de caracteres, el algoritmo deber contar cuntas veces aparece la palabra la dentro de la cadena ingresada. 4. Realizar un algoritmo para ingresar una serie de nmeros enteros positivos (de a uno por vez). El algoritmo deber imprimir el mayor de todos. El final de la serie viene dado por el nmero 0. 5. Ingresar un texto por teclado, el fin del texto esta dado por un punto y las palabras estan separadas entre si por espacios en blanco, comas o punto y coma. Realizar un algoritmo que informe: a. Cantidad de palabras que finalicen con la expresin ese b. Cantidad de palabras ese c. Determinar la cantidad total de s en el texto d. Calcular el promedio de letras s en todo el texto 6. Se dispone de una secuencia de caracteres y se desea saber la cantidad de caracteres (incluidos los espacios) que existen entre la aparicin de dos comas consecutivas. 7. Ingresar un texto por teclado, el fin del texto esta dado por un punto y las palabras estn separadas entre si por espacios en blanco, comas o punto y coma. Realizar un algoritmo que informe: a. Cantidad de palabras que terminen con ga, la o ta, pero tengan menos de cinco letras. b. Longitud de la palabra mas corta. c. Cantidad de palabras que contengan un nmero par de veces la letra c 8. Se ingresa una serie de nmeros naturales, el final est dado por el 0. Escribir un algoritmo que imprima el mayor, el menor, el promedio y la cantidad de nmeros ingresados. 9. Ingresar un texto por teclado, letra por letra. Las palabras estan separadas con blancos, comas o puntos y comas. El fin del texto se indica con un punto. Se necesita informar cuantas palabras contienen las letras c1 y c2, ingresadas por teclado. 10. En una ciudad se realiza un plebiscito. A cada persona se le realiza una pregunta, la respuesta puede ser S (si) N (no) o una abstencin. Realizar un algoritmo que informe cuntas personas votaron por si, cuntas por no, cuntas abstenciones hubo y en total cuntos votaron. Por fin se ingresa un * 11. Realizar un algoritmo que determine si una serie de nmeros naturales ingresada por teclado es ascendente. El final de la serie viene dado por el cero (0). (Ej: Para la siguiente serie:1, 5, 5, 10, 11, 12, 12, 20, 0 el algoritmo debe informar que es una serie ascendente).

Pgina 6 de 15

ALGORITMOS Y ESTRUCTURAS DE DATOS

Gua de Trabajos Prcticos 12. Realizar un algoritmo que determine si una serie de nmeros naturales ingresada por teclado es estrictamente ascendente. El final de la serie viene dado por el cero (0). (Ej: Para la siguiente serie :1, 5, 10, 11, 12, 20, 0 el algoritmo debe informar que es una serie estrictamente ascendente). 13. Se desea calcular el costo de un telegrama, que se determina en funcin del nmero de palabras (que vale V1 cada una), salvo que el promedio de letras por palabra supere las cinco letras, caso en que cada palabra vale V2. Los valores por palabra se ingresan por teclado. 14. Escribir un algoritmo que informe todas las palabras en posicin par de cada oracin de una secuencia texto de entrada que adems comienzan con la letra M. 15. Realizar un algoritmo para ingresar una serie de ternas de nmeros enteros positivos distintos entre s. El final de la serie viene dado por una terna de ceros. Por cada terna, imprimir el mayor, por final imprimir el mayor nmero de todos. 16. Se procesa una encuesta de alumnos que contiene los siguientes datos: edad, sexo y Estado Civil (1:soltero, 2: Casado). Realizar un algoritmo que informe cuntos alumnos hay en total, cuntos son varones de 21 ms aos de edad y cuntas mujeres son solteras. El fin viene dado por una terna 0, , . 17. Realizar un algoritmo para determinar si una serie es estrictamente positiva (no contiene nmeros negativos ni el cero (0)). El fin de la serie viene dado por el cero (0). 18. Escribir un algoritmo para ingresar una cadena de caracteres. Deber informar cuntas palabras contiene. (Sugerencia: Contar las palabras, no los espacios en blanco que separan palabras, pues el operador puede equivocarse y tipear ms de un espacio en blanco entre las palabras).

Pgina 7 de 15

ALGORITMOS Y ESTRUCTURAS DE DATOS

Gua de Trabajos Prcticos TRABAJO PRCTICO N 4:

VECTORES
1. Realizar un algoritmo que permita el ingreso por teclado de los 30 elementos, estos elementos debern cargarse a un vector numrico, duplicar sus valores y luego imprimirlos en el orden ingresado. 2. Realizar un algoritmo que permita el ingreso por teclado de los 30 elementos, estos elementos debern cargarse a un vector numrico y luego imprimirlos en el orden inverso al ingresado. 3. Realizar un algoritmo que permita el ingreso por teclado de los 30 elementos, estos elementos debern cargarse a un vector numrico y luego imprimir cada elemento del vector que vaya precedido inmediatamente por un elemento cero. 4. Realizar un algoritmo que cargue un vector A con 10 elementos numricos reales y realice las siguientes modificaciones: a. Asignar el valor 11.2 a la tercer posicin del vector A b. Asignar el valor del elemento de la octava posicin del vector A en la segunda posicin c. Intercambiar el elemento de la cuarta posicin, con el de la novena posicin del vector A. 5. Cargar un vector con las alturas de los N alumnos de un curso. Determinar la media y luego informar cuantos alumnos son mas altos que la media y cuantos mas bajos.

6. En un colegio secundario, se maneja la informacin de las notas de un curso, con tres vectores de longitud N, llamados trim1, trim2 y trim3. Los componentes de los vectores, son las notas del primero, segundo y tercer trimestre respectivamente, para cada alumno. Generar un cuarto vector de nombre prom, donde cada componente sea el promedio de los elementos homlogos de los tres vectores. Imprimir los tres mejores promedios del curso. 7. Los elementos de un vector numrico de 10 posiciones estn relacionados con la siguiente expresin: A[i+1] = i*A[i]+i2 y siendo A[1] = 1. Realizar un algoritmo para calcular los elementos de este vector. 8. Realizar un algoritmo que permita el ingreso por teclado de los 30 elementos, estos elementos debern cargarse a un vector numrico y luego imprimir: a. El posicin (ndice) del primer elemento menor que 0. b. El valor y posicin del mayor elemento. 9. De los 100 empleados de una fbrica se registra: nmero de legajo (coincide con el nmero de ndice), edad y salario. Se pide: a. Cargar un vector con los datos Ingresados correlativamente b. Calcular la edad promedio informando nmero de legajo de los empleados cuya edad supere el promedio 10. Mismo enunciado al ejercicio anterior. Se pide: a. Ingresar los datos en forma aleatoria. (se pide ingreso de nmero de legajo de 1 a 100, se posiciona en el elemento correspondiente del vector y se ingresa edad y salario) b. Calcular salario promedio informando nmero de legajo de aquellos cuyo salario supere el promedio.

Pgina 8 de 15

ALGORITMOS Y ESTRUCTURAS DE DATOS

Gua de Trabajos Prcticos 11. Dado dos vectores A y B de N y M componentes, realizar un algoritmo que permita ingresar datos a travs del teclado en dichos vectores, generar un nuevo vector que contenga los componentes comunes de los dos anteriores e imprimirlo. 12. Cargar dos vectores: uno de legajos de empleados, y otro de horas trabajadas por estos empleados. Cada vector tendr N elementos y el legajo en la posicin i del primer vector se corresponde con el valor de las horas trabajadas en la posicin i del segundo vector. Se pide: a. Promedio de horas trabajadas b. Imprimir legajos de las personas que trabajaron mas horas que el promedio general c. Legajo de la persona que mas horas trabajo y de la que menos trabajo. 13. Una empresa dedicada a la emisin de una revista informtica, desea conocer cierta informacin, luego de haber lanzado una campaa de promocin. La empresa tiene N vendedores, los cuales realizan suscripciones de clientes. A cada vendedor le ser otorgado un 2% sobre el monto de cada una de las suscripciones que hayan concretado. El monto de las suscripciones es nico y debe ingresarse como dato. El algoritmo a realizar deber manejar un vector CANT, donde cada componente representa un vendedor y en el cual se almacene la cantidad de suscripciones realizadas por cada vendedor. Calcular el porcentaje resultante para cada vendedor, y almacenarlo en otro vector PORC. Imprimir los porcentajes de los 5 vendedores que menos percibieron.

Pgina 9 de 15

ALGORITMOS Y ESTRUCTURAS DE DATOS

Gua de Trabajos Prcticos TRABAJO PRCTICO N 5:

ORDENAMIENTO, BSQUEDA Y HASHING

1. Se dispone de una lista de 5.000 nmeros enteros clasificados en orden creciente, almacenada en un vector. Se desea conocer si un nmero dado a travs del teclado se encuentra en la lista. Qu mtodo utilizara en este caso?Porque? 2. Se dispone de una lista de 10 nmeros enteros clasificados en orden creciente, almacenada en un vector. Se desea conocer si un nmero introducido desde el teclado se encuentra en la lista. En caso afirmativo informar su posicin. Qu mtodo utilizara?Porque? 3. Se dispone de una lista de alumnos ordenada alfabticamente (almacenada en un vector) y sus correspondientes promedios de la materia Algoritmos y Estructuras de datos (almacenados en otro vector). Realizar un algoritmo que permita ingresar por teclado el nombre de un alumno y muestre el promedio de dicho alumno. 4. Se necesita localizar un nombre en un arreglo de N nombres, ordenados alfabticamente. Escriba por lo menos dos algoritmos que permitan solucionar el problema; especifique cul de las formas considera ms eficiente y por qu 5. Se necesita ordenar un arreglo de N productos de mayor a menor. Cada elemento del arreglo contiene Nmero y Precio. Escriba por lo menos dos algoritmos que permitan solucionar el problema; especifique cul de las formas considera ms eficiente y por qu. 6. Cargar un vector con 20 nmeros enteros positivos. Mostrar el vector tal como fue ingresado y luego mostrar el vector ordenado en forma decreciente. 7. Dados dos vectores A y B de N y M componentes ordenados, realizar un algoritmo que genere un nuevo vector de N+M componentes en el que se copian ordenadamente los elementos de A y B. 8. Dado un vector de N nmeros enteros, realizar los algoritmos para ordenar sus elementos a travs de los mtodos: a. Intercambio o burbuja. b. Insercin. c. Seleccin. d. Shell. e. Quicksort. 9. Se dispone de la lista de alumnos inscriptos en la materia Algoritmos y Estructuras de Datos. Realizar un algoritmo que ordene alfabticamente esta lista. 10. Cargar un vector con 20 nmeros enteros (positivos y negativos) distintos de cero. Mostrar el vector tal como fue ingresado y luego mostrar los positivos ordenados en forma decreciente y los negativos ordenados en forma creciente. 11. Se dispone de una lista de alumnos ordenada alfabticamente (almacenada en un vector) y sus correspondientes promedios de la materia Algoritmos y Estructuras de Datos (almacenados en otro vector). Realizar un algoritmo que ordene la lista de alumnos de acuerdo a sus promedios. 12. Realizar un algoritmo que cargue dos vectores, uno con los nombres de las provincias Argentinas y el otro con la temperatura media anual de cada una de ellas. El algoritmo deber informar un listado de provincias y sus temperaturas ordenadas alfabticamente y un listado de provincias y sus temperaturas ordenado por temperaturas decrecientes. 13. Se cuenta con dos vectores de n elementos cada uno. El primer vector contiene nombre de personas y el segundo su sexo (F si es mujer o M si es varn) El algoritmo deber generar dos nuevos vectores uno contendr el nombre de todas las mujeres y el otro vector contendr el nombre de todos los varones ordenados alfabticamente. 14. Una farmacia desea procesar datos sobre sus medicamentos. Se sabe que la misma trabaja con 5 laboratorios distintos. Se pide realizar un algoritmo que cargue dos vectores, uno con

Pgina 10 de 15

ALGORITMOS Y ESTRUCTURAS DE DATOS

Gua de Trabajos Prcticos los nombres de los laboratorios y otro con la cantidad de remedios de ese laboratorio que tiene la farmacia e informe: a) Cantidad de remedios que posee en total la farmacia. b) El vector de cantidades de remedios de cada laboratorio ordenado en forma decreciente, junto con el laboratorio correspondiente (*) c) Ingresar el nombre de un laboratorio e informar con un mensaje indicando si la farmacia trabaja o no con ese laboratorio, en caso afirmativo informar la cantidad de remedios que tiene. 15. Se dispone de una lista de alumnos con sus respectivas matrculas, se dispone adems, de dos vector de 100 posiciones, uno de tipo entero y otro de cadenas de caracteres. Realizar un algoritmo que transforme el nmero de matrcula del alumno en una posicin de almacenamiento en los vectores (la matrcula en el de enteros y los nombres en el de cadenas de caracteres). Utilice el mtodo del mdulo, en caso de colisiones, utilizar la primera celda vaca.

Pgina 11 de 15

ALGORITMOS Y ESTRUCTURAS DE DATOS

Gua de Trabajos Prcticos TRABAJO PRCTICO N 6

MATRICES
1. Elaborar un algoritmo que permita ingresar nmeros enteros en una matriz de 6 x 6, y que imprima al final la suma de las columnas. 2. Elaborar un algoritmo que, permita el ingreso de nmeros enteros en una matriz de 10 x 10, imprima los elementos de la matriz recorriendo por fila y al final de cada fila imprima la suma de esta ltima. 3. Realizar un algoritmo que cargue una matriz de 5 x 10 con elementos reales y realice las siguientes operaciones: a) Asignar el valor 15.6 a la posicin que se encuentra en la segunda fila, quinta columna. b) Ingresar un nmero de fila y asignar en todas las posiciones de esa fila el valor 20. c) Permutar la columna 2 con la 5. d) Informar la matriz con todos los cambios realizados. 4. Elaborar un algoritmo que lea nmeros enteros en una matriz cuadrada de 10 x 10 elementos. Calcular e imprimir la suma de los elementos de su diagonal principal. 5. Elaborar un algoritmo que genere una matriz cuadrada de 10 x 10, en la cual asigne ceros a todos sus elementos, excepto a los de la diagonal principal, donde asignar unos. (Esta matriz recibe el nombre de matriz unidad). 6. Elaborar un algoritmo que genere una matriz cuadrada de 10 x 10, en la cual asigne ceros a todos sus elementos, excepto a los de la diagonal secundaria, donde se asignarn nmeros ledos por teclado. 7. Elaborar un algoritmo que lea nmeros enteros en dos matrices de 5 x 5. Calcular en una tercera matriz la suma de los elementos de las dos anteriores. Al final imprimir las tres matrices. 8. Se dispone de las notas correspondientes a una materia de los 40 alumnos de un curso. Cada alumno tiene 5 notas, donde las notas de un alumno corresponden a una fila de una matriz. Elaborar un algoritmo que calcule e imprima el promedio de cada alumno. 9. Se dispone de las notas correspondientes a una materia de los 40 alumnos de un curso. Cada alumno puede tener hasta 5 notas, donde las notas de un alumno corresponden a una fila de una matriz. Si el alumno no posee las 5 notas, en su lugar figurar un cero, el cual no se promedia. Elaborar un algoritmo que calcule e imprima el promedio de cada alumno. 10. Una compaa de aviacin tiene 4 destinos (numerados de 1 a 4) con 3 vuelos cada uno (numerados de 1 a 3). Se ingresa la informacin de las plazas disponibles en cada uno de los 12 vuelos. Posteriormente llegan pedidos de pasajes de los que se ingresa:N de pedido, N de destino, N de vuelo, Cantidad de pasajes requeridos Si la cantidad de pasajes pedidos es superior a la disponibilidad existente en ese vuelo y para ese destino se rechaza el pedido indicando la leyenda: NO HAY CANTIDAD DE PLAZAS DISPONIBLES. Se pide informar la cantidad de pasajes sobrantes en cada vuelo, los N de pedidos rechazados con la cantidad de pasajes solicitados. 11. Elaborar un algoritmo que lea nmeros enteros en una matriz de 5 x 10, calcular la suma de cada una de sus filas y almacenar su resultado en un vector de 5 elementos, donde al primer elemento del vector le corresponde la suma de la primera fila de la matriz, al segundo la suma de la segunda fila y as sucesivamente. 12. Elaborar un algoritmo que lea nmeros enteros en una matriz de 5 x 10, calcular la suma de cada una de sus filas y columnas, dejando dichos resultados en dos vectores, uno de 5 elementos para las filas y otro de 10 elementos para las columnas. 13. Una empresa de colectivos tiene 3 lneas de 12 coches cada una. Por cada viaje el chofer entrega al llegar a la terminal una planilla con el nmero de coche (de 1 a 12) , nmero de

Pgina 12 de 15

ALGORITMOS Y ESTRUCTURAS DE DATOS

Gua de Trabajos Prcticos lnea ( de 1 a 3) y la recaudacin del viaje. Las planillas se entregan sin ningn orden. Se pide informar por pantalla: a) La recaudacin total por lnea de colectivo. b) La recaudacin total por coche c) La recaudacin total general 14. Un comercio mayorista trabaja con cierta cantidad de artculos. Dispone de un plantel de 15 vendedores para su venta, los cuales estn numerados del 1 al 15 inclusive. El Gerente de dicho comercio, desea obtener cierta informacin estadstica respecto de las ventas realizadas en el mes. El algoritmo deber cargar y manejar: a) Una matriz CANT de 15 * N, en donde cada fila representa un vendedor, cada columna un articulo y cada componente de la matriz CANT [ i, j] la cantidad del articulo j vendida por el vendedor i. b) Un vector en el que cada componente, sea el precio unitario de venta de cada articulo. Se pide emitir un listado como el que se muestra, con las ventas totales por vendedor indicando en l, los importes vendidos. Estadstica de Ventas Vendedor 1 2 Importe vendido 9-------------9.99 9-------------9.99

15. Una empresa dedicada a la comercializacin de productos, tiene un cierto nmero de clientes selectos. Cargar por teclado una matriz, en la que cada fila represente uno de los clientes de la empresa y en la que sus tres columnas representen los siguientes puntos: Columna 1: Numero de cuenta del cliente; columna 2: Tipo de cliente (0:Normal, 1: Atrasado, 2: Especial); columna 3: Aos de relacin comercial con la empresa. 16. Cargar adems un vector saldos, en donde cada componente indique el saldo de cada cliente en su cuenta con la empresa. Debe existir un componente por cada fila de la matriz. Realizar un algoritmo que: a) Modificar el vector de saldos de tal forma que: Sume un inters del 5% a todo cliente atrasado, y otorgue un descuento del 2% a los clientes atrasados. b) Listar el nmero y el saldo de los clientes normales que tengan mas de 5 aos de relacin con la empresa. 17. Elaborar un algoritmo para ingresar nmeros en una matriz en las posiciones correspondientes al tringulo superior (de la diagonal principal hacia la derecha), el resto de la matriz permanece en 0. 18. Elaborar un algoritmo que lea nmeros en dos matrices una de 5 x 4 y la otra de 4 x 3. Calcular en una tercera matriz el producto de los elementos de las dos anteriores, la matriz resultado ser de 5 x 3. Al final imprimir las tres matrices.
Nota: Para poder multiplicar matrices, el nmero de filas de una matriz debe coincidir con el nmero de columnas de la otra (no necesariamente deben ser cuadradas). El producto est definido por la frmula:

c[i,j] = a[i,k] * b[k,j]

19. Elaborar un algoritmo que permita determinar si dada una matriz cuadrada sta es identidad.
Nota: Una matriz A es considerada identidad si cada elemento a[i,j] = a[j,i].

20. En un vector de cadenas de caracteres se tienen almacenados en orden alfabtico los nombres de los 30 alumnos de un curso. Se dispone adems de una matriz de 30 filas (una

Pgina 13 de 15

ALGORITMOS Y ESTRUCTURAS DE DATOS

Gua de Trabajos Prcticos fila por cada alumno) por 7 columnas correspondientes a las notas de cada uno de ellos en las 7 materias que estn cursando. Realizar un algoritmo que permita ingresar por teclado el nombre de un alumno, realizar una bsqueda en el vector de alumnos e imprimir sus correspondientes notas. El nmero de fila correspondiente a las notas de un alumno coincide con la posicin dentro del vector donde se encuentra el alumno (por ejemplo, si el alumno se encuentra en la posicin 23 dentro del vector, sus notas correspondern a la fila 23 de la matriz). 21. Considere el ejercicio anterior. Agregue un vector de 30 nmeros reales en el cual se almacenar el promedio de cada alumno, donde el i-simo promedio corresponde al promedio del i-simo alumno y se calcula promediando la i-sima fila de la matriz. Realizar un algoritmo que permita buscar un alumno dado por teclado e imprimir sus notas y su promedio. 22. Una empresa de construcciones que posee 112 empleados lleva un control de horas trabajadas por cada empleado durante el mes. Para ello cuenta con una estructura de tipo matriz en la que se almacena informacin acerca de las horas trabajadas por cada empleado durante los das del mes (cada empleado trabaja como mximo 25 das al mes). En la primera columna de la matriz se almacena el cdigo (numrico) del empleado, en la segunda el precio por hora, hay una columna para cada da en la que se almacena la cantidad de horas trabajadas en un da. Realizar un procedimiento que calcule e imprima el sueldo de cada empleado: Se debe sumar todas las columnas correspondientes a las horas de trabajo de cada da y multiplicarlo por la Columna 2 para obtener el sueldo. Imprimir el cdigo del empleado y su sueldo.

23. La empresa proveedora del servicio de agua potable desea informatizar su sistema de facturacin a clientes. Para ello, cuenta con informacin acerca del consumo de cada cliente y con una tabla de importes segn la cantidad consumida. Esta informacin se organiza en dos matrices: una matriz con el cdigo de cliente, la cantidad de agua consumida en metros cbicos y una columna para el Importe a facturar, y una segunda matriz: es una tabla en la que figura el costo del metro cbico de agua segn la cantidad consumida (hay 10 rangos de pares cantidad, importe). Realizar un algoritmo para actualizar el importe a facturar, teniendo en cuenta que el Importe total se obtiene del producto de la cantidad de agua consumida por el costo del metro cbico (segn el costo que corresponda) mas un costo fijo (que es el mismo para todos los clientes) mas un 25% en concepto de impuestos.

Pgina 14 de 15

Gua de Trabajos Prcticos

1. Cargar una pila llamada Nmeros, la cual cuenta con un nico elemento llamado Valor, con nmeros positivos mientras no se ingrese un 0. 2. Se cuenta con una estructura de tipo Pila, a cuyo tope apunta la variable TP . Dicha pila tiene una estructura compuesta por dos elementos Nmero y Nombre. Se ingresa un nmero por teclado, se pide que se busque dicho nmero, en caso de encontrarlo imprimir el Nombre correspondiente, en caso de no existir el nmero informar. 3. Se cuenta con una estructura de tipo Pila, a cuyo tope apunta la variable TP . Dicha estructura cuenta con un solo elemento llamado Nmero, se pide la verificacin del contenido de la pila y asegurar de que se encuentra en orden ascendente. Al terminar la verificacin informar del resultado. 4. Desarrollar un algoritmo que cargue por teclado una pila, e intercambie el primer elemento con el ltimo. 5. Se cuenta con una pila cargada con los siguientes datos de los alumnos de un colegio: Nombre, Legajo, Sexo, Edad y Seis notas de las distintas materias (utilizar un vector para almacenar las notas). Informar el promedio general de cada alumno y el promedio de notas del curso. 6. Se cuenta con una estructura tipo Pila a cuyo tope apunta la variable TP , dicha pila se llama Elementos y cuenta con un atributo llamado Nmero. Se pide que se sumen todos los nmeros contenidos en la pila e imprimir el resultado. 7. Se cuenta con una estructura de tipo Pila, a cuyo tope apunta la variable TP . Dicha estructura cuenta con un solo elemento llamado Nmero. La pila se encuentra cargada con nmeros, se pide que se recorra la pila guardando los nmeros pares en otra pila a cuyo tope apunta la variable TPares . 8. Realizar un algoritmo que cargue dos pilas por teclado y genere una tercera pila, conteniendo solo los elementos no comunes de ambas pilas. 9. Se cuenta con dos estructuras tipo Pila llamadas A y B respectivamente. Las dos cuentan con un nico elemento llamado Nmero. Se pide que se cargue una tercera pila llamada C intercalando los valores de A y B. 10. Se cuenta con una estructura de tipo Pila llamada Sueldos, a cuyo tope apunta la variable TP . La misma cuenta con dos elementos llamados Documento y Monto. Se ingresa un documento por teclado, se pide que se imprima el monto a cobrar por dicha persona. Una persona puede tener ms de un sueldo. No perder los datos. 11. Se cuenta con una pila cargada con nmeros positivos y negativos, el tope est apuntado por un puntero llamado P , la pila se llama Mezcla y su atributo Nmero. Se pide que se carguen los nmeros positivos en una pila llamada Positivos cuyo atributo se llama Nmero, y los negativos en otra llamada Negativos cuyo atributo tambin se llama Nmero, a cuyos topes apuntan las variables TPos y TNeg respectivamente. 12. Realizar un algoritmo que cargue una pila por teclado, con valores numricos y luego borre de la misma los elementos con nmeros negativos. Informar el contenido de la pila luego de eliminar los elementos

Gua de Trabajos Prcticos

13. Se cuenta con dos pilas (A y B), cada una con un solo elemento llamado Nmero. Las mismas se encuentran cargadas con nmeros en orden ascendente, se pide que se cargue una tercera pila (C) la cual contiene un nico elemento Nmero, en orden descendente. 14. Se cuenta con dos pilas (A y B), cada una con un solo atributo llamado Nmero. Las mismas se encuentran cargadas, se pide que se verifique si dichas pilas son iguales e informe el resultado de la verificacin. 15. Se cuenta con una pila llamada Pasajeros, la cual cuenta con tres atributos llamados Nombre, DNI, Asiento. Asumiendo que estamos hablando de pasajeros de un avin el cual tiene 120 asientos y que no hay error al venderse los boletos, disear un algoritmo que permita cargar la pila con los datos mencionados. 16. Ocupando la pila del ejercicio anterior (una vez cargada) realizar un algoritmo que permita determinar si un pasajero dado compr un boleto. Para ello se ingresa por teclado el DNI de la persona, de ser encontrado imprimir el Nombre y el nmero de asiento. De no ser encontrado informar. Se exige que los datos no se pierdan. 17. Se tiene una pila llamada Cuotas, la cual tiene dos atributos Fecha e Importe La misma se encuentra cargada. Se pide que se imprima la Fecha e Importe ubicada en el Nodo N, donde N es un nmero ingresado por teclado que representa la posicin del nodo dentro de la pila. Por ejemplo el 2, representa al segundo nodo ingresado. El 5 al quinto ingresado, etc. La posicin puede no existir. 18. Se cuenta con 2 pilas llamadas Pila1 y Pila2 con un nico atributo llamado Nmero, las dos pilas cuentan con la misma cantidad de nodos. Se pide que se tomen pares de nodos (uno de la Pila1 y otro de la Pila2) y se imprima el nombre de la pila que contiene el nmero mayor, esto para todos los nodos de las pilas. Por fin de proceso imprimir el nombre de la pila que ms mayores tuvo. 19. Una empresa que brinda servicios de Internet, requiere de una lista de usuarios que intentaron utilizar sus servicios en un momento dado. Para ello, se dispone de informacin almacenada en una pila. Esta pila contiene todos los intentos de conexin efectuados en un perodo dado, y almacenadas en el orden en que fueron recibidas las solicitudes. Cada nodo tiene los siguientes datos: CodCliente, Usuario (nombre del usuario), TipoConexion (un nmero que indica el tipo de servicio), Fecha, Hora y Sig. El servidor atiende una sola consulta por vez. En caso de haber dos o ms solicitudes del mismo cliente, se asume que solamente la ltima solicitud fue exitosa y los intentos anteriores fueron fallidos; por lo tanto debera considerarse como una nica solicitud de servicio. Asumiendo que TP es el puntero al elemento disponible de la pila (la cual se encuentra cargada), realizar un algoritmo para crear una lista (cuyo puntero al inicio es IN), cuya secuencia de nodos debe indicar el orden de aparicin de las solicitudes sin repeticiones, teniendo en cuenta que la lista tendr la siguiente estructura: CodCliente, Usuario y Sig.

Gua de Trabajos Prcticos

1. Cargar una cola llamada Nmeros la cual cuenta con un nico elemento llamado Valor, con nmeros positivos mientras no se ingrese un 0 (cero). 2. En una cola se tienen los cdigos y los importes de ciertos productos. Se desea saber cuantos tienen un cdigo superior a 1000 y cual es el importe acumulado de esos productos. Adems, informar la cantidad y el importe total de los productos con cdigo inferior o igual a 1000. Imprimir estas cantidades. 3. Se tiene una cola llamada Nmeros, la cual cuenta con un solo elemento llamado Valor. Se pide que se carguen dos colas, una con los nmeros positivos y otra con los nmeros negativos. Las colas se llamarn Positivos y Negativos respectivamente. Por fin de proceso imprimir la cantidad de positivos y de negativos. 4. Hay una cola llamada Impares, la cual cuenta con un nico elemento llamado Nmero. Se pide que se recorra la cola borrando todos los nmeros pares, al terminar el proceso no tiene que existir en la cola ningn valor par. Por fin de proceso imprimir la cantidad de valores borrados. 5. Se tiene una cola cargada con documentos en espera, dicha cola cuenta con dos elementos, llamados Documento (Nombre del documento) y Pginas (cantidad de pginas del documento), por teclado se ingresa un nombre de documento, se pide que se elimine de la cola dicho documento, una vez borrado el documento la cola tiene que quedar ordenada de la misma forma en que se encontraba. 6. Se tiene una cola llamada Alumnos, la cual est formada por dos elementos llamados Nombre y Divisin. Hay 2 (dos) divisiones (A y B). La cola se encuentra cargada con valores, se pide que se carguen dos pilas llamadas DivisinA y DivisinB, en las cuales se debern cargar los nombres de los alumnos de la divisin A y B segn corresponda. 7. Se cuenta con una Pila llamada Nmeros, la misma cuenta con un solo elemento llamado Valor, la pila se encuentra cargada. Se pide que se cargue una Cola con todos los elementos de la pila que sean impares y mltiplos de 3. 8. Un negocio de venta de electrodomsticos almacena toda la informacin necesaria en Colas de la siguiente manera: una cola, llamada VENTAS (V1), con informacin referente a las ventas realizadas, cada nodo esta conformado de la siguiente manera: Nro_Fac, Nom_art, Cd_ven, Unid_vend, Imp_fact. Otra cola, llamada VENDEDOR (V2), con informacin de los vendedores y conteniendo los siguientes datos: Cd_ven, Nom_ven, Dire, Suel_Bsico. Realizar un algoritmo que permita imprimir los datos de todas las ventas pero de forma tal que en vez de mostrar el cdigo del vendedor que la realiz figure el nombre del vendedor y direccin. Crear una nueva cola con los datos de aquellos vendedores que hayan vendido mas de $1000. La cola V2 debe quedar con todos los datos originales. 9. Ferretera Centro necesita que se desarrolle un algoritmo que solucione el manejo de las Ctas Ctes. Partimos con la existencia de una Pila la cual cuenta con datos de los clientes que compran en Cuenta Corriente: N Cliente, DNI, Nombre, Domicilio, Saldo_cta. Por otro lado existe una cola que tiene los siguientes datos de los movimientos diarios: N Cliente, Monto, TO. El TO (tipo de operacin) puede contener 1: Compra o 2:Pago. Realizar un algoritmo que permita actualizar el Saldo de la cuenta de cada cliente con los datos contenidos en la cola.

Gua de Trabajos Prcticos

1. Realizar un algoritmo que permita, dada una lista de valores numricos, determinar cual es el mayor y en que posicin de la lista se encuentra el mismo. 2. Se cuenta con una lista encadenada simple, a cuyo inicio apunta la variable L, y cuyo nodo tiene un solo dato numrico NUM. Desarrollar un algoritmo que permita recorrer la lista e imprimir aquellos contenidos que sean mayores que 4. 3. Dada una lista encadenada de nmeros realizar un algoritmo que calcule en forma independiente: a) La suma de los nmeros impares; b) La suma de los nmeros pares; c) Promedio de los todos los nmeros. 4. Dada una lista simplemente enlazada de nmeros, realizar un algoritmo que imprima la cantidad de nmeros mltiplos de 3 y la suma de todos ellos. 5. Realizar un algoritmo que permita encontrar el mayor y el menor valor en una lista simplemente enlazada de valores numricos, realizando un solo recorrido. 6. Se cuenta con una lista donde cada nodo tiene tres datos, nmero, nombre y monto a cobrar, se ingresa un nmero por teclado, se necesita informar nombre del empleado y monto a cobrar. Mostrar un mensaje en caso de no existir el empleado en la lista. 7. Proponer un formato de datos para una estructura de tipo lista enlazada simple que permita almacenar palabras tomadas de un texto y llevar una cuenta del total de veces que se repite cada una de las palabras en el texto. 8. Realizar un algoritmo que, en base a la estructura de datos del ejercicio anterior, permita leer palabras de un texto, almacenarlas en una lista enlazada simple si an no se encuentran en ella, caso contrario incrementar el contador asociado. 9. Se cuenta con una estructura tipo lista encadenada simple, a cuyo inicio apunta la variable L . Dicha lista se encuentra cargada con nmeros positivos. Se leen nmeros por teclado, se pide que se verifique si el nmero existe en la lista, de existir borrarlo, caso contrario agregarlo al final. El fin viene dado por un nmero 0 o un nmero negativo. 10. Se cuenta con una estructura tipo lista encadenada simple, a cuyo inicio apunta la variable L . Dicha lista se encuentra cargada con nmeros en orden ascendente. Se ingresan 40 nmeros por teclado y se pide que se los ubique en el lugar indicado para mantener el orden, si el nmero ya existe ubicarlo al lado. 11. Se cuenta con una estructura de tipo lista encadenada simple cuyo nombre es Notas la misma cuenta con los nombres de los alumnos y sus notas (al nodo cabecera apunta la variable L ). Se pide que se imprima el nombre del alumno con la mejor nota y el del alumno con la peor nota. En caso de haber ms de un alumno con la mejor o peor nota, imprimir todos los que tengan la misma nota. 12. Se tiene una lista enlazada simple llamada NotasXAlumnoYCarrera, la cual est formada por CodigoCarrera, NombreAlumno, Nota. Se pide que se ordene en otra lista teniendo en cuenta primero la carrera y despus la nota. Esto quiere decir que la lista resultado tiene que quedar ordenada por cdigo de carrera y dentro del orden por carrera ordenada por Nota. Corno fin de proceso imprimir toda la dista resultante.

Gua de Trabajos Prcticos

13. Se cuenta con una pila llamada INCR, a cuyo tope apunta la variable TP , cargada con valores numricos y cuyo nodo posee un solo elemento llamado NRO; y con una lista encadenada simple a cuyo inicio apunta la variable L cuyo nodo posee dos datos: MAT (de tipo numrico) y NOM (de tipo cadena de caracteres). Se debe desarrollar un algoritmo que permita imprimir los nombres de los alumnos que aparecen en la lista y en la pila. 14. Se cuenta con una pila llamada BORRO a cuyo tope apunta la variable TP , cargada con valores numricos y cuyo nodo tiene un solo dato numrico llamado NRO; y con una lista encadenada simple a cuyo inicio apunta la variable L , cuyo nodo tiene dos datos: LEG (de tipo numrico) y APE (de tipo cadena de caracteres). Se debe desarrollar un algoritmo que permita borrar aquellos nodos que aparecen en la lista y en la pila. 15. Se cuenta con un vector de nmeros enteros y se desean generar tres listas, conteniendo: Lista1(L1) los nmeros comprendidos entre 0 y 50; Lista2 (L2) los nmeros comprendidos entre 51 y 100; Lista3 (L3) los nmeros comprendidos entre 101 y 150. En caso, de que el nmero del vector original no cumpla con ninguna de esas condiciones, se lo imprime en pantalla. La insercin puede realizarse en cualquier lugar de las listas, al comienzo, entre dos nodos o al final. Indique cual es su decisin. 16. Una compaa area une las principales ciudades del mundo con vuelos regulares. La informacin de los diferentes destinos se representa utilizando una lista simplemente enlazada. De manera que cada nodo representa un aeropuerto, en el cual se almacena: el nombre del correspondiente aeropuerto, el tiempo de espera medio hasta la salida del vuelo, la duracin del vuelo. Escriba un procedimiento tal que dada la lista anterior, un aeropuerto origen y un aeropuerto destino, visualice por pantalla todos los aeropuertos en los que har escala (origen y destino incluidos) y la duracin total del viaje, incluyendo los tiempos de espera en cada aeropuerto(dados en horas). Hay que comprobar que los aeropuertos solicitados se encuentren en la lista, indicando el posible error. 17. Se cuenta con un vector conteniendo la lista de cursos abiertos en un instituto privado. Se cuenta con otro vector que contiene la cantidad de alumnos que se inscribieron a cada curso en el da de hoy. El elemento i del segundo vector corresponde al i-esimo curso. Se cuenta adems con una lista que contiene nombre del curso y cantidad de inscriptos hasta la fecha. Realizar un algoritmo que actualice la cantidad de inscriptos en la lista. En caso de que el curso no se encuentra en la lista, corresponde a un nuevo curso abierto y debe ser agregado en la lista, teniendo en cuenta que la lista esta ordenada alfabticamente por nombre de curso. 18. Se tiene una lista simplemente enlazada conteniendo informacin referida a las construcciones de casas y edificios, cada nodo contiene: Nro de expediente de obra, Nombre del propietario, Cant de m2 construidos, Tipo de obra (0: vivienda basica, 1: vivienda lujo, 2: edificio, 3:predio especial), Impuesto a pagar por m2 construido, Zona (0:centro, 1:barrios cercanos, 2: en las afueras). Realizar un algoritmo que genere otra lista conteniendo todos los nodos de la primera en los cuales el impuesto total (cantidad de metros construidos multiplicado por impuesto a pagar por cada metro) sea mayor a x, siendo x un valor ingresado por teclado. La lista debe generarse en forma ordenada por nmero de expediente. 19. Teniendo en cuenta la lista simplemente enlazada del ejercicio anterior, realizar un algoritmo que verifique si existe en la lista un nodo con nmero de expediente igual a ex (ingresado por teclado), en caso de existir, modificar el nombre del propietario, reemplazndolo por uno ingresado por teclado. Si el nmero de expediente ex no existe, se debe insertar en la lista, ingresando todos los datos por teclado. Recordar que la insercin debe ser ordenada.

Gua de Trabajos Prcticos

20. Se cuenta con una lista simplemente enlazada conteniendo informacin sobre las ventas realizadas en un comercio. Cada nodo contiene los siguientes campos: Numero de vendedor que realizo la venta ( un valor entre 0 y 9), cdigo de articulo vendido (un valor entre 0 y 19), descripcin del articulo, cantidad de unidades vendidas y monto de la venta. Realizar un algoritmo que genere una matriz donde cada fila represente un vendedor y cada columna un articulo, y en la que en cada componente se acumule la cantidad de cada articulo que vendi cada vendedor.