Está en la página 1de 67

Informtica II Apuntes de clase

NOTA AL ALUMNO
Este documento es una recopilacin ms o menos completa de los apuntes que utilic para dar clases desde
los aos 2006 al 2010 en la asignatura Informtica II del ciclo comn de Ingeniera de la !"A# $o tiene el
tratamiento formal de los temas que merece% para ello e&isten 'arios li(ros mu) (uenos# *s (ien% es una
transcripcin proli+a del material dictado en aula% con los mismos grficos ,orri(les -,ec,os en .aint a,ora/
que suelo di(u+ar en el pi0arrn#
Espero que les sea de utilidad para la cursada de la materia% ) por a, ,asta sir'e para aprender a
programar1
Ing# 2aniel 3olmirano
4ct# 2010

TABLA DE CONTENIDOS
$ota al alumno ################################################################################################################################################### 1
5a(la de "ontenidos ########################################################################################################################################### 1
16 Arreglos *ultidimensionales ######################################################################################################################### 7
Introduccin ################################################################################################################################################### 7
!so de arreglos multidimensionales ############################################################################################################## 6
26 4peraciones a ni'el de (it ############################################################################################################################## 8
4peradores 9gicos :inarios ########################################################################################################################## 8
"omplemento a ni'el de (it ##################################################################################################################### 10
4peradores de despla0amiento ################################################################################################################### 11
*scaras a ni'el (it ###################################################################################################################################### 12
;6 3tructs -estructuras de datos propiamente dic,as/ #################################################################################### 16
Introduccin ################################################################################################################################################# 16
9a pala(ra reser'ada struct ########################################################################################################################## 1<
.asa+e de parmetros ) de'olucin en funciones ######################################################################################## 1=
Alias de tipos -t)pedef/ ################################################################################################################################# 20
>6 .unteros ####################################################################################################################################################### 21
Informtica II Apuntes de clase

E+ecucin de un programa ############################################################################################################################ 21
.asa+e de .armetros a funciones################################################################################################################ 22
.unteros ####################################################################################################################################################### 2;
Aritmtica de .unteros################################################################################################################################# 26
Arreglos estticos ######################################################################################################################################### 2<
7 6 *ane+o dinmico de memoria #################################################################################################################### 28
3olicitar memoria dinmica funcin malloc-/ ############################################################################################ 28
9i(erar memoria solicitada? free-/ ################################################################################################################ ;1
"am(iar la cantidad de memoria reser'ada? realloc-/ ################################################################################# ;1
6 6 @ecursi'idad ################################################################################################################################################ ;;
Introduccin ################################################################################################################################################# ;;
2efinicin de recursi'idad ############################################################################################################################ ;;
E+emplo de funciones recursi'as? el factorial ############################################################################################### ;>
E+emplo de funcin recursi'a? Encontrar el m&imo en un arreglo ############################################################# ;>
3eguimiento de pila ###################################################################################################################################### ;6
<6 Estructuras dinmicas Aeneralidades ) 9istas ########################################################################################### ;=
Introduccin ################################################################################################################################################# ;=
"onocimientos pre'ios ################################################################################################################################# ;=
9istas ############################################################################################################################################################# ;8
4peraciones############################################################################################################################################## >0
Implementacin de la estructura ############################################################################################################# >0
Implementacin de las operaciones ######################################################################################################### >1
= 6 Estructuras dinmicas .ilas ) "olas ########################################################################################################### >6
Introduccin ################################################################################################################################################# >6
.ilas ############################################################################################################################################################## >6
Especificacin ########################################################################################################################################### ><
Implementacin ####################################################################################################################################### ><
Informtica II Apuntes de clase

"olas ############################################################################################################################################################# >8
Especificacin ########################################################################################################################################### >8
Implementacin ####################################################################################################################################### >8
8 6 Estructuras dinmicas 9istas do(lemente enla0adas ############################################################################### 72
Introduccin ################################################################################################################################################# 72
Especificacin ############################################################################################################################################### 72
Implementacin ########################################################################################################################################### 72
"reacin de un nue'o nodo ##################################################################################################################### 72
Agregar elementos ################################################################################################################################### 7;
Insertar elementos ################################################################################################################################### 7>
Eliminar elementos ################################################################################################################################### 7>
10 6 Estructuras 2inmicas Ar(oles :inarios ################################################################################################# 77
Introduccin ################################################################################################################################################# 77
2efiniciones 'arias ######################################################################################################################################## 76
Ar(oles (inarios de (squeda ###################################################################################################################### 76
4peraciones############################################################################################################################################## 7<
Implementacin ####################################################################################################################################### 7<
@ecorrido de un r(ol ############################################################################################################################### 7=
@ecorrido de un r(ol por ni'eles ############################################################################################################ 78
11 6 *ane+o de Arc,i'os ################################################################################################################################### 61
Introduccin ################################################################################################################################################# 61
5ipos de arc,i'os ########################################################################################################################################## 61
4peraciones en arc,i'os de te&to ############################################################################################################ 62
4peraciones en arc,i'os (inarios ############################################################################################################ 62
Bunciones incorporadas ############################################################################################################################### 62
Apertura de arc,i'os 6 fopen ################################################################################################################### 62
"ierre de arc,i'os 6 fclose ######################################################################################################################## 6>
Informtica II Apuntes de clase

Bin de arc,i'o 6 feof ################################################################################################################################## 6>
Arc,i'os de te&to 6 9ectura ####################################################################################################################### 67
Arc,i'os de te&to 6 Escritura ##################################################################################################################### 67
@esumen de funciones para arc,i'os de te&to######################################################################################### 66
Arc,i'os (inarios 6 9ectura ####################################################################################################################### 66
Arc,i'os (inarios 6 Escritura ##################################################################################################################### 66
@esumen de funciones para arc,i'os (inarios ######################################################################################### 66
4tras funciones de mane+o de arc,i'os ################################################################################################### 6<

Informtica II Apuntes de clase



1- ARREGLOS MULTIDIMENSIONALES

I$5@42!""IC$
3a(emos que un arreglo es una estructura de datos compuesta por una secuencia de tamao fi+o de
elementos del mismo tipo# 2ic,a secuencia posee un nom(re -el nom(re del arreglo/% ) cada elemento
puede ser accedido a tra's de un su(ndice# El rango inferior del su(ndice es 0 ) el superior% $ 61 -siendo $
el tamao del arreglo/#
En la memoria de la computadora% los elementos de un arreglo ocupan posiciones contiguas de la memoria#
3i tenemos un arreglo de enteros% p# e+#? int a[100]D ) aE0F se encuentra en la posicin 0&200% entonces
aE1F se encuentra en 0&20>% aE2F en 0&20=% ) as sucesi'amente -)a que cada entero ocupa > ()tes/#

9os arreglos multidimensionales son estructuras mu) similares a los arreglos% pero que utili0an ms de un
su(ndice para referirse a sus elementos# "ada su(ndice agrega una GdimensinH al arreglo# .or e+emplo%
podemos declarar un arreglo multidimensional de ; & ; -totali0ando 8 elementos/ de la siguiente manera?
int m[3][3];
3u representacin grfica ser?

m[0][0] m[0][1] m[0][2]
m[1][0] m[1][1] m[1][2]
m[2][0] m[2][1] m[2][2]

En el caso de los arreglos de 2 dimensiones% el nom(re ms comn que se les da es el de matrices -dado su
parecido con las matrices de lge(ra/# .odemos pensar que el primer su(ndice define las filas% ) el segundo
su(ndice% las columnas dentro de cada fila#

!n arreglo de ; dimensiones sera similar a un cu(o% con una primera dimensin que defina el GaltoH% una
segunda de Ganc,oH% ) una tercera de GprofundidadH#

Informtica II Apuntes de clase


En un arreglo multidimensional no es posi(le tener filas de diferente longitud% cada una de ellas ser
e&actamente de la longitud definida por la dimensin en el momento de su declaracin#
9os arreglos multidimensionales son utili0ados para representar datos que en la 'ida real se definen en
ta(las de mltiples entradas# Algunos e+emplos?
El pago de e&pensas de un edificio -donde cada fila puede representar un departamento% las
columnas los meses del ao% ) en cada GceldaH podemos ingresar un pago mensual/#
!na lista de asistencia al curso -donde cada fila representa un alumno% cada columna la asistencia a
una clase en particular% ) en cada celda podemos ingresar un 1 si el alumno est presente% o 0 si
est ausente/#

!34 2E A@@EA943 *!95I2I*E$3I4$A9E3

2e(emos distinguir los diferentes momentos en que ,acemos referencias a 'aria(les del tipo arreglo
multidimensional?
Declaracin: se declara el tipo de dato% el nom(re del arreglo ) luego cada una de las dimensiones utili0ando
corc,etes# 2entro de los corc,etes se indica el tamao de esa dimensin en particular# 2e la misma manera
que con los arreglos unidimensionales% el tamao de cada dimensin de(e ser conocido de antemano -)a
sea G,ardcodeandoH el nmero en la declaracin% o utili0ando una constante Idefine/#
Ejemplos:
double temperaturas_del_anio [31][12];
char nombres_equipo [40][11];

Declaracin + inicializacin: podemos declarar e iniciali0ar un arreglo% es decir% lograr que el 'alor de cada
una de sus G'aria(lesH sean conocidos desde el momento en que la 'aria(le se declara# .ara ello utili0amos
la notacin de lla'es# Al igual que en el caso de los arreglos unidimensionales% si declaramos menos datos de
los que componen el arreglo% el resto se rellenar de ceros#
Informtica II Apuntes de clase

// Esto declara un arreglo de 8 x 8 con las 2 primeras filas
// completas, y las restantes con 0.
int tablero[8][8] = {
{2, 3, 4, 5, 10, 4, 3, 2},
{1, 1, 1, 1, 1, 1, 1, 1}};

Acceso a las aria!les: 3e reali0a de la misma manera que con los arreglos unidimensionales# "ada 'aria(le
se referencia por tantos ndices como dimensiones tenga el arreglo# Es posi(le referenciar un Gsu(6arregloH
dentro del arreglo multidimensional utili0ando menos ndices que la cantidad de dimensiones del arreglo#
Esto puede ser til% por e+emplo% para referirse a filas completas dentro de una matri0#
Ejemplo:
// Este programa escribe una "cruz" en una matriz de 10 x 10 y luego la imprime.
#include <stdio.h>
#include <stdlib.h>

void imprime_linea(char[], int);

int main()
{
char figura[10][10];
int f, c;
for (f = 0; f < 10; f++)
{
for (c = 0; c < 10; c++)
{
if (f == c || f == 0 || c == 0 || c == 9 || f == 9 || f + c == 9)
figura [f][c] = '*'; //Seteamos una variable accediendo con sus 2 indices
else
figura [f][c] = ' ';
}
}
for ( f = 0; f < 10; f++)
imprime_linea(figura[f] , 10); //Referenciamos una fila completa de la matriz
return 0;
}

void imprime_linea(char a[], int largo)
{
int i;
for (i = 0; i < largo; i++)
{
printf("%c", a[i]);
}
printf("\n");
}

"asa#e $or $ar%&e'ro a ()nciones: Al momento de utili0ar un arreglo multidimensional como parmetro de
una funcin% de(e tenerse en cuenta que en la declaracin de la funcin es necesario indicar las primeras $6
1 dimensiones del mismo# JKu quiere decir estoL .or e+emplo% si declaramos una funcin para imprimir un
arreglo de ; & ; enteros% entonces su prototipo ser?
void imprimir_matriz(int [][3]);

Informtica II Apuntes de clase

J.or qu ocurre estoL .ara el compilador% un arreglo multidimensional se G'eH en memoria de la misma
manera que un arreglo unidimensional?
1/ En memoria% un arreglo unidimensional se 'e como una secuencia de 'aria(les del mismo tipo% una
despus de la otra# 9a memoria es lineal% cada posicin tiene un nmero asignado ) es seguida por otra# El
programa reser'a una cantidad M de ()tes para cada 'aria(le% esa cantidad depende del tipo de dato de la
'aria(le# As% un arreglo de 10 enteros ocupa 10 & > ()tes N >0 ()tes en memoria#
2/ JKu ocurre con los arreglos multidimensionalesL 2ado que la memoria es lineal -1 dimensin/ ) los
mismos tienen ms de 1 dimensin% lo que ,ace el compilador es GaplanarH las dimensiones% colocando una
fila inmediatamente luego de la otra% tal como se indica en la figura?

"uando referenciamos un arreglo multidimensional dentro de una funcin% el compilador calcula la
Gposicin realH de memoria de cada 'aria(le multiplicando la longitud de la fila & la cantidad de filas )
sumando el despla0amiento de columna -en el caso de ms de 2 dimensiones% el clculo es anlogo%
agregando cada una de las dimensiones/?
Posicin real = longitud de fila x nmero de fila + columna.

En el caso de la figura% si queremos calcular la posicin real de la 'aria(le mE2FE1F% 'eremos que su posicin
dentro del arreglo es 2 & ; O 1 N < -lo cual puede compro(arse en la figura contando en 0 desde la posicin
inicial ) llegando al ndice </#
.ara poder ,acer este clculo% el compilador necesita conocer de antemano el 'alor G;H% es decir el tamao
de las dimensiones so(re la cual se est tra(a+ando#
Informtica II Apuntes de clase



*- O"ERACIONES A NI+EL DE BIT

9as operaciones a ni'el de (it nos permiten manipular los contenidos de 'aria(les de tipo enteras o c,ar% (it
por (it# Esto significa que podemos alterar los contenidos de una 'aria(le pensando en ella como una
secuencia de (its en 'e0 de entenderla como una 'aria(le del tipo de dato correspondiente# .or e+emplo?
char letra = 'a';
9a 'aria(le letra contiene el caracter PaP% pero tam(in podemos 'erla como la secuencia de (its
0 1 1 0 0 0 0 1

.odemos pensar esta secuencia como un arreglo% donde slo podemos ingresar ceros ) unos# .ero% al
contrario de un arreglo regular% no podemos acceder en forma directa a una posicin a tra's de su
su(ndice# .ara poder manipular sus contenidos es que contamos con los operadores a ni'el de (it#
Qa) dos tipos de operadores? los operadores lgicos% ) los operadores de despla0amiento# 9os primeros
permiten operar una o dos 'aria(les del mismo tipo% (it por (it# 9os segundos permiten Rmo'erR los (its de
una 'aria(le ,acia la i0quierda o la derec,a#

4.E@A24@E3 9CAI "43 :I$A@I43
9os operadores lgicos (inarios son ;
, ? A$2 a ni'el (it - ? 4@ inclusi'o a ni'el (it .? 4@ e&clusi'o -M4@/ a ni'el (it

El operador S reci(e dos 'aria(les del mismo tipo -enteros o c,ar/ ) aplica la operacin A$2 (it por
(it% retorna otro 'alor que contiene (it 1 en las columnas donde am(as 'aria(les tienen 1% ) 0 en
otro caso
El operador T aplica la operacin 4@ (it por (it% retorna otro 'alor que contiene (it 1 en las
columnas donde alguna de las 'aria(les tiene un 1% ) 0 en aquellas donde am(as 'aria(les tengan 0#
El operador U aplica la operacin M4@ (it por (it% retorna otro 'alor que contiene (it 1 en aquellas
columnas donde una 'aria(le presenta un 1% ) la otra un 0# 3i aparecen dos 1 o dos 2% el resultado
de dic,a columna ser 0#
Veamos un e+emplo?
Informtica II Apuntes de clase

char l1 = 113; // letra 'q'
char l2 = 122; // letra 'z'

char l3 = l1 & l2;



l3 = l1 | l2;





l3 = l1 ^ l2;
0 1 1 1 0 0 0 1
S
0 1 1 1 1 0 1 0
666666666666666666666666666666666666666666666666666666
0 1 1 1 0 0 0 0

0 1 1 1 0 0 0 1
T
0 1 1 1 1 0 1 0
666666666666666666666666666666666666666666666666666666
0 1 1 1 1 0 1 1


0 1 1 1 0 0 0 1
S
0 1 1 1 1 0 1 0
666666666666666666666666666666666666666666666666666666
0 0 0 0 1 0 1 1


En los e+emplos% pensar Gqu letraH representa la 'aria(le l; luego de reali0ar las operaciones A$2% 4@ )
M4@% no tiene sentido% )a que estamos considerando su representacin interna (it por (it% ) no el 'alor A3"II
resultante#

"4*.9E*E$54 A $I VE9 2E :I5
Binalmente% e&iste un cuarto operador que no es (inario sino unario# 2ada una 'aria(le% retorna el resultado
de negar cada uno de sus (its# Este operador es W
char l1 = 122;
char l2 = ~l1;

W
0 1 1 1 1 0 1 0
Informtica II Apuntes de clase

666666666666666666666666666666666666666666666666666
1 0 0 0 0 1 0 1


4.E@A24@E3 2E 2E3.9AXA*IE$54
9os operadores de despla0amiento son 2?
YY ? s,ift i0quierdo a ni'el de (its
ZZ ? s,ift derec,o a ni'el de (its

Am(os operadores mue'en los (its del operando de la i0quierda% tantas 'eces como indique el operando de
la derec,a -dic,o 'alor de(e ser positi'o/# El operador de s,ift i0quierdo RrellenaR con ceros los (its
despla0ados# El operador de s,ift derec,o RrellenaR los (its despla0ados con el contenido del primer (it para
as preser'ar el signo de la 'aria(le#


char x = 65;
char y = x << 3;


0 1 0 0 0 0 0 1
YY ;
6666666666666666666666666666666666666666666666666666
0 0 0 0 1 0 0 0



En este caso los ; (its de la i0quierda se RpierdenR de(ido al despla0amiento ,acia la i0quierda#

char x = 97;
x = x >> 2;


0 1 1 0 0 0 0 1
ZZ 2
6666666666666666666666666666666666666666666666666666
X X 0 1 1 0 0 0


Informtica II Apuntes de clase


En este caso los 2 (its de la derec,a se RpierdenR de(ido al despla0amiento# .onemos una R&R en 'e0 de un
nmero en los primeros dos (its% )a que usualmente no podemos afirmar qu 'alor qued copiado#
.odemos pensar que el operador de despla0amiento i0quierdo x << n multiplica & por 2
n
# Anlogamente%
x>>n % cuando la 'aria(le tiene signo positi'o% reali0a una di'isin entera por 2#

*[3"A@A3 A $IVE9 :I5

2e(ido a que los (its de una 'aria(le slo pueden ser accedidos a tra's de los operadores descriptos
anteriormente% es necesario reali0ar algunos pasos adicionales si queremos modificar un cierto (it en una
'aria(le sin cam(iar el resto# En este sentido% es normal RencenderR (its -ponerlos en 1/% siendo la operacin
contraria un poco menos frecuente#
!saremos mscaras para RencenderR (its en una 'aria(le% o para detectar si un (it tiene un 'alor dado# !na
mscara es una constante en la cual slo algunos (its estn RprendidosR o puestos en 1% ) los dems se
mantienen en 0# "om(inando una mscara con una 'aria(le% 'amos a poder encender o apagar (its% )
detectar qu (its estn en 1#

.ara poder poner un cierto (it en 1 en una 'aria(le% lo que ,aremos es reali0ar un 4@ (inario con una
mscara que tenga ese (it en 1# .or e+emplo?
Informtica II Apuntes de clase



#define MASK1 1
#define MASK2 (1<<12)

int x = 32;
int y = 123;

x = x | MASK1;





y = y | MASK2;

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0
T
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 1 1
T
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0
6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 1 1 0 1 1


9a mscara no tiene por qu estar compuesta nicamente por un solo (it a 1D es posi(le tener mscaras con
ma)or cantidad de (its a 1#
Informtica II Apuntes de clase



.ara poder sa(er si una 'aria(le tiene un cierto (it en 1% lo que ,aremos es reali0ar un A$2 (inario con una
mscara que tenga ese (it en 1# .or e+emplo?

#define MASK1 1
int x = 65;
if (x & MASK1)
printf("La variable
x contiene un 1 en el
primer bit\n");

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1
S
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1



Anlogamente% es posi(le usar mscaras compuestas para descu(rir 'arios (its al mismo tiempo#
#define MASK1 7
int x = 123;
int y = x & MASK1;
printf("%d", y);

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 1 1
S
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1
6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1



Informtica II Apuntes de clase

Binalmente% es posi(le alterar el contenido de un (it -lle'arlo a 1 si est en 0% ) 'ice'ersa/% aplicando un M4@
con una mscara que tenga dic,o (it a 1# 3i en la posicin correspondiente a la mscara ,a(a un 1% el M4@ lo
transformar en un 0# 3i% al contrario% ,a(a un 0% 0 M4@ 1N 1#
Informtica II Apuntes de clase


/- STRUCTS 0ESTRUCTURAS DE DATOS "RO"IAMENTE DIC1AS2
I$5@42!""IC$
Al ,a(lar de arreglos ) matrices introdu+imos el concepto de Gestructura de datosH# !na estructura de datos
es un con+unto de datos agrupados por algn moti'o% con una cierta organi0acin interna# Qa) diferentes
moti'os por el cual es con'eniente tra(a+ar 'arios 'alores de datos como si fueran uno solo?
A ni'el operati'o% simplificar la manipulacin de 'alores% tra(a+ando con un solo 'alor compuesto
en 'e0 de 'arios 'alores simples#
A ni'el conceptual% agrupar en una nica 'aria(le los diferentes datos que se refieren a una misma
idea#
Arreglos ) matrices son e+emplos de estructuras de datos incorporadas en el lengua+e "# "on ellas podemos
modelar secuencias de datos del mismo tipo -tanto lineales como n6dimensionales/# 5ericamente sera
posi(le utili0ar arreglos para manipular entidades conceptuales ms comple+as% acordando% p#e+#% que cada
posicin se refiere a algn dato del cual queremos ,a(lar% ) utili0ando ndices correspondientes en
diferentes arreglos para Glin\earH datos que estn relacionados# Esta manera de tra(a+ar es comple+a )
tiende a producir errores rpidamente#
El lengua+e " -) la ma)ora de los denominados lengua+es GestructuradosH/ nos da la posi(ilidad de definir
nuestras propias estructuras de datos# Al ,acerlo podemos representar a(stracciones conceptuales de
datos -e'entualmente definir nuestros propios tipos de datos/% que nos permiten tra(a+ar muc,o ms
fcilmente con representaciones comple+as de la realidad#
Veamos un ejemplo:
.ara representar un punto en el espacio @
;
% utili0amos sus ; coordenadas en los e+es cartesianos?
.1 N -2% ;% 0/ .2 N -1%62% 7/
JKu opciones conocemos para representar en el lengua+e " un punto en @
;
L
!tili0ar ; 'aria(les -double x, y, z;/# 3i necesitamos definir 2 puntos % utili0amos 6 'aria(les%
) as sucesi'amente#
!tili0ar un arreglo de longitud ; ) con'enir que la posicin 0 corresponde a &% la 1 a ) ) la 2 a 0
-double punto[3]/# 3i necesitamos definir mltiples puntos% podemos usar o (ien una matri0%
o podemos usar un arreglo de longitud ;]$% donde las ; primeras posiciones son para el primer
punto% las otras ; para el siguiente% etc#
$inguno de las dos soluciones representa fielmente lo que queremos modelar? que un punto en el espacio
se representa mediante ; coordenadas% llamadas &% ) ) 0#
Informtica II Apuntes de clase



9A .A9A:@A @E3E@VA2A 35@!"5
9a pala(ra reser'ada struct es utili0ada para definir nuestras propias estructuras de datos# "uando
definimos una estructura de datos% estamos indicndole al lengua+e cmo se organi0arn los datos en
memoria cuando utilicemos dic,as estructuras# 9a sinta&is es?

struct <nombre>
{
[miembros];
};

@etomando el e+emplo anterior?
struct s_punto
{
double x;
double y;
double z;
};

El cdigo escrito ms arri(a sir'e para definir una estructura de datos llamada struct s_punto# 2ic,a
estructura tiene ; miem(ros o componentes del tipo double% llamados x% y ) z# "uando ,agamos
referencia a una 'aria(le de tipo struct s_punto% estaremos ,a(lando de una 'aria(le que
internamente contiene esos ; componentes# Anlogamente al uso que ,acemos de su(ndices cuando
tra(a+amos con arreglos% aqu utili0aremos los nom(res de los componentes para referirnos a cada parte
indi'idual de una 'aria(le de tipo struct s_punto# .ara acceder a cada componente utili0amos el
operador . -el punto/#
#include <stdio.h>

struct s_punto
{
double x;
double y;
double z;
};

int main()
{
struct s_punto p1, p2;
p1.x = 2.1;
p1.y = 3;
p1.z = 0;

Informtica II Apuntes de clase

scanf("%lf", &p2.x);
scanf("%lf", &p2.y);
scanf("%lf", &p2.z);

p1.x = p1.x + p2.x;
p1.y = p1.y + p2.y;
p1.z = p1.z + p2.z;

printf("\n P1(x,y,z) = (%.2lf, %.2lf, %.2lf)\n", p1.x, p1.y, p1.z);
return 0;
}

9as estructuras se definen luego de las directi'as de preprocesador pero antes de los prototipos de
funciones% de manera que el compilador las recono0ca en el resto del programa# "uando definimos una
estructura% no estamos ocupando ningn espacio en memoria% simplemente estamos indicando que desde
ese lugar en adelante% cada 'e0 que ,agamos referencia a un 'alor del tipo del struct% en realidad estamos
,a(lando de la totalidad de los datos que representa# 9uego% cada 'e0 que declaremos una 'aria(le del tipo
del struct% ocuparemos tanta memoria como miem(ros tenga el struct#
En el e+emplo dado anteriormente 'emos que para poder GllenarH una 'aria(le del tipo struct
s_punto% de(emos referenciar sus componentes uno por uno -)a que la funcin scanf() no sa(ra como
completar los ; datos simultneamente/# El operador punto nos permite acceder a las componentes
internas de una 'aria(le struct# En el caso de la impresin utili0ando printf-/% ocurre lo mismo% de(emos
tra(a+ar con la 'aria(le struct componente por componente#
Al momento de definir una estructura de datos% no estamos limitados a utili0ar componentes de tipos de
datos simples -los definidos por el lengua+e/? podemos utili0ar arreglos e incluso otras estructuras#
.or e+emplo% si queremos representar empleados de una empresa% de cada uno de los cuales nos importa
su lega+o% nom(re% su apellido% su fec,a de nacimiento ) su fec,a de ingreso a la compaa% podemos utili0ar
las siguientes estructuras?
struct s_fecha
{
int dia, mes, anio;
};

struct s_empleado
{
int legajo;
char nombre[40];
char apellido[50];
struct s_fecha fecha_nac;
struct s_fecha fecha_ing;
};

.A3A^E 2E .A@[*E5@43 _ 2EV49!"IC$ E$ B!$"I4$E3
Informtica II Apuntes de clase

Es posi(le tanto pasar estructuras como parmetros a funciones% como retornar estructuras como resultado
de in'ocacin a una funcin# 2e(e tenerse en cuenta que cuando pasamos una estructura como parmetro
a una funcin% la misma se comporta como si fuera una 'aria(le de tipo de dato simpleD es decir% que se
copiarn los datos al espacio de memoria de la funcin% ) la 'aria(le original no se 'er modificada si
llegamos a cam(iar algo dentro de la funcin#
Vol'iendo al e+emplo del punto% podramos definir las siguientes funciones?
!na funcin que retorne un punto cargado por el usuario#
!na funcin que imprima los contenidos de un punto por pantalla#

#include <stdio.h>

struct s_punto
{
double x;
double y;
double z;
};

struct s_punto cargar_punto(void);
void imprimir_punto(struct s_punto);

int main()
{
struct s_punto p1, p2;
p1 = cargar_punto();
p2 = cargar_punto();

p1.x = p1.x + p2.x;
p1.y = p1.y + p2.y;
p1.z = p1.z + p2.z;

printf("\n P1");
imprimir_punto(p1);
return 0;
}

struct s_punto cargar_punto(void)
{
struct s_punto resultado = { 0, 0, 0 };
scanf("%lf", &resultado.x);
scanf("%lf", &resultado.y);
scanf("%lf", &resultado.z);
return resultado;
}

void imprimir_punto(struct s_punto punto)
{
printf("(x,y,z) = (%.2lf, %.2lf, %.2lf)\n", punto.x, punto.y, punto.z);
}
Informtica II Apuntes de clase



A9I A3 2E 5I.43 -5_.E2EB/
El lengua+e " pro'ee un mecanismo que nos permite definir Galias de tiposH# !n alias de tipo no es otra cosa
que un sinnimo para referirnos a un tipo )a e&istente# .odemos utili0arlo para referirnos ms (re'emente a
tipos de datos struct# 9a sinta&is es

typedef <un tipo de datos> <su alias>;


#include <stdio.h>

struct s_punto
{
double x;
double y;
double z;
};

typedef struct s_punto Punto;

Punto cargar_punto(void);
void imprimir_punto(Punto);

int main()
{
Punto p1, p2;
p1 = cargar_punto();
p2 = cargar_punto();
`


Informtica II Apuntes de clase


3- "UNTEROS
9os conceptos de punteros ) memoria dinmica estn ntimamente relacionados con la estructura en
memoria de un programa e+ecutndose# .ara poder entenderlos% de(emos conocer algo respecto a cmo
un programa se e+ecuta en la computadora#

E^E"!"IC$ 2E !$ .@4A@A*A
!na 'e0 que un programa es compilado por el compilador de nuestra eleccin% se o(tiene cdigo mquina%
capa0 de ser cargado ) e+ecutado por el 3istema 4perati'o# Es l quien se encarga de gestionar la forma en
que el proceso -proceso N programa en e+ecucin/ 'a a poder acceder a los diferentes recursos de ,ardaare#
.ara gestionar el acceso a memoria asignada al proceso% se la di'ide en ; 0onas? la 0ona de datos -para
'aria(les glo(ales ) constantes/% el stac\ o memoria esttica% ) el ,eap o memoria dinmica# El stac\ se
denomina as porque su comportamiento es similar al de una pila? cada nue'o requerimiento de memoria se
u(ica por encima del anterior -se apila/% ) al finali0ar% se quita o desapila# "uando el programa es cargado% el
3#4# (usca una 0ona de memoria li(re para este nue'o proceso# "ada funcin que se e+ecuta -empe0ando
por el main/ se carga en el stac\# _a que para cada funcin ,emos declarado las 'aria(les ) su tipo% el 3#4#
sa(e cunto espacio en memoria se necesita# "uando desde el main se in'oca una funcin% se reser'a
memoria en el stac\% tanto para los parmetros como para las 'aria(les de la funcin% ) tam(in para el
'alor de retorno de la funcin# 3i esta funcin llama a otra% se sigue apilando memoria% ) as sucesi'amente#
"uando la funcin retorna% el espacio en memoria se desapila -en la prctica% lo nico que se ,ace es G(a+arH
el cursor que indica el tope de la pila a la posicin en que se encontra(a antes de e+ecutar la funcin/#

Informtica II Apuntes de clase

.or supuesto el stac\ tiene un espacio finito? es posi(le generar% mediante muc,as llamadas sucesi'as% una
condicin denominada Gstac\ o'erfloaH o so(repasamiento de pila% en la cual el proceso finali0a
a(ruptamente#
.A3A^E 2E .A@[*E5@43 A B!$"I4$E3
"uando se in'oca una funcin% adems del espacio necesario para las 'aria(les locales de la funcin% se
reser'a espacio para los parmetros con los que la funcin es in'ocada# 9os 'alores con los que la funcin se
e+ecuta son copiados desde la funcin llamadora# 2entro del m(ito de e+ecucin de la funcin% es posi(le
reasignar 'alores a los parmetros% pero estos cam(ios siempre son locales% )a que los parmetros fueron
copiados#


2ic,o esto% est claro que una funcin no puede modificar el 'alor de las 'aria(les que reci(e# 3in em(argo%
sa(emos que esto no es necesariamente cierto# Aprendimos anteriormente que si pasamos un arreglo por
parmetro% sus 'alores pueden ser cam(iados# 5am(in es posi(le in'ocar la funcin scanf-/ ) lograr el
mismo efecto?
Informtica II Apuntes de clase


JKu ocurre en estos casosL 3i nos fi+amos en el e+emplo% estamos pasando 2 parmetros a scanf-/? una
cadena de te&to ) una 'aria(le entera G+H# .ero la 'aria(le + tiene un signo S delante# Este operador -llamado
Goperador de referenciaH/ nos permite o(tener un $)n'ero a la 'aria(le +#

.!$5E@43
JKu es un punteroL Es una referencia a una 'aria(le% o dic,o de otra manera% una 'aria(le que contiene un
'alor? la direccin de memoria de otra 'aria(le#
3i pensamos que una 'aria(le es una Gca+aH donde podemos almacenar informacin% un puntero puede
pensarse como un G'aleH que dice G'ale por esa ca+aH# El G'aleH contiene informacin% pero su informacin
no es la 'aria(le en s% sino dnde se encuentra sta#
Al pasar un puntero como parmetro a una funcin% o(tenemos un (eneficio? le estamos Gdando permisoH
para que cam(ie los contenidos de la 'aria(le original# Esto se logra reali0ando la operacin complementaria
Informtica II Apuntes de clase

a referenciar? desferenciar o indireccionar un puntero
1
# JKu significa desreferenciar un punteroL
:sicamente es reali0ar la operacin in'ersa a referenciar? tomamos un puntero% le aplicamos el operador
apropiado% ) o(tenemos la 'aria(le a la que ,ace referencia# Al en'iar un puntero como parmetro a una
funcin% ) an cuando se copia el contenido del puntero% al desreferenciarlo ganamos acceso a la 'aria(le
original# 9uego% podemos modificar sus contenidos% aunque la 'aria(le se encuentre en el espacio de
memoria que no es el propio de la funcin#
Veamos un e+emplo?


En este e+emplo podemos identificar lo siguiente?
"ada 'aria(le se encuentra en una posicin de memoria#
Al in'ocar la funcin fun-/% copiamos el contenido del puntero a un nue'o espacio en memoria%
propio de la funcin# El contenido del puntero es la direccin de memoria donde se encuentra la
'aria(le +#
2eclaracin de 'aria(les? ll tipo de dato para una 'aria(le del tipo puntero se escri(e
tipo_de_dato_del_puntero nom!re_"aria!le# % si (ien todos los punteros se refieren a posiciones

1
$inguna de estas pala(ras e&iste en espaol pero a los efectos prcticos podemos usarlas para indicar esta
operacin#
Informtica II Apuntes de clase

de memoria -por lo tanto un puntero a c,ar o un puntero a int GmidenH lo mismo/% es necesario
aclarar el tipo de dato de la 'aria(le a la que se ,ace referencia#
.ara usar un puntero de(emos GsacarloH de una 'aria(le )a e&istente% para eso usamos el operador
de referencia# 3i declaramos un puntero ) no le asignamos nada% ese puntero ,ar referencia a
posiciones de memoria fuera de la memoria que el programa tiene asignado% ) pro(a(lemente
fallar su e+ecucin#
.ara o(tener la 'aria(le original a la que ,ace referencia un puntero% lo desreferenciamos con el
operador asterisco# 5anto S como ] son operadores unariosD se ponen delante de la 'aria(le ) de
esa manera o(tenemos el puntero - S'aria(le 6Z puntero/ o la 'aria(le -]puntero 6Z 'aria(le/#
Veamos otro e+emplo# En este caso% declaramos un puntero como una 'aria(le ms?
#include <stdio.h>
int main()
{
int i = 0, j = 0;
int *p1, *p2;

p1 = &i;
p2 = &j;
scanf("%d", p1);
scanf("%d", &j);

printf("i: %2d - j: %2d\n", i, j);
p2 = p1;
(*p2)++;
printf("i: %2d - j: %2d\n", i, j);
return 0;
}

En el e+emplo anterior% ,acemos que p1 apunte a i% ) que p2 apunte a j# En las lneas en las que reci(imos
datos por teclado% 'emos que es lo mismo en'iar p1/&i% o p2/&j. 9uego del printf() cam(iamos el
puntero p2 de lugar% lo ,acemos apuntar al lugar donde est apuntando p1# Binalmente desreferenciar p2
) e+ecutar el postincremento% estamos afectando la 'aria(le i#
5ener en cuenta las siguientes consideraciones?
!n puntero sin asignar puede ,acer que un programa de+e de e+ecutarse al tratar de leerbescri(ir
de posiciones de memoria no 'lidas#
$o es necesario declarar una 'aria(le de tipo puntero% podemos utili0ar el operador S ) GgenerarH
una cuando necesitemos pasar un puntero como parmetro#
9a precedencia de operadores suele complicar las cosas? es recomenda(le escri(ir las operaciones
de referencia ) desreferencia entre parntesis% ,asta sa(er (ien en qu momento ,acen falta )
cundo no# .or e+emplo% si quitamos los parntesis en el cdigo de arri(a% se aplicara primero el
postincremento ) luego el operador de desreferencia% creando un cdigo que no ,ace nada#
9os punteros no son otra cosa que 'alores enteros# .ero no es aconse+a(le tratarlos como tales%
prestar muc,a atencin a los mensa+es que genera el compilador para 'erificar que estamos
Informtica II Apuntes de clase

tra(a+ando con los tipos correctos# !n error de asignacin entre punteros ) enteros 'a a compilar
con GaarningsH% pero no da error# El error se produce al momento de e+ecutar el programa#
A@I5*c5I"A 2E .!$5E@43
Es posi(le utili0ar los operadores O ) con punteros# 9as siguientes operaciones tienen sentido?
3umarle o restarle un nmero n a un puntero? el resultado es otro puntero despla0ado -n
()tes & el tamao del tipo de dato/ respecto al original# .or e+emplo% si tenemos un puntero a char
) le sumamos 1% o(tenemos un puntero a la siguiente posicin en memoria desde la u(icacin de la
'aria(le char#
@estar dos punteros? o(tendremos la diferencia de posicin entre los 2 punteros#
Al utili0ar el operador de suma ) resta de enteros% tiene importancia el tipo de dato con el que
estamos tra(a+ando?
o 3i sumamos 1 a un puntero a entero% o(tendremos una direccin de memoria > ()tes
ma)or a la direccin original#
o 3i sumamos 1 a un puntero a c,ar% o(tendremos una direccin de memoria 1 ()te ma)or a
la direccin original#
$o se puede suponer que si ,a) dos 'aria(les del mismo tipo declaradas en forma contigua% al
sumar 1 a un puntero a la primera se o(tendr la segunda#
.ara imprimir punteros% podemos usar GdpH# Al ,acerlo as o(tendremos la direccin de memoria a
la que referencia el puntero% en cdigo ,e&adecimal#
E+emplos?
#include <stdio.h>
int main()
{
int i;
int a[10] = {1,2,3,4,5,6,7,8,9,10};
int *p1, *p2;
char c1 = 'a';
char c2 = 'b';
char *pc;

p1 = &a[0];
p2 = &a[7];
printf("Numeros en un arreglo: %p: %d - %p: %d - Dif: %d \n",
p1, *p1, p2, *p2, p2 - p1);

pc = &c1;
printf("Caracteres sueltos: %p: %c - %p(%p): %c \n", pc, c1,
pc+1, &c2, c2 );

*(p1 + 3) = 200;
*(p2 - 1) = 50;

for (i = 0; i < 10; i++)
printf("%p: %d\n", &a[i], a[i]);
Informtica II Apuntes de clase

return 0;
}


Numeros en un arreglo: 0028FF00: 1 - 0028FF1C: 8 - Dif: 7
Caracteres sueltos: 0028FEF7: a - 0028FEF8(0028FEF6): b
0028FF00: 1
0028FF04: 2
0028FF08: 3
0028FF0C: 200
0028FF10: 5
0028FF14: 6
0028FF18: 50
0028FF1C: 8
0028FF20: 9
0028FF24: 10

Process returned 0 (0x0) execution time : 0.014 s
Press any key to continue.


En el primer printf()% estamos imprimiendo la direccin de memoria del primer puntero% su
contenido% la direccin de memoria del segundo puntero% su contenido% ) la diferencia en ()tes
entre ellos#
En el segundo printf(), podemos 'er que si (ien pc apunta a c1% pcO1 no apunta a c2D al
contrario% el programa c2 est Gms a(a+oH que c1# 5am(in 'emos que las sumas producen
aumentos de a 1 ()te% en el caso de los punteros a enteros% son de >#
El loop de impresin del arreglo muestra que se puede sumar ) restar en forma segura dentro de
los lmites de un arreglo% ) modificar los contenidos del mismo#

A@@EA943 E35[5I"43
"uando tra(a+amos con arreglos% estamos tra(a+ando en forma indirecta con punteros# Al momento de
declararlo% el nom(re del arreglo puede ser pensado como un puntero a la primera posicin del mismo#
9a sinta&is int arreglo[10]; es una forma de declarar un puntero a entero ) al mismo
tiempo apuntarlo a la primera de 10 posiciones en memoria de tipo entero que se reser'an en el
stac\#
9as funciones no pueden declarar el tamao de los arreglos que reci(en% )a que en realidad lo que
estn reci(iendo son punteros# Al momento de declarar un prototipo de funcin% es indistinto usar
EF o ] #
E+emplo?
Informtica II Apuntes de clase

#include <stdio.h>

int fun(int*);
char fun2(char*);

int main()
{
char frase[25] = "hola mundo";
//es posible declarar char* frase = "hola mundo"; pero el
arreglo
//resultante es "esttico", es decir que si tratamos de
ejecutar
//fun2 sobre el mismo, el programa termina con error.
//Esto solo puede hacerse con chars, los arreglos de otros
tipos
//se deben declarar con corchetes.
int arreglo[10] = {1,2,3,4,5,6,7,8,9,10};
int a;
char c;

a = fun(arreglo);
c = fun2(frase);

printf("%d %c \n", a, c);
return 0;

}

int fun(int * puntero)
{
if (*(puntero + 3) > puntero[4])
{
return 0;
}
else
{
return 1;
}
}

char fun2(char* s)
{
s[4] = *(s+1) + (s[2] - s[3]);
return s[4];
}

Informtica II Apuntes de clase



4 - MANE5O DIN6MI CO DE MEMORIA
3a(emos que la gestin de memoria de un programa escrito en el lengua+e " reconoce ; reas? el stac\ o
pila% donde se almacena el espacio para las 'aria(les declaradas en el main-/ ) en el cuerpo de cada funcin%
la regin esttica% donde se guardan 'aria(les glo(ales ) constantes% ) el ,eap o rea dinmica# A diferencia
del stac\% donde se conoce en cada momento cunta memoria es necesaria para e+ecutar cada funcin% la
memoria en el ,eap es otorgada en forma dinmica? e&isten instrucciones que nos permiten pedir memoria%
) li(erarla cuando )a no la necesitamos#
J.ara qu podemos utili0ar el rea de memoria dinmicaL :sicamente para cualquier procedimiento en el
cual descono0camos de antemano la cantidad de datos con los que 'amos a estar tra(a+ando? por e+emplo si
tenemos que almacenar informacin cargada por teclado% sin un lmite m&imo conocido% o si tenemos que
procesar un arc,i'o cu)o tamao desconocemos% etc# 2e esta manera e'itaremos declarar estructuras
innecesariamente grandes% ) apro'ec,ar me+or los recursos de los cuales disponemos# "omo mencionamos
anteriormente% la memoria disponi(le en el stac\ es limitadaD la memoria del ,eap no sufre de tantas
restricciones# 3in em(argo% al ser un rea que es compartida con otros procesos que pueden correr al mismo
tiempo% de(emos ser cuidadosos a la ,ora de solicitarla% ) retornarla al sistema lo antes posi(le% de manera
de no ocupar recursos cuando no los necesitamos#
Ejemplo:
3upongamos que queremos reali0ar un programa que ordene una secuencia de nmeros ingresada por
teclado# Qasta este momento la nica manera que podemos ,acer esto es declarar un arreglo de un tamao
m&imo -$ N 100 & e+emplo/% ) marcar con alguna (andera el fin de los 'alores 'lidos# Esta manera de
resol'er el pro(lema tiene dos incon'enientes?
El programa no puede procesar ms de $ elementos#
3i los datos a ingresar son slo 10% estamos desperdiciando 80 espacios en memoria#
3i (ien la prdida de memoria en el e+emplo es nfima% en una escala ma)or de procesamiento de datos esta
decisin puede conducir a fallas por falta de memoria# .ara e'itar este pro(lema% recurriremos al rea de
memoria dinmica para almacenar los datos# 3lo usaremos la cantidad de memoria que necesitemos% )
luego de usarla la li(eraremos para posterior reuso#
349I"I5A@ *E*4@I A 2I$[*I "A B!$"IC$ *A994"-/
.ara solicitar un (loque de memoria del ,eap usamos la funcin malloc-/# 9a in'ocacin a la funcin retorna
un puntero al nue'o (loque% por lo cual usaremos una 'aria(le de tipo puntero para sa(er dnde se
encuentra el (loque#
El prototipo de la funcin malloc es el siguiente? void* malloc(size_t)D
JKu significa cada parteL
Informtica II Apuntes de clase

'oid] es un tipo de retorno Gpuntero genricoH? la funcin malloc-/ puede retornar un puntero a
memoria almacenada de cualquier tipo? esta es la forma que tiene el lengua+e de indicarlo
malloc es el nom(re de la funcin% reci(e como parmetro la cantidad de ()tes que queremos
reser'ar#
si0eet es un t)pedef para 'alores long unsigned int# 9o que significa que podemos pasar cualquier
'alor numrico entero positi'o#
J"mo utili0amos la funcin malloc-/L 9o ms comn es declarar un puntero a entero ) asignar el puntero
que retorna malloc-/ a este puntero#
#include <stdio.h>
#include <stdlib.h>

int main()
{
int i, n;
int *arreglo = NULL;
printf("Indique la cantidad de datos a ingresar: ");
scanf("%d", &n);
arreglo = (int *) malloc(n * sizeof(int));
for (i = 0; i < n; i++)
{
printf("Ingreso de dato %d", i+1);
scanf("%d", (arreglo + i));
}
return 0;
}

$!ser"aciones:
9as ltimas 'ersiones de los compiladores de " detectan automticamente el tipo de puntero que
se est asignando% pero anteriormente era norma GcastearH el puntero al tipo correcto# .or
e+emplo? int* arreglo = (int*) malloc(10 * sizeof(int));
9os punteros se iniciali0an a $!99 de manera que estn con un 'alor inicial conocido# $!99 equi'ale
,a(itualmente al 'alor 0#
.ara calcular la cantidad de ()tes que necesitamos reser'ar en el ,eap% multiplicamos la cantidad
de 'alores que queremos reser'ar ] si0eof-tipo de dato/#
3i se reser'a ms de un espacio de memoria% entonces estamos tra(a+ando con un arreglo
GdinmicoH# .or lo tanto% es posi(le usar la notacin de corc,etes EF para acceder a sus miem(ros#
Es posi(le que el pedido de memoria falle -por e+emplo% si solicitamos ms memoria que la que el
sistema tiene disponi(le para nuestro proceso/# En ese caso% malloc-/ retorna $!99# En la prctica
-so(re todo en esta materia/ es poco comn que dic,a situacin ocurra% pero es o(ligacin 'erificar
que el malloc no ,a)a fallado% con un if a continuacin del llamado a malloc# En algunos e+emplos
de este apunte se omite dic,a 'erificacin% con el espritu de mantener los e+emplos sencillos% pero
recuerde que el alumno est o(ligado a ,acerlo en los e+ercicios#

Informtica II Apuntes de clase

9I:E@A@ *E*4@IA 349I "I5A2A? B@EE-/
El pedido de memoria reali0ado con malloc-/ se acompaa de su operacin complementaria? li(erar la
memoria que el sistema entrega para que el mismo proceso% ms adelante% o incluso otros procesos% puedan
apro'ec,ar dic,a memoria# 9a norma es li(erar la memoria en el momento en el cual de+a de necesitarse# 3i
la memoria no es li(erada en forma e&plcita% el sistema se encarga de ello al finali0ar el proceso#
El prototipo de la funcin es? void free(void*):
El parmetro que se le en'a a free-/ es un puntero entregado por malloc-/ -o realloc-/% de la cual
,a(laremos ms adelante/#
Es imposi(le li(erar memoria del stac\% slo puede li(erarse memoria del ,eap# 4 sea no tiene
sentido ,acer free-/ de un arreglo declarado con la notacin de corc,etes#
$o es posi(le li(erar una GparteH de la memoria que se solicit% free-/ reci(e como parmetro un
'alor que ,a sido entregado anteriormente por malloc-/ -internamente% el programa mantiene una
ta(la de la memoria pedida% entonces cuando le pedimos que li(ere un cierto puntero% (usca ese
dato en la ta(laD por lo cual slo esos 'alores pueden ser li(erados/#
El e+emplo anterior se completa agregando la lnea Gfree-arreglo/DH% una 'e0 que )a no necesitemos el
mismo#
$!ser"aciones:
Es posi(le programar funciones que soliciten un espacio en memoria ) que sea responsa(ilidad de
la funcin llamadora li(erar el espacio posteriormente# *uc,as de las funciones de la (i(lioteca
Ystring#,Z utili0an esta modalidad#
Es una mala prctica de programacin no GlimpiarH la memoria que no requerimos# 2e(ido a la
comple+idad relacionada con la gestin manual de memoria% lengua+es de programacin posteriores
a la in'encin de " ,an ,ec,o automtico dic,o mane+o -tanto la solicitud como su posterior
li(eracin% a tra's de algoritmos denominados Aar(age "ollectors/#

"A*:IA@ 9A "A$5I2A2 2E *E*4@IA @E3E@VA2A? @EA994"-/
$o siempre necesitamos el (loque de memoria que solicitamos la primera 'e0? a 'eces podemos requerir
ma)or cantidad% ) en otras ocasiones% es posi(le que de(amos de'ol'er parte de la memoria pedida porque
no la 'amos a utili0ar# 9a funcin realloc-/ permite modificar la cantidad de memoria pedida#
El prototipo de la funcin es? void* realloc(void*, size_t); donde?
9a funcin retorna un nue'o puntero a la memoria realocada# Es posi(le que al pedir ms -o menos/
memoria% el sistema decida u(icar la memoria en otra posicin -de manera de apro'ec,ar me+or los
espacios que se 'an generando/# "uando esto ocurre% todos los contenidos originales se copian a la
nue'a posicin% ) sta es retornada#
El primer parmetro es el puntero original -pedido con malloc-/ o con un realloc-/ anterior/#
El segundo parmetro es el nue'o tamao que ocupa la memoria? podemos pedir ms% o menos# En
el primer caso nuestra memoria se ampla al nue'o tamao -p#e+#% si originalmente pedimos 10
Informtica II Apuntes de clase

espacios ) luego pedimos 1>% se agregarn > espacios/% ) en el segundo% se ac,ica -si tenamos 10
espacios ) pedimos 7% se eliminarn los ltimos 7/#
E+emplo? si queremos crear un arreglo de enteros donde slo ocupemos la memoria mnima necesaria%
podemos ir pidiendo de a 1 lugar?

#include <stdio.h>
#include <stdlib.h>

int main()
{
int i = 0, n, ocupado = 5;
int *arreglo = (int *)malloc( 5 * sizeof(int) );
printf("Agregue datos, finalice con 0: ");
do
{
scanf("%d", &n);
if (n != 0)
{
*(arreglo + i ) = n;
i++;
if (i >= ocupado)
{
arreglo = realloc(arreglo, (i + 1) * sizeof(int));
ocupado = i;
}
}
} while( n != 0);

printf("Memoria ocupada: %d\n", ocupado);
free(arreglo);
return 0;
}


En el e+emplo anterior% si usamos menos de 7 espacios en memoria% la memoria asignada ser ma)or a la
usada# J"mo podra arreglarseL
Informtica II Apuntes de clase


7 - RECURSI +IDAD
I$5@42!""IC$
Imaginemos por un momento que nos encontramos frente a una fila de gente# $o podemos 'er dnde
termina la fila% ni sa(emos cuntas personas ,a) en ella# 5an slo podemos 'er ) ,a(lar con la primer
persona# Ella% a su 'e0% puede darse 'uelta ) ,a(lar con quien tiene inmediatamente detrs# Kueremos sa(er
quin es la persona que tiene el nmero de documento ma)or# J2e qu manera podemos resol'er el
pro(lemaL
!na solucin a nuestro pro(lema consiste en preguntarle a la persona que tenemos detrs cul es su
nmero de documento% ) compararlo con el nuestro# 2e esta comparacin podemos o(tener el ma)or
nmero de documento entre am(o# A continuacin% la persona detrs nuestro de(e ,acer e&actamente lo
mismo% pero usando este nue'o nmero# Al finali0ar la fila% la ltima persona tendr la respuesta ) se la
de'ol'er a la anterior% que ,ar lo mismo% ,asta llegar a la primer persona#
4tra posi(ilidad es preguntarle a la persona que est detrs nuestro% cul es el ma)or nmero de
documento de la fila que empie0a en l mismo% comparar su dato con el nuestro ) de a, o(tener la
respuesta# 9a segunda persona usa la misma estrategia que nosotros? para sa(er cul es el ma)or nmero de
documento de su fila% 'a a preguntarle a la siguiente persona cul es el ma)or documento de la otra fila` )
as sucesi'amente ,asta que lleguemos a la ltima persona de la fila# Ella% al no tener ninguna detrs% sa(e
que el ma)or nmero de documento es el su)o# A medida que el resultado 'a G'ol'iendoH% el ma)or nmero
es el que o(tenemos como resultado final#
!n tercer e+emplo? supongamos que queremos conocer la cantidad de letras que tiene una cadena de
caracteres# 5radicionalmente lo que podemos ,acer es utili0ar un for ) contar a medida que a'an0amos%
,asta llegar al carcter Pf0P# .ero tam(in es posi(le pensarlo de la siguiente manera? la cadena 'aca tiene
una longitud de 0% ) cualquier otra cadena mide 1 ms que lo que mide la cadena que empie0a en el
segundo elemento# Es decir?
int longitud(char cad[])
{
if (cad[0] == '\0')
return 0;
else
return 1 + longitud (cad +1);
}
En todos los casos% ,emos utili0amos un mtodo de resolucin recursi'o#

2EBI$I"IC$ 2E @E"!@3I VI2A2
2ecimos que una definicin es recursi'a cuando in'olucra aquello que se define en el cuerpo de la
definicin# En el caso de las funciones recursi'as% diremos que una funcin es recursi'a cuando se in'oca a s
misma#
Informtica II Apuntes de clase

E+emplos de definiciones recursi'as?
3i decimos Glos amigos de mis amigos son mis amigosH% estamos implicando que dentro de la
definicin de amigos est in'olucrada la misma definicin#
*is antepasados son mis padres% ) sus padres% ) sus padres% etc# .odemos decir que mis
antepasados son mis padres% ) los antepasados de mis padres# Entonces los antepasados de mis
padres sern sus padres% ) los antepasados de ellos% ) as sucesi'amente#

En una definicin recursi'a% de(emos identificar dos partes?
El caso (ase -aquello que no se repite/? la longitud de la cadena "ac%a es &' mis antepasados son mis
padres' etc
El caso recursi'o -aquello que se repite/? mis antepasados son los antepasados de mis padres' la
persona con documento m(s grande en la fila es la persona con documento m(s grande en la fila
)ue comien*a luego de m%D etc#
o Es necesario notar que la definicin recursi'a in'olucra aquello que se define% pero con
alguna 'ariacin que permite ir Gac,icandoH la definicin ,asta llegar al caso (ase# 3i una
definicin recursi'a repite aquello que est definiendo sin 'ariacin% se cae en un ciclo
infinito de repeticiones#

E^E*.94 2E B!$"I4$E3 @E"!@3IVA3? E9 BA"54@IA9
9a funcin factorial es el clsico caso de funcin que se puede definir recursi'amente# *atemticamente%
sa(emos que?
!0 = 1
!n = n (n-1)! (si n > 0)

.odemos definir entonces el factorial de la siguiente manera?
unsigned long int factorial(unsigned long int n)
{
if (n == 0)
return 1;
else
return n * factorial(n - 1);
}

!tili0amos en este caso 'alores unsigned para no tener pro(lemas con el signo de la 'aria(le#

E^E*.94 2E B!$"IC$ @E"!@3IVA? E$"4$5@A@ E9 *[MI *4 E$ !$ A@@EA94
Informtica II Apuntes de clase

Veamos el e+emplo de encontrar la persona con el ma)or 2$I en una fila# 3upongamos que la fila es un
arreglo de estructuras personas% ) que 'amos a retornar un puntero a la posicin donde se encuentra la
persona con ma)or 2$I# !n dni == 0 marca el fin de los 'alores 'lidos#
Qa) dos 'ariantes recursi'as en este e+ercicio? la primera consiste en comparar el primer elemento del
arreglo con el ma)or del resto# 9a segunda consiste en comparar el primer elemento con el segundo% ) as
,asta llegar al final del arreglo#
Variante 1?

typedef struct
{
char nombre[20];
int dni;
} Persona;

Persona* mayor(Persona* fila)
{
Persona* mayorAux;
if ( fila[1]->dni == 0)
return fila;
else
{
mayorAux = mayor(fila + 1);
if (fila->dni > mayorAux->dni)
mayorAux = fila;
return mayorAux;
}
}

Variante 2?

Persona* mayor(Persona* fila, Persona* mayorAux)
{
if ( fila->dni == 0)
return mayorAux;
else
{
if (fila->dni > mayorAux->dni)
return mayor(fila + 1, fila);
else
return mayor(fila + 1, mayorAux);
}
}

Esta 'ariante se in'oca pasando el primer elemento del arreglo como segundo parmetro% para alimentar la
funcin con un 'alor 'lido# Al llegar al final del arreglo% lo que nos qued en el segundo parmetro es el
'alor que queremos#
Informtica II Apuntes de clase


3EA!I*IE$54 2E .I9A
En ocasiones es con'eniente 'isuali0ar qu ocurre en la memoria cuando empe0amos a resol'er pro(lemas
con algoritmos recursi'os# "ada in'ocacin de funcin genera un apilamiento de memoria en el stac\% ) es
fcil Gperder el ,iloH de dnde nos encontramos#
@ealicemos el seguimiento de la siguiente porcin de cdigo?
#include <stdio.h>
#include <stdlib.h>

unsigned long int factorial(unsigned long int n);

int main()
{
unsigned long int n = factorial(3);
printf("%lu\n", n);
return 0;
}

unsigned long int factorial(unsigned long int n)
{
if (n == 0)
return 1;
else
return n * factorial(n - 1);
}






n = ? main()



n = 3
ret=? factorial(3)

n = ? main()


n = 2
ret=? factorial(2)
n = 3
ret=? factorial(3)

n = ? main()

1- Inicia main
Se invoca
factorial(3)
2- Se ejecuta
factorial(3)
Se copia el valor 3
El valor de retorno
de la funcin se
desconoce hasta que
se ejecute
factorial(2)
Se llama a
factorial(2)
3- Se ejecuta factorial(2)
Se copia el valor 2
El valor de retorno de la
funcin se desconoce hasta
que se ejecute factorial(1)
Se llama a factorial(1)
Informtica II Apuntes de clase



n = 1
ret=? factorial(1)
n = 2
ret=? factorial(2)
n = 3
ret=? factorial(3)

n = ? main()

n = 0
ret=1 factorial(0)
n = 1
ret=? factorial(1)
n = 2
ret=? factorial(2)
n = 3
ret=? factorial(3)

n = ? main()

n = 0
ret=1 factorial(0)
n = 1
ret=1 factorial(1)
n = 2
ret=? factorial(2)
n = 3
ret=? factorial(3)

n = ? main()

4- Se ejecuta
factorial(1)
Se copia el valor 1
El valor de retorno
de la funcin se
desconoce hasta que
se ejecute
factorial(0)
Se llama a
factorial(0)
5- Se ejecuta
factorial(0)
Se copia el valor 0
Se retorna 1. Ahora
factorial(1) puede
finalizar su
ejecucin

6- factorial(1) retorna 1.
Ahora factorial(2) puede
finalizar su ejecucin
n = 0
ret=1 factorial(0)
n = 1
ret=1 factorial(1)
n = 2
ret=2 factorial(2)
n = 3
ret=? factorial(3)

n = ? main()

n = 0
ret=1 factorial(0)
n = 1
ret=1 factorial(1)
n = 2
ret=2 factorial(2)
n = 3
ret=6 factorial(3)

n = ? main()

n = 0
ret=1 factorial(0)
n = 1
ret=1 factorial(1)
n = 2
ret=2 factorial(2)
n = 3
ret=? factorial(3)

n = 6 main()

7- factorial(2)
retorna 2 x 1 = 2.
Ahora factorial(3)
puede finalizar su
ejecucin
8- factorial(3)
retorna 2 x 3 = 6.
Ese valor es devuelto
al main()
9- main() finaliza su
ejecucin


Informtica II Apuntes de clase

8- ESTRUCTURAS DIN6MICAS 9 GENERALIDADES : LISTAS
I$5@42!""IC$
!na estructura dinmica es una agrupacin de datos que ponemos +untos porque se refieren a una misma
idea o concepto que tiene la facultad de modificar su tamao en la medida que lo necesitemos# !na
estructura dinmica nos sir'e para modelar% en la computadora% situaciones pro(lemticas en las cuales la
cantidad de Gindi'iduosH -datos indi'iduales/ con la que tra(a+amos es desconocida de antemano% que
presentan entre s una cierta correlacin#
E+emplo? la cola de gente en una ca+a de supermercado es una estructura dinmica# 3i consideramos que
cada persona es un indi'iduo -elemento/ de nuestra estructura% 'eremos que sta crece -cuando llega
gente/ ) decrece -cuando la gente se 'a/# 9os elementos estn en correlacin% cada elemento pertenece a la
cola ) sa(e quin lo antecede ) quin lo sigue -e&cepto claro el primero ) el ltimo/#
2ependiendo del tipo de relacin que ,a)a entre los elementos% ) de las operaciones que definimos so(re
los mismos% tradicionalmente en Informtica se definen las siguientes estructuras?
9istas? estructura secuencial de datos# "ada elemento conoce al elemento que le sigue -)
potencialmente a su predecesor/# "onociendo al primer elemento% podemos tener acceso a
cualquiera de ellos# 9as operaciones que podemos ,acer son? agregar% quitar elementos% recorrerla
-por e+emplo para imprimirla/% ) agregar en forma ordenada -si la lista define un orden interno/#
E+emplos? lista de personas en un equipo de fut(ol#
.ilas? estructura secuencial de datos de modelo 9IB4 -last in first out/# Esto quiere decir que los
elementos se agregan ) se eliminan por el mismo e&tremo# E+emplo? una torre de "2s% slo
podemos agregar ) quitar "2s por el e&tremo superior# En una pila no tiene sentido ,a(lar de
GrecorrerH o de Gagregar en forma ordenadaH% )a que las nicas operaciones definidas son agregar
-pus,/ ) quitar -pop/#
"olas? estructura secuencial de datos de modelo BIB4 -first in first out/# Esto quiere decir que los
elementos se agregan por un e&tremo ) se quitan por el otro# .or e+emplo? una cola de gente en el
supermercado# En una pila no tiene sentido ,a(lar de GrecorrerH o de Gagregar en forma
ordenadaH% )a que las nicas operaciones definidas son encolar -enqueue/ ) desencolar -dequeue/#
[r(oles? estructura GramificadaH de datos# "ada elemento conoce a otros a los que llama sus ,i+os#
A su 'e0 cada ,i+o tam(in es un elemento% ) puede conocer otros ,i+os# .or e+emplo? un r(ol
genealgico#
.odemos pensar que cada estructura est definida de dos maneras? a tra's de su es$eci(icacin -es decir
qu cosas esperamos que nos permita ,acer/D ) a tra's de su i&$le&en'acin -cul es el cdigo que nos
permite cumplir con la especificacin/#
"4$4"I*IE$543 .@EVI43
9as especificaciones de qu ,ace una estructura dinmica no requieren conocimientos pre'ios de
informtica% podramos decir que son formas con'encionales de representacin de datos -de ,ec,o son tan
Informtica II Apuntes de clase

con'encionales que otros lengua+es de programacin las implementan en forma nati'a/# 3 es necesario
estar de acuerdo en dic,as operaciones cuando ,a(lamos entre nosotros en clase? independientemente de
cmo las implementemos% cuando ,a(lemos de pilas pensaremos slo en trminos de pus+ ) pop% cuando
,a(lemos de colas% en enqueue ) dequeue% ) as sucesi'amente#
9a implementacin% por otro lado% requiere que tengamos presentes todos los temas 'istos anteriormente
en la materia?
Estructuras
.unteros
*emoria 2inmica
@ecursi'idad
J2e qu manera utili0amos estos conocimientosL 9a implementacin de una estructura dinmica se reali0a
de la siguiente manera?
6 !tili0aremos un struct para representar cada uno de los indi'iduos de nuestra estructura# Este
struct 'a a contener 2 tipos de informacin? la del indi'iduo que estemos representando por un
lado% ) por otro lado% informacin que nos permitan relacionarla con el resto de la estructura#
6 "ada 'e0 que necesitemos agregar un elemento a la estructura% lo ,aremos a tra's de un malloc,-.
"ada 'e0 que necesitemos quitar uno% lo quitaremos con free,-. 2e esta manera% la estructura
ocupa slo la memoria que necesita#
6 En los structs% la relacin entre un elemento ) los dems la reali0aremos a tra's de punteros# 2ado
entonces que cada struct conoce a otros structs -del mismo tipo/% los mismos son recursi"os#
6 9a estructura completa la referenciaremos con un puntero a uno de sus elementos# Inicialmente
este puntero estar en $!99 ) diremos que la estructura est 'aca% ) al momento que agreguemos
un elemento% )a no lo estar#
Veamos a,ora cmo se ponen en prctica todas estas consideraciones#

9I35A3
"omo di+imos anteriormente% una lista es una secuencia de datos# En la implementacin (sica de listas que
utili0aremos% cada elemento conoce al elemento que lo sigue% ) nosotros conoceremos -a tra's de un
puntero/ al primer elemento de la lista# 9as listas pueden estar ordenadas de acuerdo al orden de llegada de
los elementos% o pueden tener un cierto orden definido de acuerdo a un criterio#
Ejemplos de listas: una lista de in'itados a una fiesta% una lista de asistentes a una reunin% una lista de
compras de supermercado% etc#
Similitudes y diferencias con arreglos: una lista permite representar la misma informacin que podramos
representar en un arreglo# 9as similitudes son e'identes? un arreglo tam(in es una secuencia de datos# En
Informtica II Apuntes de clase

un arreglo% cada elemento tiene un sucesor -e&cepto el ltimo/% ) para accederlo de(emos simplemente
a'an0ar 1 posicin de memoria# @especto a las diferencias? un arreglo tiene todos sus elementos contiguos
en la memoria% en una lista esto no es as# .ara acceder al n6simo elemento% simplemente ,acemos
arregloEnF% en cam(io en una lista tendremos que posicionarnos en el elemento inicial ) a'an0ar n 'eces
,asta llegar al ensimo#
4.E@A"I4$E3
En una lista las siguientes operaciones son 'lidas?
Agregar un elemento? si la lista est 'aca% esta operacin GcreaH la lista#
Kuitar un elemento#
Agregar un elemento en forma ordenada% si la lista tiene un criterio de orden#
@ecorrer la lista#
4tras -pero las anteriores son las (sicas/#
I*.9E*E$5A"IC$ 2E 9A E35@!"5!@A
.ara implementar una lista necesitaremos modelar cada uno de sus elementos# "ada elemento lo
representaremos con un struct al que llamaremos GnodoH# As% una lista estar compuesta por nodos# "ada
nodo contendr informacin del indi'iduo que representa% ) tendr informacin so(re el siguiente nodo de
la lista -es decir% cada nodo conoce al nodo siguiente/#
Arficamente lo representaremos as?

En la parte i0quierda del nodo pondremos la informacin que queremos representar% la parte derec,a del
nodo es un puntero al siguiente elemento#
El cdigo para representar un nodo es el siguiente?
struct s_nodo
{
int valor;
struct s_nodo* sig;
};
typedef struct s_nodo* t_nodo;
Informtica II Apuntes de clase

valor es una 'aria(le de tipo int% pero podra ser de cualquier otro tipo -o podra ,a(er ms de una
'aria(le/# 9o interesante es que la estructura s_nodo tiene un puntero a otra estructura s_nodo -por eso
decimos que es recursi'a/# Adems definimos un tipo t_nodo% que es puntero a senodo#

I*.9E*E$5A"IC$ 2E 9A3 4.E@A"I4$E3
Vamos a definir las siguientes operaciones? agregar-/% insertar-/ -agregar ordenado/ ) eliminar-/#
9as funciones anteriores pueden programarse de dos maneras? en forma recursi'a ) en forma iterati'a# "ada
una de ellas presenta 'enta+as ) des'enta+as# Aeneralmente las formas recursi'as se codifican ms
(re'emente% ) su funcionamiento es uniforme dentro de toda la lista# 9as soluciones iterati'as generalmente
son ms eficientes% pero de(en definir funcionamientos diferentes de acuerdo a la posicin de la lista so(re
la que estn operando -el principio% el medio% el final% o la lista 'aca/#
A;re;ar )n alor a )na lis'a
.ara agregar un 'alor a una lista% 'amos a definir el siguiente prototipo de funcin? agregar(t_nodo*,
int)# Veamos un e+emplo de uso ) aclaremos qu significa el tipo t_nodo*.
#include <stdio.h>
#include <stdlib.h>

struct s_nodo
{
int valor;
struct s_nodo* sig;
};
typedef struct s_nodo* t_nodo;

void agregar(t_nodo*, int);

int main()
{
t_nodo lista = NULL;
agregar(&lista, 3);
agregar(&lista, 7);
}

JKu pasa en el cdigo de arri(aL
16 2eclaramos las estructuras que necesitamos
26 2eclaramos el prototipo de una funcin agregar# Esta funcin nos sir'e para crear la lista% si es que
sta est 'aca% o para agregarle un nodo al final% si es que )a contiene elementos#
;6 En el main-/% utili0amos la lista en'iando como parmetro Slista# J.or quL 3a(emos que las
funciones en " no pueden modificar los argumentos que le en'iamos -por e+emplo% si in'ocamos la
funcin poa-a% (/% a la salida de la funcin a ) ( no se modifican/# "uando queremos que una
funcin modifique el parmetro que reci(e% tenemos que pasarlo como un puntero# "omo lista es
Informtica II Apuntes de clase

una 'aria(le de tipo puntero% pero a su 'e0 queremos que se modifique dentro de la funcin%
tenemos que en'iar un puntero a ese puntero% o lo que es lo mismo% un do(le puntero o do(le
indireccin#
.ara 'erlo grficamente?

t N 0 t N 1

nue'o
nodo 2;>B0

9lamo a
agregar
NNZ




$!99 lista 2;>B0 lista
main-/ main-/


9uego de in'ocar a agregar-/% la 'aria(le lista% que era un puntero apuntando a $!99% a,ora contiene la
direccin de memoria donde se cre el nue'o nodo# 9a nica manera de lograr eso% en el lengua+e "% es si
pasamos un puntero a dic,a 'aria(le -)a que de esa manera% podemos modificarlo en una funcin/#
Veamos la codificacin -en forma recursi'a/ de la funcin agregar?
void agregar(t_nodo* nodo, int valor)
{
if ( *nodo == NULL)
{
*nodo = (t_nodo) malloc(sizeof(struct s_nodo));
(*nodo)->valor = valor;
(*nodo)->sig = NULL;
}
else
{
agregar(& (*nodo)->sig, valor);
}
}

Vemos que la funcin ,ace que el puntero a un nodo apunte a una nue'a posicin de memoria slo cuando
ste est apuntando a $!99? cuando in'oquemos agregar-/ la primera 'e0% ,ar que nuestra 'aria(le lista
Informtica II Apuntes de clase

apunte a un nue'o nodo# "uando llamemos a la funcin una segunda 'e0% como lista no est apuntando ms
a $!99% se in'ocar recursi'amente% pasando como parmetro un do(le puntero al miem(ro GsigH del
primer nodo# El efecto prctico es que dic,o puntero GsigH 'a a apuntar a un nue'o nodo que se cree cuando
la funcin sea in'ocada la segunda 'e0# 3i 'ol'emos a agregar otro nodo% ocurrir nue'amente lo mismo -el
nodo inicial no es 'aco ) a'an0a recursi'amente% el siguiente nodo no es 'aco tampoco ) 'uel'e a a'an0ar%
aqu s el nodo estar apuntando a $!99 as que crea una nue'a estructura en memoria ) la ,ace apuntar
por ese nodo/#
int main()
{
t_nodo lista = NULL;
agregar(&lista, 3);
agregar(&lista, 7);
agregar(&lista, 5);
agregar(&lista, 2);

}


Inser'ar en (or&a or<ena<a )n alor en )na lis'a
3i la lista que queremos crear de(e respetar un cierto orden% entonces la funcin agregar() no nos sir'e%
porque sta agrega slo al final#
@e'isemos la lgica que de(eramos seguir si queremos insertar en una lista en forma ordenada#
3upongamos que partimos de la lista 3->7 ) queremos agregar el 'alor 7# 9a lista que 'amos a o(tener 'a a
ser 3->5->7#
9o que 'amos a tener que ,acer es% (sicamente% a'an0ar por toda la lista ,asta encontrar un nodo cu)o
'alor sea ma)or al 'alor que queremos insertar# 3i nos paramos en lista ) miramos el nodo con el 'alor ;%
si queremos insertar el 7% 'amos a tener que a'an0ar un paso# 3i nos paramos en el puntero GsigH% )
o(ser'amos el 'alor del nodo al que apunta% 'emos que es ma)or al nmero que queremos insertar% por lo
tanto es aqu donde de(emos agregar nuestro nodo# A continuacin?
6 creamos un nodo ) lo ,acemos apuntar por un puntero au&iliar#
6 Qacemos que el puntero sig del nue'o nodo apunte al nodo que estamos apuntando actualmente
-en el e+emplo% el que contiene al </#
6 A,ora ,acemos que el puntero al nodo actual en donde estamos% apunte a nuestro nue'o nodo
au&iliar -o sea% el que contiene el 7/#

!na ltima consideracin es que no siempre 'amos a insertar un 'alor entre 2 nodos? si nos ocurre que
llegamos al final de la lista% tendremos que insertar el 'alor all#
Informtica II Apuntes de clase



Arficamente?


El cdigo nos queda as?
void insertar(t_nodo* nodo, int valor)
{
t_nodo aux = NULL;
if (*nodo == NULL || valor < (*nodo)->valor)
{
aux = (t_nodo) malloc(sizeof(struct s_nodo));
aux->valor = valor;
aux->sig = *nodo;
*nodo = aux;
}
else
{
insertar( & (*nodo)->sig, valor);
}
}
Informtica II Apuntes de clase


Eli&inar alores <e )na lis'a
"uando eliminamos 'alores de una lista% lo que de(emos ,acer es a'an0ar ,asta el nodo que queremos
(orrar% eliminarlo con free% ) Greenganc,arH los nodos restantes# 9a lista de(e tener al menos un elemento
para que podamos (orrar% si la lista est 'aca podemos imprimir un mensa+e de error#

void eliminar(t_nodo* nodo, int valor)
{
t_nodo aux = NULL;
if (*nodo == NULL)
{
printf("Error al borrar valor de una lista vacia\n");
return;
}
else if ( (*nodo)->valor == valor )
{
aux = (*nodo);
*nodo = (*nodo)->sig;
free(aux);
}
else
{
eliminar( & (*nodo)->sig, valor);
}
}

Esta funcin tam(in sir'e para eliminar el primer elemento de una lista -)a que el puntero original pasar a
apuntar al segundo elemento/% como cualquier elemento del medio e inclusi'e el ltimo -)a que ,ar que el
anteltimo nodo apunte a $!99% ) (orrar el ltimo/#
Informtica II Apuntes de clase



= - ESTRUCTURAS DIN6MICAS 9"ILAS : COLAS
I$5@42!""IC$
.ilas ) colas son dos estructuras de datos que se utili0an cuando queremos modelar pro(lemas en los cuales
las operaciones de insercin ) (orrado de elementos en la estructura ocurren por los e&tremos de la misma#
En am(os casos utili0aremos el mismo tipo de nodos que ,emos utili0ado para programar listas
simplemente enla0adas% sin em(argo 'eremos que la implementacin de las operaciones es diferente#
.I9A3
9as pilas son estructuras de datos que sir'en para modelar pilas -Gstac\sH/ de la 'ida real# .or e+emplo?
pensemos en una torre de "2s#

3i tenemos una torre de "2s 'aca ) empe0amos a agregar discos en la misma% podemos notar que?
$o ,a) pro(lemas para agregar discos% siempre el ltimo disco que agreguemos 'a a estar en el
tope de la torre#
.ara quitar un disco% slo lo podemos ,acer por el tope# 3i estamos (uscando un disco en el medio%
de(emos quitar todos los anteriores% quitar el que (uscamos% ) 'ol'er a colocar todos#
!na pila se comporta de esa manera# 9as operaciones de insercin ) eliminacin se producen por un
e&tremo% al cual denominamos GtopeH de la pila# $o es posi(le acceder a un elemento del medio sin sacar
antes los anteriores#
2ecimos que una pila es una estructura 9IB4 -last in first out/? el ltimo elemento agregado es el primero en
ser quitado#
Informtica II Apuntes de clase

A las operaciones de insercin ) de remocin se las denomina Gpus,H ) GpopH#
E3.E"IBI"A"IC$
3o(re una pila slo es posi(le reali0ar las siguientes operaciones?
.us,? permite agregar un elemento
.op? permite quitar un elemento ) o(tener que dic,o elemento almacena(a#
I*.9E*E$5A"IC$
9a implementacin de una pila podemos ,acerla so(re una lista simplemente enla0ada% usando el inicio de
la lista como tope de la pila# 9o ,acemos as porque es el nico e&tremo que cam(ia% ) el que tenemos ms
Ga manoH? si utili0ramos el final de la lista como tope% tendramos que recorrerla en su totalidad tanto para
agregar como para eliminar un elemento#
9os prototipos de las operaciones nos quedan definidos as?
struct s_nodo
{
int valor;
struct s_nodo* sig;
};
typedef struct s_nodo* t_nodo;

void push(t_nodo*, int);
int pop(t_nodo*);

E+emplo de uso?
int main()
{
int val;
t_nodo pila = NULL;
do
{
printf("Ingrese un valor, con 0 finaliza: ");
scanf("%d", &val);
if (val != 0)
push(&pila, val);
} while ( val != 0);

printf("\nLos elementos de la pila, desapilados, son:\n");
while (pila != NULL)
{
val = pop(&pila);
printf("%d -", val);
}
printf("\n");
return 0;
}
Informtica II Apuntes de clase



.!3Q
9a funcin pus, permite agregar un nue'o elemento a la pila# 2ic,o elemento se con'ierte en el nue'o tope#
9a implementacin consiste (sicamente en crear un nue'o nodo% ponerlo enfrente de los que )a tenemos%
) mo'er el tope de la pila al nue'o nodo creado#
void push(t_nodo* pila, int valor)
{
t_nodo aux = (t_nodo) malloc( sizeof(struct s_nodo));
aux->dato = valor;
aux->sig = NULL;
aux->sig = *pila;
*pila = aux;
}


.4.
9a funcin pop permite e&traer el ltimo elemento de una pila# Al ,acerlo% eliminaremos el nodo que
guarda(a dic,o elemento# El tope de la pila se 'a a mo'er al nodo siguiente al primero# $o es posi(le
e+ecutar la funcin pop so(re una pila 'aca% se producir un error en tiempo de e+ecucin#
int pop(t_nodo* pila)
{
int valor;
t_nodo aux = *pila;

valor = aux->dato;
*pila = aux->sig;
free(aux);
return valor;
}

Informtica II Apuntes de clase


"49A3
9as colas son estructuras de datos que sir'en para modelar -sorpresa/ colas de atencin de la 'ida real#
En una cola de atencin sin prioridad% la primer persona que llega a la cola es la primer persona en ser
atendida% ) la primera en retirarse# 9a gente que llega despus% se 'a encolando detrs de la primera% de
manera que el ltimo que lleg ser el ltimo en retirarse#


Al e&tremo por el cual se producen las inserciones lo llamamos el GfinalH de la cola% ) al e&tremo por el cual
los elementos se quitan% lo llamamos el GfrenteH#
2ecimos que una cola es una estructura BIB4 -Birst In% Birst 4ut/# El primer elemento que se agrega es el
primero que se quita#
E3.E"IBI"A"IC$
3o(re una cola slo dos operaciones son 'lidas?
queue o encolar? agrega un elemento al final de la cola#
dequeue o desencolar? quita un elemento del frente de la cola#
I*.9E*E$5A"IC$
Implementaremos una cola so(re una lista simplemente enla0ada# 9as inserciones se producirn al final de la
lista% ) las eliminaciones% desde el principio#
2ado que necesitaremos operar por am(os e&tremos de la lista implementacin% es con'eniente mantener
punteros tanto al frente como al final en forma simultnea# 2e esta manera% en ningn caso de(eremos
recorrer la lista en su totalidad para agregar o quitar elementos#
.ara poder manipular am(os e&tremos en forma simultnea% utili0aremos una estructura au&iliar#
Informtica II Apuntes de clase



struct s_nodo
{
int valor;
struct s_nodo* sig;
};
typedef struct s_nodo* t_nodo;

struct s_cola
{
t_nodo frente;
t_nodo final;
};
typedef struct s_cola t_cola;

En el cuadro anterior podemos o(ser'ar que una estructura t_cola contiene dos punteros% uno a cada
e&tremo de la misma# 9os prototipos de las funciones% entonces% reci(irn como parmetro un puntero a
una estructura t_cola% lo cual permitir modificar dic,os punteros internamente#

void queue(t_cola*, int);
int dequeue(t_cola*);

E+emplo de uso?
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

...

int main()
{
int val;
t_cola cola = { NULL, NULL };
do
{
printf("Ingrese valores, con 0 finaliza: ");
scanf("%d", &val);
if (val != 0)
queue(&cola, val);
} while ( val != 0);

printf("\nDatos ingresados: ");
while (cola.frente != NULL)
{
val = dequeue(&cola);
printf("%d -", val);
}
printf("\n");
return 0;
Informtica II Apuntes de clase

}

K!E!E
9a funcin para encolar datos de(e reali0ar lo siguiente?
"rear un nue'o nodo en memoria ) almacenar el elemento en'iado como parmetro
Qacer que el puntero siguiente del final de la cola apunte al nue'o nodo ) mo'er el final a la nue'a
posicin% o si la cola esta(a 'aca% ,acer que frente ) final apunten al nue'o nodo creado#
void queue(t_cola* cola, int valor)
{
t_nodo aux = (t_nodo) malloc(sizeof(struct s_nodo));
nodo->valor = valor;
nodo->sig = NULL;

if (cola->frente == NULL && cola->final == NULL)
{
cola->frente = aux;
cola->final = aux;
}
else
{
cola->final->sig = aux;
cola->final = aux;
}
}

2EK!E!E
9a funcin para desencolar datos de(e reali0ar lo siguiente?
*o'er el puntero del frente de la cola al siguiente elemento#
Almacenar el 'alor del nodo que est al frente de la cola ) eliminar dic,o nodo#
3lo si la cola queda 'aca% ,acer que el final de la cola tam(in apunte a $!99#
int dequeue(t_cola* cola)
{
int valor;
t_nodo aux = cola->frente;
cola->frente = cola->frente->sig;
valor = aux->dato;
free(aux);
if (cola->frente == NULL)
{
cola->final = NULL;
}
return valor;
}
Informtica II Apuntes de clase


> - ESTRUCTURAS DIN6MICAS 9 LISTAS DOBLEMENTE ENLA?ADAS
I$5@42!""IC$
9a primer implementacin de la estructura dinmica lista la reali0amos con nodos simplemente enla0ados#
9os llamamos as )a que cada nodo slo conoce al nodo que le sigue% pero no conoce a ningn otro#
E&iste una segunda implementacin de listas dinmicas? listas do(lemente enla0adas# En esta
implementacin% cada elemento conoce al nodo que le sigue% pero tam(in conoce al nodo que le antecede#
3i (ien esta implementacin consume ms recursos de memoria que la primera 'ersin% tam(in ofrece
ma)or fle&i(ilidad a la ,ora de recorrerla% agregar ) quitar elementos#
E3.E"IBI"A"IC$
3o(re una lista do(lemente enla0ada es posi(le reali0ar las mismas operaciones que so(re una lista
simplemente enla0ada?
Agregar elementos
Insertar -agregar en forma ordenada/
Eliminar
@ecorrerla
I*.9E*E$5A"IC$
El nodo que utili0aremos para representar los elementos de la lista 'a a tener a,ora 2 punteros% uno que
apunte al nodo anterior ) otro que apunte al nodo siguiente# En el e&tremo i0quierdo de la lista% el puntero
anterior apuntar a $!99D ) en el e&tremo derec,o% el puntero siguiente ,ar lo mismo#
struct s_nodo
{
int valor;
struct s_nodo* sig;
struct s_nodo* ant;
};
typedef struct s_nodo* t_nodo;


9as funciones se pueden implementar de la misma manera en que se implementan funciones so(re listas
simplemente enla0adas# 5am(in es posi(le reali0ar implementaciones eficientes a tra's de ciclos
iterati'os% en 'e0 de recurrir a llamadas recursi'as# 9as listas do(lemente enla0adas presentan una 'enta+a
so(re las simples% )a que a tra's del puntero al nodo anterior% podemos Gir ) 'enirH en am(os sentidos#
"@EA"IC$ 2E !$ $!EV4 $424
Informtica II Apuntes de clase

!tili0aremos una funcin au&iliar para crear nue'os nodos# 2e esta manera% nos a,orraremos las lneas de
cdigo de iniciali0acin?
t_nodo nuevo_nodo(int valor)
{
t_nodo aux = (t_nodo) malloc(sizeof(struct s_nodo));
aux->valor = valor;
aux->ant = NULL;
aux->sig = NULL;
return aux;
}

AA@EAA@ E9E*E$543
Al agregar un elemento al final de la lista% no de(emos ol'idarnos de Glin\earH los nodos anterior )
siguiente# Aqu ,a) un e+emplo de una implementacin iterati'a en 'e0 de recursi'a?
void agregar(t_nodo* lista, int valor)
{
t_nodo aux;
if (*lista == NULL)
{
*lista = nuevo_nodo(valor);
}
else
{
aux = *lista;
while (aux->sig != NULL)
aux = aux-> sig;

aux->sig = nuevo_nodo(valor);
aux->sig->ant = aux;
}
}
En el caso de las implementaciones sin recursi'idad% ,a(itualmente tendremos que agregar condiciones
para distinguir si lo que estamos ,aciendo lo ,acemos al principio% al medio% o al final de la lista# En el
cuadro anterior% 'emos cmo de(emos controlar si la lista est 'aca cuando agregamos un nodo#
No'a: es posi(le reempla0ar estas lneas
aux = *lista;
while (aux->sig != NULL)
aux = aux-> sig;
por esta?
for (aux = *lista; aux->sig != NULL; aux = aux-> sig);
$otar el D al final del for% el ciclo no tiene otras instrucciones internas
Informtica II Apuntes de clase


I$3E@5A@ E9E*E$543
.ara insertar elementos -es decir% agregarlos de manera que la lista quede ordenada/% recorreremos la lista
,asta llegar al nodo frente al cual de(emos efectuar la operacin# !na 'e0 all% crearemos un nue'o nodo
cu)o puntero siguiente apuntar al nodo donde estamos posicionados% ) su puntero anterior al nodo
anterior correspondiente# 9uego de(emos Grelin\earH los nodos en forma apropiada -el siguiente del nodo
anterior ) el anterior del nodo donde estamos posicionados apuntarn al nue'o/#
En el caso que la insercin se produ0ca al frente o al final de la lista% de(eremos tener cuidado de no reali0ar
asignaciones innecesarias de punteros -)a que el anterior ) el siguiente en cada caso apuntarn a $!99/#
void insertar(t_nodo* lista, int valor)
{
t_nodo aux;
t_nodo nuevo = nuevo_nodo(valor);
if (*lista == NULL || valor < (*lista)->valor)
{
nuevo->sig = *lista;
if (*lista != NULL)
(*lista)->ant = nuevo;
*lista = nuevo;
}
else
{
for (aux = *lista; valor > aux->valor && aux->sig != NULL;
aux = aux->sig);

if (valor < aux->valor)
{
nuevo->sig = aux;
nuevo->ant = aux->ant;
aux->ant->sig = nuevo;
aux->ant = nuevo;
}
else
{
nuevo->ant = aux;
aux->sig = nuevo;
}
}
}

E9I*I $A@ E9E*E$543
.ara eliminar elementos de una lista do(lemente enla0ada% aplican las mismas consideracioens que para
insertar datos? si estamos eliminando el primer nodo de(emos modificar el inicio de la lista% si estamos en el
medio de(emos Grelin\earH los nodos anteriores ) siguientes% ) si estamos eliminando el ltimo elemento
simplemente lo quitamos ) apuntamos el ltimo puntero a $!99#
Informtica II Apuntes de clase


void eliminar(t_nodo*lista, int valor)
{
t_nodo aux;
for(aux = *lista; aux->valor != valor && aux->sig != NULL;
aux = aux->sig);

if (aux == *lista)
{
*lista = (*lista)->sig;
(*lista)->ant = NULL;
free(aux);
}
else if (aux->valor == valor)
{
if (aux->sig != NULL)
aux->sig->ant = aux->ant;
aux->ant->sig = aux->sig;
free(aux);
}
}

1@ - ESTRUCTURAS DIN6MI CAS 9 ARBOLES BINARIOS
I$5@42!""IC$
9istas% pilas ) colas son estructuras dinmicas GlinealesH? para cada elemento de la estructura% conocemos un
sucesor ) tal 'e0 un antecesor% pero solamente uno# .odramos definir estructuras dinmicas que sir'ieran
para representar grafos ms comple+os% por e+emplo una red de ciudades interconectadas% o una red de
su(terrneos% o los planos de una casa% etc#
!na de las estructuras ms utili0adas computacionalmente es la estructura r(ol# El trmino no se refiere a
los r(oles del reino 'egetal% sino a representaciones del estilo de los r(oles genealgicos o los r(oles que
representan una +erarqua#

Informtica II Apuntes de clase

En el e+emplo anterior% el r(ol est Gde ca(e0aH ) ,a(itualmente lo representamos as# 2ecimos que la
Gra0H del r(ol es el elemento original al cual se conectan los dems# 9os elementos de los e&tremos son las
G,o+asH% ) los intermedios% las GramasH#
!n tipo particular de r(ol son los llamados r(oles (inarios# En l% cada elemento puede tener a lo sumo 2
,i+os -el ,i+o i0quierdo ) el derec,o/#
2EBI$I"I4$E3 VA@IA3
!n r(ol (inario es una estructura en la que cada nodo conoce a lo sumo a otros dos nodos% sus ,i+os# 9os
nodos que no tienen ,i+os son los nodos ,o+aD el nodo que da origen al r(ol es la ra0 del mismo# .odemos
pensar en un r(ol como una estructura recursi'a# !n r(ol es o (ien el r(ol 'aco -$!99/% o (ien es un
nodo que contiene dos su(6r(oles% el i0quierdo ) el derec,o% ) estos a su 'e0 tam(in son r(oles#


5anto los r(oles como los r(oles (inarios poseen 'arias $ro$ie<a<es interesantes# .odemos efectuar las
siguientes definiciones?
6 !n r(ol es es'ric'a&en'e !inario si cada nodo que no es ,o+a tiene ,i+o i0quierdo ) derec,o no
nulo -el del e+emplo anterior no sera estrictamente (inario/#
6 El niel <e )n no<o de un r(ol (inario se define de la siguiente manera? la ra0 tiene ni'el 0% )
cualquier otro nodo tiene un ni'el 1 ma)or al ni'el de su nodo padre#
6 9a profundidad de un r(ol es el ma)or ni'el de cualquier ,o+a#
6 !n r(ol (inario es co&$le'o si todas sus ,o+as estn al mismo ni'el#
6 !n r(ol (inario de ni'el $ tiene como m&imo 2
$O1
61 nodos# .or e+emplo% un r(ol (inario de ni'el
; puede contener ,asta 17 nodos -1 en el ni'el 0% 2 en el ni'el 1% > en el ni'el 2 ) < en el ni'el ;/#
6 !n r(ol crece en forma e&ponencial% esto quiere decir que necesitamos relati'amente pocos
ni'eles para representar grandes cantidades de datos# .or e+emplo% en un r(ol de profundidad 8
se pueden representar ,asta 102; elementos#
6 !n r(ol (inario est ordenado cuando el 'alor del nodo ra0 es ma)or que cualquier 'alor de su
su(r(ol i0quierdo% menor que cualquier 'alor de su su(r(ol derec,o% ) a su 'e0 am(os su(r(oles
tam(in estn ordenados# !n r(ol con estas caractersticas se denomina Gr(ol (inario de
(squedaH#

A@:49E3 :I$A@I43 2E :g3K!E2A
Informtica II Apuntes de clase

9os r(oles (inarios de (squeda o A:: son estructuras que permiten reali0a (squedas de datos 'eloces#
En un A:: de $ elementos% ,acen falta a lo sumo log2-$/ comparaciones para encontrar un dato -la
demostracin est fuera del alcance de lo que se e&plica pero es mu) sencilla/#

4.E@A"I4$E3
9as operaciones que podemos definir so(re un A:: son?
6 Agregar datos? si el r(ol est 'aco% podemos insertar 'alores# 3i no lo est% agregaremos el dato a
i0quierda% si el 'alor a agregar es menor que el 'alor del nodo donde estamos parados% o a derec,a
en caso contrario# 9a operacin es recursi'a ,asta alcan0ar un su(r(ol -nodo/ 'aco#
6 Eliminar datos? slo podremos eliminar nodos ,o+asD en caso de querer eliminar un nodo que no es
,o+a% de(eremos eliminar todo el su(r(ol correspondiente#
6 @ecorrer un r(ol? al ser una estructura no lineal% e&isten diferentes maneras de ,acerlo# 3e
desarrollarn ms adelante#
I*.9E*E$5A"IC$
.ara implementar un r(ol (inario utili0aremos una estructura recursi'a?
struct s_nodo_bin
{
int valor;
struct s_nodo_bin* izq;
struct s_nodo_b* der;
};
typedef struct s_nodo_bin* t_nodo_bin;

El algoritmo de creacinbinsercin de datos es como sigue?
void agregar(t_nodo_bin* arbol, int valor)
{
if (*arbol == NULL)
{
*arbol = (t_nodo_bin)malloc(sizeof(struct s_nodo_bin));
(*arbol)->valor = valor;
(*arbol)->izq = NULL;
(*arbol)->der = NULL;
}
else
{
if (valor < (*arbol)->valor)
agregar(& (*arbol)->izq, valor);
else
agregar(& (*arbol)->der, valor);
}
}
Informtica II Apuntes de clase


Este algoritmo presupone que nunca se insertan 'alores duplicados -esta presuncin la ,aremos siempre
para r(oles (inarios/#
!na funcin (ooleana que sir'a para determinar si un 'alor se encuentra en un r(ol se indica a
continuacin?


int esta(t_nodo_bin arbol, int valor)
{
if (arbol == NULL)
return 0;
else
{
if (valor == arbol-> valor)
return 1;
else
if (valor < arbol->valor)
return esta(arbol->izq, valor);
else
return esta(arbol->der, valor);
}
}

9a eliminacin de un su(r(ol se reali0a encontrando el nodo ) luego eliminando en forma recursi'a el
su(r(ol -se de+a el e+ercicio al lector/#

@E"4@@I24 2E !$ [@:49
Es posi(le recorrer un r(ol de diferentes maneras# 9os algoritmos ms usuales son >?
6 @ecorrido en pre6order#
6 @ecorrido en in6order#
6 @ecorrido en post6order#
6 @ecorrido por ni'eles#
En todo caso% recorrer un r(ol se trata de 'isitar todos sus nodos# Visitar es un trmino genrico? en los
e+emplos a continuacin 'isitar implica imprimir por pantalla el 'alor del nodo#

Recorri<os en or<en: los tres recorridos mencionados implican una operacin recursi'a? si el r(ol est
'aco% no de(emos ,acer nada# 3i no lo est% ,a) que elegir una secuencia en la cual se 'isite el nodo ra0% )
se recorran los su(r(oles i0quierdo ) derec,o# 2ependiendo cmo se ,aga o(tenemos cada uno de los
recorridos?
Informtica II Apuntes de clase

.re order?
6 Visitar el nodo padre
6 @ecorrer el su(r(ol i0quierdo
6 @ecorrer el su(r(ol derec,o
In 4rder?
6 @ecorrer el su(r(ol i0quierdo
6 Visitar el nodo padre
6 @ecorrer el su(r(ol derec,o
.ost 4rder?
6 @ecorrer el su(r(ol i0quierdo
6 @ecorrer el su(r(ol derec,o
6 Visitar el nodo padre

Veamos el e+emplo en cdigo para el recorrido in6order?
void inorder(t_nodo_bin arbol)
{
if (arbol != NULL)
{
inorder(arbol->izq);
printf("%d - ", arbol->valor);
inoder(arbol->der);
}
}

El recorrido inorder tiene una propiedad interesante? como se recorren primero los nodos menores al nodo
padre% ) luego los ma)ores -) esto ocurre en forma recursi'a para cada su(r(ol/% al in'ocar este recorrido%
la impresin de los nodos se reali0a en forma ordenada#
@E"4@@I24 2E !$ [@:49 .4@ $IVE9E3
@ecorrer un r(ol por ni'eles implica 'isitar primero todos los nodos del ni'el 0% luego todos los nodos del
ni'el 1% ) as sucesi'amente ,asta 'isitar las ,o+as del ltimo ni'el# 3upongamos que 'isitamos los nodos de
i0quierda a derec,a#

Informtica II Apuntes de clase


3i recorremos este r(ol por ni'eles% la impresin nos queda? < 2 10 1 > 11 ; 6 7 #
$o e&iste un algoritmo recursi'o sencillo que nos permita recorrer un r(ol por ni'eles# 3in em(argo% e&iste
uno no recursi'o que utili0a una estructura au&iliar que nos permite ,acerlo#
Imaginemos por un momento que estamos su(iendo una gran familia a un (us# El primero en su(ir es el
a(uelo# "uando este su(e% a'isa a sus ,i+os que ,agan la cola para su(irse al (us# 9os ,i+os ,acen la fila% ) en
turno% cuando cada uno de ellos su(e% a'isa a sus ,i+os que ,agan la cola para su(irse al (us# 3i repetimos
esta situacin ,asta que estn todos en la fila% 'eremos que el orden en que ascienden es el orden
genealgico? primero el a(uelo% luego sus ,i+os% luego los ,i+os del primer ,i+o% luegos los ,i+os del segundo%
etc#
Este algoritmo nos permite recorrer un r(ol por ni'eles% ) se reali0a utili0ando una estructura au&iliar del
tipo cola#

void por_niveles(t_nodo_bin arbol)
{
t_cola cola = {NULL, NULL};
t_nodo_bin nodo_aux = NULL;
queue(&cola, arbol);

while (cola.frente != NULL)
{
nodo_aux = dequeue(&cola);
if (nodo_aux->izq != NULL)
queue(&cola, nodo_aux->izq);
if (nodo_aux->der != NULL)
queue(&cola, nodo_aux->der);

printf("%d -", nodo_aux->valor);
}
}

Informtica II Apuntes de clase

11 - MANE5O DE ARC1I+OS
I$5@42!""IC$
9a definicin tradicional dice que un arc,i'o es el mnimo (loque de informacin que puede almacenarse en
forma permanente en una computadora# Esta definicin 'ara dependiendo del sistema operati'o ) de la
arquitectura de la computadora% pero para los fines prcticos nos es suficiente# !n arc,i'o puede pensarse
como una secuencia de ()tes escritos en un dispositi'o de almacenamiento permanente -disco rgido% "2%
dis\ette###/D posee un nom(re ) una e&tensin% ) se encuentra en una ruta de directorio# .or e+emplo:
.:/0indo1s/s2stem.ini en el sistema operati'o hindoas M. o hindoas Vista% o 3etc3pass1d en 9inu& b !ni&#
9os sistemas operati'os pro'een mecanismos ) utilidades que permiten crear% (orrar ) mo'er arc,i'os% pero
la lectura ) escritura de sus contenidos suele reali0arse con programas especiali0ados# 9os programas )
aplicaciones utili0an arc,i'os cuando desean persistir informacin an cuando no se estn e+ecutando#
!n programa% durante su e+ecucin% puede leer ) guardar datos en arc,i'os# "uando el programa se cierra%
toda la informacin que se encuentra en memoria -tanto en 'aria(les estticas o en estructuras dinmicas/
se pierde# .ero si esta informacin se gra(a en un arc,i'o% la siguiente 'e0 que el programa se e+ecute sta
se ,allar disponi(le% tanto para ser leda como para ser actuali0ada en caso de ser necesario#
E+emplos de usos de arc,i'os?
almacenar un con+unto de registros donde cada uno de ellos representa un alumno#
almacenar una serie de lneas que registran los ingresos por teclado del usuario#
almacenar una serie de resultados de cuentas#
almacenar la configuracin de 'isuali0acin de un listado donde la primer lnea contiene el nmero
de cuntas filas se mostrarn por 'e0% la segunda contiene la longitud m&ima por lnea% ) la tercera
) cuarta indican las letras de inicio ) fin del listado#

5I.43 2E A@"QIV43
9os contenidos de un arc,i'o dependen enteramente del programa que los crea# 9a interpretacin de los
datos dentro del mismo ser ,ec,a de acuerdo al formato en que la informacin es almacenada#
Es ,a(itual distinguir dos tipos de arc,i'os? !inarios -tam(in llamados de acceso aleatorio/ ) de 'eA'o# 9a
principal diferencia entre ellos es que en los arc,i'os de te&to los contenidos son interpretados ()te por
()te como caracteres A3"IID en tanto que en los arc,i'os (inarios no puede sa(erse de antemano qu
significa cada uno de los ()tes que contiene# 9os arc,i'os (inarios ,a(itualmente almacenan un con+unto de
re;is'ros% que son secuencias de ()tes que pueden interpretarse de cierta manera# 9os registros poseen
todos el mismo tamao% ) es esta cualidad la que permite acceder a una posicin especfica del arc,i'o? )a
que sa(emos cuntos ()tes ocupa cada registro% si queremos leer el 10i registro del arc,i'o podemos
,acerlo directamente% )endo al ()te correspondiente# Es por ello que se los llama de acceso aleatorio# .or el
contrario% los arc,i'os de te&to son de acceso secuencial? un arc,i'o de te&to est constituido por lneas
-que finali0an con un retorno de carro o enter/% ) si queremos leer una lnea especfica% tendremos que leer
todas las anteriores )a que posi(lemente la longitud de cada lnea no sea fi+a#
Informtica II Apuntes de clase

4.E@A"I4$E3 E$ A@"QIV43 2E 5EM54
9a operacin de lectura se reali0a de manera secuencial% empe0ando por el primer carcter# El lengua+e "
pro'ee funciones para leer tanto carcter por carcter como lneas completas# 9a operacin de escritura se
reali0a anlogamente% (ien carcter por carcter o escri(iendo lneas completas# En general no se agrega el
carcter Pf0P en ningn lugar% dado que no tiene sentido indicar el fin de una pala(rabfrase# 9a operacin de
actuali0acin de un arc,i'o de te&to es engorrosa -por e+emplo si queremos (orrar una pala(ra de(eramos
despla0ar el resto de los contenidos del arc,i'o para ocupar su espacio/% por lo que en la prctica no se
reali0a -en caso de ser necesario puede escri(irse un nue'o arc,i'o con los contenidos actuali0ados/# 3 es
posi(le agregar informacin a un arc,i'o de te&to% al final del mismo#
4.E@A"I4$E3 E$ A@"QIV43 :I$A@I43
9a operacin de lectura puede ,acerse en forma secuencial% empe0ando por el primer registro% o en forma
aleatoria% posicionando el RcursorR en un ()te determinado ) le)endo a partir de esa posicin# .ara escri(ir
en un arc,i'o (inario agregamos registros al final del mismo% ) si queremos actuali0ar un determinado
registro% tam(in es posi(le ,acerlo# 3i deseamos (orrar un registro% tenemos dos opciones? despla0ar todos
los otros registros de la misma manera en que lo ,aramos con un arc,i'o de te&to% o RmarcarR el registro
con 'alores in'lidos -e incorporar una lgica que nos permita reconocer que ese dato no es 'lido en
nuestro programa/#
B!$"I4$E3 I$"4@.4@A2A3
El lengua+e " nos pro'ee de un con+unto de funciones de manipulacin de arc,i'os para reali0ar todas las
tareas mencionadas anteriormente# Algunas de las funciones son especficas para su uso con arc,i'os
(inarios% otras son especficas de arc,i'os de te&to% ) un tercer grupo es comn a am(as#
No'a "reia: .ara tra(a+ar con las funciones de arc,i'os es necesario incluir la (i(lioteca Ystdio#,Z# En dic,a
(i(lioteca se encuentra la definicin de la estructura que utili0aremos para manipular arc,i'os# 9as
funciones de mane+o de arc,i'os reci(en como parmetro o retornan un puntero a una de estas estructuras
-no es necesario conocer cmo est compuesta sino simplemente usarla/# 9a estructura es llamada BI9E ) en
nuestras funciones ) programas declararemos un puntero BI9E]#
9os prototipos de funciones descriptos a continuacin se modificaron respecto de los originales% a efectos de
simplificar la e&plicacin# 9a lista completa de las funciones de mane+o de arc,i'os puede ser encontrada en
Internet% un (uen lugar para comen0ar es aqu#

A.E@5!@A 2E A@"QI V43 6 B4.E$
9a primera operacin que de(emos reali0ar antes de leer o escri(ir en un arc,i'o% es a(rirlo# A(rir un arc,i'o
significa indicarle al sistema operati'o que nuestro programa quiere ,acer uso del mismo# "uando esto
ocurre% el arc,i'o queda R(loqueadoR% imposi(ilitando que otros programas lo leanbescri(an al mismo
tiempo# El sistema operati'o es el encargado de todo este mane+o#
Informtica II Apuntes de clase

El prototipo de la funcin de apertura es BILEC (o$en0cDarCE cDarC2F fopen retorna un puntero a una
estructura BI9E que de(eremos pasar a las dems funciones de manipulacin de arc,i'os# fopen reci(e 2
parmetros% el primero es el nom(re del arc,i'o que deseamos a(rir% inclu)endo la ruta completa de
acceso% ) el segundo es una cadena de te&to que indica el &o<o <e a$er')ra# "uando a(rimos un arc,i'o%
de(emos indicar lo siguiente?
si deseamos a(rir el arc,i'o en modo lectura -RrR/% en modo escritura -RaR/% o en modo agregar
-RaR/#
si deseamos a(rir el arc,i'o en forma (inaria -R(R/
si deseamos actuali0ar el arc,i'o -ROR/#

En forma prctica% los modos de apertura pueden ser?
RrR A(re en modo lectura un arc,i'o de te&to# 3i el arc,i'o con el nom(re indicado no e&iste% no lo
crea#
RaR A(re en modo escritura un arc,i'o de te&to# 3i el arc,i'o con el nom(re indicado e&iste% es
(orrado#
RaR A(re en modo agregar -append/ un arc,i'o de te&to# 3i el arc,i'o e&iste% no lo (orra#
RrOR A(re en modo lecturaOescritura un arc,i'o de te&to# 3i el arc,i'o no e&iste% no lo crea#
RaOR A(re en modo escrituraOlectura un arc,i'o de te&to# 3i el arc,i'o no e&iste% lo crea# 3i e&iste%
lo (orra#
RaOR A(re en modo agregarOlectura un arc,i'o de te&to# 3i el arc,i'o e&iste% no lo (orra# 3i no e&iste
lo crea#
Rr(R% Ra(R% Ra(R% RrO(R% RaO(R% RaO(R que ,acen lo mismo% pero para arc,i'os (inarios#

En todos los casos% si la apertura del arc,i'o falla% la funcin retorna $!99#
E+emplos?
#include <stdio.h>

int main()
{
FILE* fd = NULL;
...
fd = fopen("C:\\Users\\Alumno\\Documents\\ejemplo.txt", "r");
if (fd == NULL)
printf("El archivo ejemplo.txt no existe");
...

#include <stdio.h>
int main()
{
FILE* fd = NULL;
...
fd = fopen("C:\\Users\\Alumno\\Documents\\ejemplo.dat", "w+b");
if (fd == NULL)
Informtica II Apuntes de clase

// No se pudo crear el archivo en la ruta indicada
printf("El archivo ejemplo.dat no pudo ser abierto");
...


"IE@@E 2E A@"QI V43 6 B"943E
"uando terminamos de ,acer nuestras operaciones de lectura b escritura so(re un arc,i'o% de(emos
indicarle al sistema operati'o que no deseamos seguir utili0ndolo# Esto lo ,acemos para li(erar los recursos
que el sistema operati'o dedica a mantener el arc,i'o a(ierto% ) que de esa manera tanto dic,os recursos
como el arc,i'o en s puedan ser usados por otras aplicaciones#
El prototipo de la funcin de cierre de arc,i'os es oi< (close0BILEC2E ) reci(e como parmetro el puntero a
arc,i'o que oportunamente fue retornado por fopen#
BI$ 2E A@"QIV4 6 BE4B
feof nos permite sa(er si nos encontramos u(icados al final del arc,i'o que estamos le)endobescri(iendo#
9os arc,i'os poseen una Rmarca de fin de arc,i'oR que se encuentra luego del ltimo ()te del arc,i'o#
"uando el RcursorR con el que nos despla0amos por el arc,i'o llega a esta marca% feof retorna 1#
El prototipo de la funcin es in' (eo(0BILEC2F 2e(ido a que es necesario reali0ar una lectura adicional para
encontrar la marca de fin de arc,i'o% una estrategia mu) comn para leer un arc,i'o con un ciclo de
repeticin es la siguiente?

Abrir Archivo
Leer Archivo
while (!feof( archivo ) )
{
Realizar operaciones
Leer Archivo
}
Cerrar Archivo

4tra opcin es preguntar si la operacin de lectura fue e&itosa -las operaciones de lectura retornan cero
cuando no se efectuaron correctamente/
Abrir Archivo
while (!feof( Archivo ) )
{
if (Leer Archivo)
{
Realizar operaciones
}
}
Cerrar Archivo

Informtica II Apuntes de clase


A@"QIV43 2E 5EM54 6 9E"5!@A
.ara leer un arc,i'o de te&to nuestras opciones son? leer un caracter% leer un patrn% o leer una lnea
completa#
9a funcin (;e'c nos permite leer un carcter del arc,i'o ) despla0ar el cursor en 1 posicin# El prototipo de
la funcin es in' (;e'c0BILEC2# "uando fgetc encuentra la marca de fin de arc,i'o% retorna la constante E4B#
5enga en cuenta que el tipo de retorno es int% )a que la constante E4B que se de'uel'e es entera -distinta de
cualquier 'alor de tipo c,ar#/ .or lo tanto el uso correcto de esta funcin es aginar el 'alor de retorno a una
'aria(le de tipo int% luego 'erififcar que esa 'aria(le int sea distinta de E4B% ) en caso afirmati'o% se puede
asignar a una 'aria(le de tipo c,ar ese int% para tratarlo como letrabcarcter#
9a funcin (scan( nos permite leer un patrn determinado de un arc,i'o% ) guardar los contenidos leidos en
una o ms 'aria(les% que se pasan como parmetro# El prototipo de la funcin es in' (scan(0BILECE cDarC E FFF2
# 3e puede utili0ar de la misma manera que se utili0a scanf% con la diferencia que la lectura de ,ace desde el
arc,i'o# fscanf retorna E4B si la lectura falla#
9a funcin (;e's nos permite leer una lnea completa -,asta encontrar el caracter PfnP/ ) guardar los
contenidos en una 'aria(le de tipo c,arEF# El prototipo de la funcin es cDarC (;e's0cDarCE in'E BILEC2# El
primer parmetro es el arreglo donde se almacenar el te&to ledoD el segundo parmetro es la cantidad
m&ima de caracteres a leer -si no se encuentra PfnP antes/% ) el tercer parmetro es el puntero al arc,i'o# El
caracter PfnP se copia a la cadena destino# 9a funcin agrega automticamente un Pf0P al final de la cadena#
@etorna un puntero a la misma cadena% o $!99 si ,u(o algn error o se lleg al final del arc,i'o#

A@"QIV43 2E 5EM54 6 E3"@I5!@A
Anlogamente a la lectura% al momento de escri(ir en un arc,i'o de te&to podemos? escri(ir un caracter%
escri(ir un te&to formateado% o escri(ir una cadena completa#
9a funcin ($)'c nos permite escri(ir un carcter al arc,i'o# 3u prototipo es in' ($)'c0cDarE BILEC2F El primer
parmetro es el arc,i'o a escri(ir ) el segundo es el puntero al arc,i'o# 9a funcin retorna E4B si el carcter
no se pudo escri(ir#
9a funcin ($rin'( nos permite escri(ir un te&to formateado# Es idntica en su funcionamiento a la funcin
printf% pero requiere un parmetro adicional -el arc,i'o donde se quiere escri(ir el te&to/# El prototipo es in'
($rin'(0BILECE cDarCE FFF 2D el primer parmetro es el puntero al arc,i'o% el segundo es la cadena de formato% )
los siguientes parmetros son los que se utili0an para completar la cadena# El 'alor de retorno% en caso que
,a)a ,a(ido un error% es negati'oD de lo contrario es positi'o ) es igual al nmero de caracteres escrito#
9a funcin ($)'s nos permite escri(ir una cadena completa# 3u prototipo es in' ($)'s0cDarCE BILEC2# 3i la
funcin no puede escri(ir% retorna E4B# 5ener en cuenta que si se desea escri(ir 1 lnea% de(emos agregar el
carcter PfnP a la cadena )a que ($)'s no lo ,ar automticamente por nosotros#

Informtica II Apuntes de clase


@E3!*E$ 2E B!$"I4$E3 .A@A A@"QI V43 2E 5EM54

Lec')ra Escri')ra
int fgetc-BI9E]/D int fputc-c,ar% BI9E]/D
int fscanf-BI9E]% c,ar]% ###/D int fprintf-BI9E]% c,ar]% ###/D
c,ar] fgets-c,ar]% int% BI9E]/D int fputs-c,ar]% BI9E]/D

A@"QIV43 :I$A@I43 6 9E"5!@A
.ara leer un arc,i'o (inario% slo tenemos una operacin disponi(le? (rea<# El prototipo de la funcin es in'
(rea<0 oi<CE in'E in'E BILEC2D donde? el primer parmetro es un puntero a una estructura o arreglo de
estructuras donde se 'a a guardar la informacin leda% el segundo parmetro indica el tamao que ocupa
cada registro -generalmente% un si0eof del tipo de datos de la estructura/% el tercer parmetro indica cuntos
registros queremos leer% ) el cuarto parmetro es el puntero al arc,i'o# !na 'e0 producida la lectura% el
RcursorR del arc,i'o se despla0a la cantidad de ()tes ledos# 9a funcin retorna la cantidad de registros
ledos% si retorna menos -o cero/ es o (ien que ,u(o un error% o que se lleg al fin de arc,i'o#
A@"QIV43 :I$A@I43 6 E3"@I5!@A
Anlogamente a la lectura% para escri(ir en un arc,i'o (inario la operacin disponi(le es (Gri'e# El prototipo
de la funcin es in' (Gri'e0 oi<CE in'E in'E BILEC2% donde? el primer parmetro es un puntero a una estructura
o arreglo de estructuras a escri(ir en el arc,i'o% el segundo es el tamao que ocupa cada registro
-generalmente% un si0eof del tipo de datos de la estructura/% el tercero indica cuntos registros queremos
escri(ir% ) el cuarto es el puntero al arc,i'o# 9a funcin retorna la cantidad de registros escritos% si retorna
otro nmero es que se produ+o un error#

@E3!*E$ 2E B!$"I4$E3 .A@A A@"QI V43 :I$A@I43

Lec')ra Escri')ra
int fread-'oid]% int% int% BI9E]/D int farite-'oid]% int% int% BI9E]/D


Informtica II Apuntes de clase

45@A3 B!$"I4$E3 2E *A$E^4 2E A@"QIV43

('ell nos indica la posicin del cursor -en ()tes/ en el arc,i'o# 3lo tiene sentido utili0arla en
arc,i'os (inarios -aunque funcione en arc,i'os de te&to/# 3u prototipo es lon; in' ('ell0BILEC2#
(seeH nos permite despla0ar el cursor del arc,i'o a una posicin especfica dentro del mismo# 3lo
tiene sentido utili0arla en arc,i'os (inarios# 3u prototipo es in' (seeH0BILECE lon; in'E in'2% donde?
o el primer parmetro es el puntero al arc,i'oD
o el segundo parmetro indica cuntos ()tes queremos mo'ernosD
o el tercer parmetro indica desde dnde deseamos reali0ar el despla0amiento# Este
parmetro tiene ; 'alores posi(les? 3EEje"!@ indica que queremos mo'ernos desde la
posicin donde el cursor se encuentra% 3EEje3E5 indica que queremos mo'ernos desde el
principio del arc,i'o% ) 3EEjeE$2 indica que queremos despla0arnos desde el final del
arc,i'o# 5eniendo en cuenta esto% para 3EEje"!@ podemos usar 'alores positi'os o
negati'os% con 3EEje3E5 slo 'alores positi'os o cero% ) con 3EEjeE$2% slo 'alores
negati'os o cero#
o 9a funcin retorna 0 en caso de ser e&itosa% o un 'alor distinto de cero en otro caso#
reGin< nos permite mo'er el cursor ,acia el principio del arc,i'o# 3u prototipo es oi<
reGin<0BILEC2F
o reaind puede considerarse equi'alente a ,acer fsee\- ptrearc,i'o% 0% 3EEje3E5/#
((l)sD nos permite en'iar los datos que se mantienen en (uffer ,acia el arc,i'o# $o tiene sentido
utili0arlo si el arc,i'o se a(ri en modo lectura# En modo escritura% cualquier dato toda'a no
escrito al arc,i'o es en'iado al mismo -los datos que se gra(an con farite se mantienen en un
(uffer para reducir la cantidad de operaciones de Entradab3alida que se e+ecutan/#

También podría gustarte