c2 PDF

1
Captulo 2.
Definicin de Estructuras de Datos en C.

Se desea conocer las tcnicas para disear estructuras de datos. Se repasan los conceptos de
tipos bsicos, para luego desarrollar las herramientas de creacin de nuevas estructuras,
haciendo nfasis en los conceptos de agrupacin y vinculacin. Dando ejemplos que
posteriormente se emplearn en el texto.
2.1. Tipos primitivos.

En los lenguajes de programacin suele disponerse de tipos bsicos o primitivos: caracteres,
enteros con y sin signo, reales o flotantes de simple y doble precisin.
Se dispone la forma de definir e inicializar variables de esos tipos, y tambin la forma de
escribir constantes de esos tipos.
Para los tipos primitivos existen numerosos y variados operadores que permiten construir
expresiones con variables y constantes de dichos tipos. En determinados casos existen
mecanismos automticos para convertir valores de un tipo en otro, sin embargo es preferible la
conversin explcita a travs del molde o cast.
Mediante las bibliotecas de entrada-salida pueden ingresarse o desplegarse valores de esos
tipos.
2.2. Mecanismos de estructuracin.

Existen dos mecanismos bsicos de estructuracin de datos: la agrupacin y la vinculacin.
2.2.1. Grupos bsicos.
La estructura (struct) permite agrupar elementos de diferente tipo. El arreglo agrupa elementos
de igual tipo. El string agrupa caracteres.
Profesor Leopoldo Silva Bijit
20-01-2010
Estructuras de Datos y Algoritmos
Estructura
Arreglo
String
Figura 2.1. Agrupaciones de datos.

Se dispone de una forma de definir variables de esos grupos bsicos, y los mecanismos de
acceso a las componentes: el discriminador del campo (un punto) para las estructuras; y los
parntesis cuadrados o corchetes para delimitar el ndice de la componente del arreglo. Las
operaciones que estn definidas para estos grupos bsicos son muy reducidas, el programador
debe crear sus propias funciones o mtodos para efectuar operaciones ms complejas sobre
estos grupos bsicos. En el caso de strings existe una biblioteca estndar de funciones que los
manipulan (ver Apndice 2).
Las agrupaciones pueden ser tan complejas como sea necesario: ya que es posible crear arreglos
de estructuras, y tambin estructuras que contengan arreglos y strings.
2.2.2. Vnculos.
Pueden establecerse relaciones entre elementos de datos. Los siguientes diagramas ilustran las
formas bsicas de vinculacin: vnculos de orden o secuencia en listas, relaciones jerrquicas en
rboles, e interconexiones complejas en grafos.
rboles
listas
grafos
Figura 2.2. Vnculos entre componentes de datos.

20-01-2010
El vnculo es el elemento de datos de una componente que permite accesar a otra componente.
Una componente puede contener informacin de uno o ms vnculos.
El programador debe disponer de elementos del lenguaje que le permitan crear nuevos tipos de
datos, y mediante estos tipos crear funciones o mtodos que realicen operaciones sobre las
componentes.
Cuando el nmero mximo de componentes es conocido de antemano, las componentes pueden
modelarse como una serie de arreglos agrupados en una estructura. En la cual se emplea uno o
varios arreglos para establecer el o los vnculos entre las componentes. Se suele definir como
cursor a una variable que contiene el valor del ndice de una componente.
Otro mecanismo para establecer vnculos es el puntero, que es una variable que contiene la
direccin de otra componente. La vinculacin a travs de punteros suele emplearse
preferentemente en situaciones dinmicas, en las cuales el nmero de las componentes vara
durante la ejecucin del programa; esto debido a que se crean, insertan y descartan
componentes.
2.3. Ejemplos basados en arreglos.

2.3.1. Acceso a componentes del arreglo.
El acceso a componentes se realiza va indireccin de un puntero constante que es el nombre del
arreglo, con un offset dado por el ndice del elemento.
Se definen tipos de datos.
typedef int Tipo;
/* tipo de item del arreglo */
typedef int Indice; /* tipo del ndice */
Es prctica usual, definir mediante una constante el tamao mximo del arreglo
#define MaxEntradas 10
Se definen e inician con valores dos arreglos
Tipo A[MaxEntradas]={0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
Tipo B[MaxEntradas]={ 10,11,12,13,14,15,16,17,18,19};
A las funciones que manipulan arreglos se les suele pasar el arreglo por referencia.
Por ejemplo la funcin que imprime en una lnea las componentes de un arreglo a.
void mostrar(Tipo *a, Indice inferior, Indice superior)
{
Indice i;
for (i = inferior; i <= superior; i++) printf(" %d ", a[i]);
putchar('\n');
}
Note que el primer argumento de la funcin tambin puede escribirse: Tipo a[].
20-01-2010
Ejemplos de uso:
mostrar(A, 0, 4); imprime 0 1 2 3 4
mostrar(A+2, 0, 4); imprime 2 3 4 5 6
La manipulacin de arreglos no suele verificar el rango del ndice. En el caso de haberse
definido adyacentes los arreglos A y B, la referencia a A[12] est accesando efectivamente a
B[2], por eso se muestra un 12; pero es un error por acceso fuera de rango.
printf(" %d
printf(" %d
printf(" %d
printf(" %d
printf(" %d
\n", A[12]); imprime 12

\n", B[-2]);
imprime 8
\n", A[-1]); imprime cualquier cosa que estuviera almacenada antes de A
\n", 1[-1+B] ); imprime 10
\n", -1[B] ); imprime -11 (es una referencia correcta)
Similares errores pueden generarse accesando componentes indireccionando va puntero:

printf(" %d \n", *(A+12)); imprime 12
printf(" %d \n", *(-2+B)); imprime 8
Los ejemplos anteriores ilustran que el acceso a componentes de un arreglo se efecta mediante
indireccin con el puntero que es el nombre del arreglo.
La expresin: A[c] se interpreta como el contenido de la direccin:
A + c*(tamao del tipo del arreglo).
Donde A es la direccin de la primera componente del arreglo.
Empleando el lenguaje:
A[c] equivale a: *(A+c) y A es equivalente a &A[0].
Definicin de matrices.
Puede definirse una matriz de caracteres, arr, de R renglones y C columnas mediante:
#define R 8 //renglones
#define C 10 //columnas
char arr[R][C];
arr
arr[3][5]
arr[3]
Figura 2.2.a. Matriz de caracteres

20-01-2010
Entonces: arr[3] es el cuarto rengln de la matriz arr, y es un arreglo de C caracteres. Puede

considerarse que arr[3] es la direccin de inicio de ese arreglo; es decir, es un puntero constante
que indica la primera componente de ese arreglo. Puede escribirse, usando notacin de punteros
como: *(arr+3).
La expresin: a[3][5], denota el sexto carcter del cuarto rengln. La cual puede escribirse,
usando notacin con punteros, mediante: * ( *(arr+3) + 5 ).
Puede concluirse que arr es un puntero a un puntero a carcter.
Definicin de arreglo de arreglos.
Empleando definicin de tipos puede crearse el tipo rengln, como un arreglo de C caracteres.
Y mediante este nuevo tipo puede definirse una matriz ar, como un arreglo de renglones.
Definiciones que se muestran a continuacin.
#define R 8 //renglones
#define C 10 //columnas
typedef char renglon[C];
renglon ar[R];
La expresin ar[3] es el cuarto rengln. La expresin: * ( *(ar+3) + 5 ) corresponde al sexto
carcter almacenado en el cuarto rengln, y es equivalente a: ar[3][5].
Con el mismo procedimiento se pueden estructurar organizaciones ms complejas. Por ejemplo
una matriz cuyo contenido sea un arreglo.
Los arreglos aseguran que las componentes quedan adyacentes en memoria. En el caso de
matrices, el ltimo elemento del primer rengln queda adyacente con el primer elemento del
segundo rengln.
Arreglo de punteros a renglones.
Un ejemplo de creacin de estructuras de datos, empleando el lenguaje C, es disear un arreglo
de punteros pt, que apunten a los renglones de una matriz.
pt
ar
(*pt[2])[5]
Figura 2.2.b. Arreglo de punteros a arreglos de caracteres
20-01-2010
Las siguientes declaraciones de tipos y definiciones de variables, crean el espacio que

almacenar a la estructura de datos.
typedef char renglon[C]; //definicin de tipo rengln como un arreglo de C caracteres
typedef renglon * prenglon; //definicin del tipo puntero a rengln
renglon ar[R];
//Matriz de caracteres como arreglo de renglones
prenglon pt[R];
//Arreglo de punteros a los renglones.
Es preciso vincular los punteros del arreglo con los renglones, lo cual se efecta con:
for(i=0; i<R; i++) pt[i]=&ar[i]; //llena arreglo de punteros a renglones.
Entonces: pt[2] contiene un puntero al tercer rengln. Lo cual puede escribirse: *(pt +2 ).
La expresin: *(pt[2]) es el tercer rengln, que en este caso es un arreglo de C caracteres; es
decir: *( *(pt+2)) es el valor del puntero al inicio de ese rengln. Y consecuentemente:
*( *(pt+2)) +5 es el puntero al sexto carcter del tercer rengln.
Finalmente para accesar al elemento ubicado en el tercer rengln y en la sexta columna, debe
indireccionarse el puntero anterior, lo cual puede escribirse: *( *( *(pt+2)) +5), o empleando
notacin de arreglos: (*pt[2])[5] .
Una alternativa a lo anterior es convertir el puntero a rengln en un puntero a carcter, esto se
logra mediante: (char *) pt[2]; entonces el acceso a un carcter, a travs de punteros a renglones
se logra con: ((char*) pt[i])[j].
Arreglo de punteros a caracteres.
Puede lograrse una representacin ms simple, si se almacenan en un arreglo punteros a
caracteres, en lugar de punteros a renglones. Esto puede modelarse segn:
typedef char renglon[C]; //definicin de tipo renglon como un arreglo de C caracteres
renglon ar[R];
// Arreglo de R renglones
char * pch[R];
// Arreglo de punteros a caracteres
Los vnculos de la estructura se producen con:
for(i=0; i<R; i++) pch[i]=(char *) (&ar[i]); //llena arreglo de punteros a char
La expresin: pch[i][j] accesa al carcter ubicado en el rengln (i+1) y en la columna (j+1).
2.3.2. Lista simplemente enlazada en base a cursores.
#define MaxEntradas 4
#define fin_de_lista -1
Con los siguientes datos:
Tipo Valor[MaxEntradas] ={1, 2, 3, 4};
Indice Cursor[MaxEntradas] ={2, 3, 4, fin_de_lista };
Puede visualizarse la siguiente lista.
20-01-2010

1
7
3
Figura 2.3. Lista simplemente enlazada.

Se tiene, como ejemplo, que: Cursor[2] contiene el valor 4 de ndice.
2.4. Ejemplos basados en estructuras.

2.4.1. Estructura para fecha.
Agrupamos mediante la estructura fecha los campos: da, mes, ao.
//molde. Declaracin.
struct fecha
{ int dia;
int mes;
int agno;
};
La declaracin slo establece un molde o patrn para la estructura.
Se denominan instancias o definiciones de variables cuando se asocia un tipo a una variable. La
definicin considera una asignacin de memoria para la variable.
//instancias.
struct fecha fecha1; //definicin.
struct fecha fecha2={1,5,2004}; //definicin e inicializacin
Ntese que se requiere preceder con la palabra struct al nombre del molde.
Tambin se puede establecer una definicin e inicializacin de un puntero a la variable fecha1,
mediante:
struct fecha *ptfecha1=&fecha1;
No puede accederse a los campos de una estructura no iniciada, para lectura.
Se pueden copiar estructuras completas, mediante asignacin:
fecha1=fecha2;
Puede escribirse en un campo determinado:
fecha1.mes=11;
// mediante el selector de campos
ptfecha1->dia=25;
//o a travs del puntero
La forma equivalente, va indireccin del puntero, no suele emplearse:
*(ptfecha1.dia) = 25;
Es preferible crear tipos, previo a la definicin de variables de tipo estructura:
20-01-2010
8
//Definiciones de tipos
typedef struct fecha Fecha;
typedef Fecha * pFecha;

//hay diferencia entre maysculas y minsculas.
//define puntero a elemento de tipo Fecha.
En este mbito, las definiciones de las instancias para las variables, quedan:
Fecha fecha3 = {1, 5, 2004}; //definicin e inicializacin.
pFecha pfecha3=&fecha3;
Observar que las definiciones no son precedidas por struct.
Es preciso crear mtodos para desplegar variables que son estructuras:
Se ilustra pasar el argumento como una estructura. Lo cual implica: crear el espacio y copiar la
estructura en el frame de la funcin:
void printfecha(Fecha f)
//paso por valor
{
printf(" Da = %d Mes = %d Ao = %d \n", f.dia, f.mes, f.agno); //lectura de campos
}
Es preferible pasar una referencia a la estructura, ya que esto ocupa menos espacio en el frame.
Slo es preciso copiar un puntero.
void printfecharef(pfecha p)
//paso por referencia.
{
printf(" Da = %d Mes = %d Ao = %d \n", p->dia, (*p).mes, p->agno);
}
Ejemplos de uso:
printfecha(fecha3);
printfecharef(pfecha3);
Tambin es til disponer de un constructor de la estructura.
Fecha setfecha (int dia, int mes, int agno)
//retorno de estructura
{
Fecha f;
f.dia=dia; f.mes=mes; f.agno= agno; //escritura en campos
return(f);
}
Ejemplo de uso:
fecha3 = setfecha(15, 6, 2005);
Tambin suele ser necesario desarrollar funciones para realizar operaciones de comparacin
entre estructuras. El siguiente prototipo ilustra un operador de comparacin mayor o igual
que, al cual se le pasan punteros a estructuras y devuelve un puntero a la estructura que es
mayor o igual que la otra, el diseo de la funcin se deja como tarea.
pFecha fechaGET(pFecha pf1, pFecha pf2);
20-01-2010
Se pueden crear arreglos de estructuras de tipo Fecha:

Fecha ArrFecha[3]={ {1,1,2005},{30,6,2005},{31,12,2005}};
printf("mes %d \n", (ArrFecha+1)->mes); imprime 6
printf("dia %d \n", ArrFecha[2].dia); imprime 31
Es responsabilidad del programador no exceder los rangos del arreglo.
2.4.2. Lista simplemente enlazada en base a punteros.
Es posible declarar el molde y definir tipos simultneamente.
En esta situacin en lugar de moldenodo se podra haber puesto cualquier otro identificador.
Esta forma suele describirse como declaracin annima.
typedef struct moldenodo
{ int clave;
struct moldenodo *proximo;
} nodo, *pnodo;
//instancias. Definiciones.
nodo nodo1={1,NULL};
pnodo lista=&nodo1;
Las siguientes asignaciones crean los vnculos.
lista->proximo = &nodo2;
nodo2.proximo = &nodo3;
lista
1
nodo1
nodo2
nodo3
Figura 2.4. Lista simplemente enlazada, mediante punteros.

En caso de definir la lista en forma dinmica, slo es preciso definir la variable lista. El espacio
para los nodos se solicita a travs de llamados a malloc; debido a esto los nodos no tienen un
nombre y slo se los puede accesar va punteros.
En el caso del ejemplo, los nodos se han definido en forma esttica, y tienen un nombre de
variable asociado.
20-01-2010
10
2.5. Estructuras ms complejas.

2.5.1. Arreglo de listas.
Pueden concebirse estructuras ms complejas.
Por ejemplo se desea disponer de un arreglo de punteros, donde cada elemento del arreglo es el
inicio de una lista simplemente enlazada.
Consideraremos que cada celda debe estar asociada a un string, donde los strings pueden ser de
diferente largo. Se decide que no es conveniente almacenar los strings como arreglos de
caracteres, esto implicara un tamao fijo para cada arreglo, con lo cual se ocupara mal el
espacio cuando deba almacenarse un string de pequeo largo, y la estructura puede colapsar si el
largo del string es mayor que el tamao mximo del arreglo. Es preferible asociar al nodo de la
lista un puntero a un string, lo cual ocupa un tamao fijo (normalmente los bytes ocupados por
un entero).
Definimos entonces los siguientes tipos:
typedef struct moldecelda
{
char *nombre;
struct moldecelda *next;
} celda, *pcelda;
#define BALDES 10 /* 10 celdas */
static pcelda hashtable[BALDES]; /*tabla punteros */
La palabra static, que precede a la definicin, explcitamente indica que la tabla debe
almacenarse en un segmento esttico de la memoria. Es decir estar disponible, durante toda la
ejecucin del programa.
Se ilustra un ejemplo de la estructura.
ndice
Tabla
String0
0
1
2
.
B-1
String i
String j
String k
Figura 2.5. Arreglo de listas.
20-01-2010
11
Veremos que se pueden desarrollar algoritmos eficientes para buscar strings almacenados en la
tabla, cuando estudiemos tablas de hash.
2.5.2. Arreglo de estructuras.
El siguiente ejemplo de diseo de una estructura de datos, contempla un arreglo en el cual se
califica el estado de cada celda. Suponemos que se almacena un entero, y para describir
lgicamente el estado empleamos la definicin de un tipo enumerativo, que permite el mapeo de
nombres lgicos con enteros. Internamente se emplean enteros, pero el programador puede
referirse a ellos mediante sus nombres equivalentes.
typedef enum {vacio, ocupado, descartado} state;
typedef struct hcelda
{ int clave;
state estado;
} celda;
#define B 10 /* 10 celdas */
static celda hashtab[B]; /*arreglo de celdas */
static int ocupados;
//ocupados de la tabla
El programador puede escribir expresiones en trminos del tipo enumerativo:
(hashtab[i].estado != vacio && hashtab[i].estado != descartado)
2.5.3. Multirboles.
La descripcin de un nodo que pueda tener un nmero variable de punteros que apunten a sus
descendientes no es prctica. Ya que esto implica almacenar los vnculos en un arreglo, y si es
arreglo debe tener un tamao fijo. El cual debe escogerse considerando el mximo nmero de
descendientes que soportar la estructura; mal empleando los recursos en el caso de un nodo sin
hijos, o de nodos con un pequeo nmero de descendientes. Adems siempre estar el riesgo de
que aparezca un nodo con mayor nmero de descendientes que el tamao mximo escogido.
1
2
5
3
6
4
9
10
11
Figura 2.6. Multirbol.
20-01-2010
12
13
12
El esquema anterior ilustra los vnculos. Este ejemplo refuerza el concepto que un vnculo puede
ser un cursor o un puntero.
El nmero variable de los vnculos asociados a un nodo pueden reemplazarse por slo dos
vnculos: uno que relaciona el nodo con el primer descendiente izquierdo, y otro que vincula a
cada nodo con su hermano derecho. Ntese que en cada nivel puede observarse una lista de
nodos que parte del nodo ubicado ms a la izquierda y termina en un vnculo nulo despus del
ltimo descendiente de un nodo.
Figura 2.7. Primer descendiente izquierdo, hermano derecho.

Con esta visualizacin se requieren slo dos vnculos por nodo.
2.5.3.1. Descripcin mediante punteros.
Una representacin mediante punteros requiere definir la estructura del nodo segn:
{
int valornodo;
struct moldenodo *hijoizquierdo;
struct moldenodo *hermanoderecho;
struct moldenodo *padre;
potros * datos_perifricos;
} nodo, *pnodo;
Donde se han definido los tipos asociados al nodo y al puntero a nodo.
Se ha considerado que se almacenar un entero como clave o valor distintivo del nodo. Se ha
agregado un puntero a una estructura que podra almacenar otros datos asociados al nodo, con el
campo datos_perifricos. Tambin se agrega un puntero al padre, ya que esta informacin
reduce el tiempo de buscar al padre de un nodo determinado.
2.5.3.2. Descripcin mediante arreglos de cursores.
Se describe a continuacin los valores que describen el multirbol, de la Figura 2.6, mediante
arreglos de cursores para el Hijo izquierdo y Hermano Derecho. Se ha considerado que un valor
cero indica que no hay hijo izquierdo o hermano derecho o padre; si se desea usar el nodo cero,
podra elegirse -1 como el cursor nulo.
20-01-2010
13
ndice Hijo izquierdo Hermano derecho Padre Clave Otros datos

0
0
0
0
--1
2
0
0
1
-2
5
3
1
2
-3
7
4
1
3
-4
10
0
1
4
-5
0
6
2
6
-6
0
0
2
6
-7
0
8
3
7
-8
0
9
3
8
-9
0
0
3
9
-
Figura 2.8. Multirbol mediante arreglo de cursores.
Se ha agregado un arreglo de cursores para especificar el padre del nodo. Esta informacin
facilita la bsqueda del padre de un nodo dado.
Un diseo de la estructura de datos considera al multirbol como una estructura cuyos campos
son los diferentes arreglos.
#define MAXNODOS 13
struct moldemultiarbol
{
int Hijo_izquierdo[MAXNODOS];
int Hermano_derecho[MAXNODOS];
int Padre[MAXNODOS];
int clave[MAXNODOS];
int dato1[MAXNODOS];
} arbol;
arbol.Hijo_derecho[4] tiene valor 0; lo cual indica que es el ltimo descendiente.
La estructura puede contener ms o menos informacin dependiendo de costo de las
operaciones que se deseen implementar. Por ejemplo si slo se desea conocer la conectividad de
los nodos del multirbol, basta que la estructura aporte informacin para conocer quien es el
padre de cada nodo, con esta descripcin si luego se desea conocer los hijos de cada nodo,
resultar un algoritmo costoso.
2.5.3.3. Descripcin por arreglo de padres.
20-01-2010
14

0
1
4
2
5
10
11
12
Figura 2.9. Multirbol mediante arreglo de padres.

En un ambiente de grafos, es de inters describir un rbol que interconecta todos los vrtices sin
formar circuitos. Se ilustra un rbol de un grafo orientado, en el que se muestra el nmero
asociado a cada vrtice; se ha considerado el vrtice 0, esto debido a que los arreglos en C,
parten de ndice cero.
La informacin que describe el rbol anterior es:
Vrtice
0 1 2 3 4 5 6 7 8 9 10 11 12
Padre del vrtice 0 0 0 0 1 1 2 2 2 3 3 3 3
Figura 2.10 Arreglo de padres.
Empleando lenguaje de programacin, queda:
int PadreDelVertice[MAXNODOS]={0, 0, 0, 0, 1, 1, 2, 2, 2, 3, 3, 3, 3};
2.6. Un ejemplo real de estructuras.

La realidad suele ser ms compleja que los casos idealizados que se exponen en los cursos
bsicos.
El diseo de una estructura ms realista, es la que describe los encabezados de los paquetes
ICMP e IP en un ambiente de red.
Primero se definen dos tipos bsicos, con fines de compatibilidad. Se mapean los tipos del
lenguaje C, a tipos lgicos. Si los tamaos de los tipos bsicos de un compilador para un
procesador especfico son diferentes, basta cambiar el nombre de los tipos bsicos. Toda la
codificacin no es necesario modificarla, ya que queda en trminos de u8_t y u16_t, que son los
tipos usados en el programa.
typedef unsigned char u8_t; //es el tipo byte.
typedef unsigned short u16_t; //el entero de 16 bits
20-01-2010
15
/* The ICMP and IP headers. */

typedef struct {
/* IP header. */
u8_t vhl,
tos,
len[2],
ipid[2],
ipoffset[2],
ttl,
proto;
u16_t ipchksum;
u16_t srcipaddr[2],
destipaddr[2];
/* ICMP (echo) header. */
u8_t type,
icode;
u16_t icmpchksum;
u16_t id,
seqno;
} uip_icmpip_hdr;
Problemas resueltos.
P2.1. Se tiene el siguiente programa:
#include <stdlib.h>
#include <stdio.h>
#define MAX 5
typedef struct nn
{ int i1;
int i2;
struct nn * next;
} nodo, * pnodo;
pnodo lista1=NULL;
pnodo lista2=NULL;
pnodo getnodo(void)
{ pnodo p;
if( (p=(pnodo)malloc(sizeof(nodo)))==NULL) return(NULL); else return(p);
}
void Push(pnodo *ref, int dato1, int dato2)
{ pnodo newnodo;
if ( (newnodo=getnodo( )) == NULL) exit(1);
newnodo->i1 = dato1; newnodo->i2 = dato2; newnodo->next = *ref;
20-01-2010
16
*ref = newnodo;
}
void crealista(void)
{ int i;
for(i=0; i<MAX; i++)
{ Push(&lista1, i, i+1); Push(&lista2, MAX-i, i-1); }
}
pnodo busca(pnodo pp)
{ pnodo qq=NULL;
while (pp !=NULL) {qq = pp; pp = pp->next;}
return (qq);
}
pnodo busca2(pnodo p, int j, pnodo q)
{
if(p !=NULL)
{ while( p->i1 != j ) p = p->next;
if (p != NULL)
while (q !=NULL) { if(p->i2 == q->i1) return(q); q = q->next; }
return (NULL);
}
return(NULL);
}
int main(void)
{ pnodo tt;
crealista();
printf(" %d \n", ( *(busca(lista1)) ).i1);
printf(" %d \n", busca(lista2)->i2);
if( (tt=busca2(lista1, 3, lista2)) !=NULL) printf(" %d \n", tt->i2);
return(0);
}
a) Explicar, empleando un diagrama, el paso por referencia de Push.
b) Diagrama de la estructura despus de ejecutar crealista();
c) Explicar accin realizada por busca.
d) Explicar accin realizada por busca2.
e) Determinar qu imprime el programa.
Solucin.
a) En la funcin crealista, se tiene un ejemplo de uso de Push.
Consideremos el llamado: Push(&lista1, 0, 1).
En la definicin de Push, el primer argumento es un puntero a puntero a nodo.
20-01-2010
17
Dentro de la funcin, la ocurrencia de *ref, denota a la variable, cuya direccin es pasada en la

invocacin a la funcin, en el caso del ejemplo referencia a variable global lista1.
Si *ref, aparece a la derecha, formando parte de una expresin, su valor es el almacenado en
lista1; si aparece a la izquierda, se escribe en la variable lista.
Luego de la invocacin a la funcin, se tiene el siguiente esquema para las variables.
Datos
Stack
Lista1
newnodo
ref
dato1 = 0
dato2 = 1
Figura P2.1.
Ntese que los argumentos son variables almacenadas en el stack, iniciadas con los valores de
los parmetros de la invocacin. La variable local newnodo, al no estar inicializada en su
definicin apunta a cualquier lado. Razn por la cual, conviene definirlas e inicializarlas
simultneamente.
Despus de un llamado exitoso a getnodo(); es decir, malloc asign una estructura en el heap, un
diagrama de la situacin es el siguiente:
Datos
Stack
heap
Lista1
newnodo
i1 = ?
ref
i2 = ?
dato1 = 0
next = ?
dato2 = 1
Figura P2.2.
El resto de la funcin, escribe en los campos de la estructura creada en el heap. Y adems, en
ltimo trmino, sobreescribe en la variable global lista1(en el ejemplo que se analiza).
20-01-2010
18
Datos
Stack
heap
Lista1
newnodo
i1 = 0
ref
i2 = 1
dato1 = 0
next
dato2 = 1
Figura P2.3
Al salir de Push, desaparecen las variables automticas, ubicadas en el stack, y la situacin
queda:
Datos
Stack
heap
Lista1
i1 = 0
i2 = 1
next
Figura P2.4
Si se hubiera pasado solamente un puntero a nodo como referencia, se tendra el diseo:
void Push2(pnodo ref, int dato1, int dato2)

{
pnodo newnodo;
if ( (newnodo=getnodo()) == NULL) exit(1);
newnodo->i1 = dato1;
newnodo->i2 = dato2;
newnodo->next = ref;
ref = newnodo;
}
Y un ejemplo de uso, sera:
Push2(lista1, 0, 1);
Lo cual no es equivalente al diseo anterior. Puede comprobarse efectuando un diagrama.
20-01-2010
19
Las listas con cabecera ( header ) permiten diseos alternativos.

b) Despus de crealista, el espacio queda:
Datos
Lista1
Lista2
heap
i1=4
i1 = 3
i1 = 2
i1 = 1
i1 = 0
i2 = 5
i2 = 4
i2 = 3
i2 = 2
i2 = 1
next
next
next
next
next
i1 =1
i1 = 2
i1 = 3
i1 = 4
i1 = 5
i2 = 3
i2 = 2
i2 = 1
i2 = 0
next
next
next
next
i2 = -1
next
Figura P2.5.
c) A la funcin busca, se le pasa la direccin del primer nodo de la lista. Si la lista es vaca,
retorna un puntero nulo. Si no es vaca, con pp recorre la lista, dejando qq apuntado al nodo
corriente y con pp al prximo. Cuando se llega con pp, al final de la lista, qq apunta al ltimo
nodo de la lista.
d) La funcin busca2 intenta encontrar el valor j en el campo i1 del nodo apuntado por el
argumento p. Si la lista es vaca retorna un puntero nulo; en caso de encontrar el valor j, busca a
partir del nodo apuntado por q, el valor del campo i1 que sea igual al valor del campo i2 del
nodo donde qued apuntando p.
Si lo encuentra, retorna un puntero al nodo que cumple la condicin anterior; en caso contrario,
retorna un puntero nulo.
La invocacin: busca2(lista1, 3, lista2), despus del primer while, deja p apuntando al segundo
nodo de la lista1, el segundo while deja q apuntando al cuarto nodo de la lista2; ya que busca en
sta el valor 4 en el campo i1.
El diseo de la funcin incurre en un error frecuente, en este tipo de problemas. Qu ocurre si
el valor j no se encuentra en ningn campo i1 de la lista apuntada por p?.
Cuando p tome valor nulo, intentar leer p->i1 en las primeras direcciones de memoria, las
cuales suelen pertenecer a un segmento del sistema operativo. Lo ms seguro que la ejecucin
del proceso aborte debido a un error de segmentacin.
Se podra corregir, cambiando:
while( p->i1 != j ) p = p->next;
por:
while ((p != NULL)&&( p->i1 != j )) p = p->next;
Lo cual funciona debido a que el and opera con cortocircuito.
20-01-2010
20
e) En primer trmino imprime el campo i1 del ltimo nodo de la lista1.

Luego el campo i2 del ltimo nodo de la lista2.
Finalmente el campo i2 de la lista 2, cuyo campo i1 es 4; ya que en la lista1, el campo i2 es 4,
cuando el campo i1 es 3.
Imprimira:
0
-1
0
P2.2. Escribir una funcin:
int btoi(char *str, int *pvalor) que convierta un string binario pasado en str (Ej. "110101") a un
entero a ser retornado en pvalor (Ej. 53). La funcin retorna 0 si no hay error y retorna -1 si el
string binario tiene un carcter que no es '0' o '1'.
Nota: 1101 (en binario) = 1x23+1x22+0x21+1x20 = 8 + 4 + 1 = 13 en decimal
/* Uso de la funcion */
#include <stdio.h>
#include <math.h>
#include <string.h>
int btoi(char *str, int *pvalor);
main()
{
int valor=0;
char str[10];
strcpy(str, "110101");
if( !btoi(str, &valor) ) printf("string binario: %s, int:%d\n", str, valor);
}
Solucin.
int btoi(char *str, int *pvalor)
{ int i=0, largo=0, temp=0;
largo = strlen(str) - 1; //ndice del dgito menos significativo
while(i <= largo)
{
if (*(str + i) == '1')
temp += (int) pow(2, largo - i);
//suma las potencias presentes de dos, desde la ms significativa.
else if (*(str + i) == '0') ;
else return -1; //no es 1 0
i++;
}
20-01-2010
21
*pvalor = temp; //retorno por referencia

return 0;
}
Una alternativa es sumar las potencias presentes de dos, desde la menos significativa.
int btoi(char *str, int *pvalor)
{ int i=0, temp=0, pot=1;
i = strlen(str)-1; //ndice del dgito menos significativo
while(i >=0)
{
if (*(str + i) == '1')
{ temp += pot; printf(" %d %d \n",temp, pot);}
else if (*(str + i) == '0') ;
else return -1; //no es 1 0
i--;pot*=2;
}
*pvalor = temp;
return 0;
}
P2.3. Se tiene la siguiente funcin:
char *f1(char *s, int c)
{
while( *s )
{ if( *s == (char) c ) return (char *) s;
s++;
}
return (char *) 0;
}
a) Explicar los cast que se emplean y su necesidad.
b) Qu realiza la funcin.
c) Si se tiene char *string="12345678"; explicar que despliega:
printf("%s\n", f1(string, '3')) ;
Solucin.
El cast (char) c se emplea, debido a que el segundo argumento de la funcin es de tipo entero,
para convertirlo a carcter y efectuar la comparacin con un carcter del string. No es
necesario, ya que por defecto, los valores de tipo carcter son promovidos automticamente a
enteros con signo. Por ejemplo se puede pasar equivalentemente el valor 65 0x45 A. Esto
permite pasar caracteres de control que no son imprimibles, como argumentos. La comparacin
tambin se poda haber explicado segn: ( (int) *s == c ). Es preferible usar cast, de tal modo
de comparar valores de igual tipo.
El cast en return (char *) s; no es necesario, ya que s es de tipo puntero a char.
20-01-2010
22
El cast return (char *) 0; es necesario para retornar un puntero nulo a carcter.

b) Revisa y encuentra la primera ocurrencia del carcter (char) c, en el string apuntado por s;
retornado un puntero al carcter de s que es igual a (char) c. Si el string es nulo, retorna un
puntero nulo a carcter; tambin si no encuentra (char) c en el string.
c) Despliega el string: 345678, seguido de un terminador de lnea, ya que el llamado
f1(string, '3') retorna un puntero al string 345678".
P2.4. Se tiene la siguiente funcin:
int f2(char *s1, char *s2)
{
while( *s1++ == *s2 )
if( *s2++ == '\0' ) return(1);
return(0);
}
a) Explicar que realiza la funcin. Indicando las condiciones en las que retorna un cero o un uno
b) Dar un ejemplo de uso. Definiendo las variables que sean necesarias.
Solucin.
a) Compara dos strings. Retorna 1 slo si los strings son iguales. Reconoce la igualdad de dos
strings nulos. Retorna cero, si los strings son diferentes. Si los caracteres, en la misma
posicin, de s1 y s2 son iguales va recorriendo ambos strings.
Si los primeros caracteres de los strings fuesen iguales, retorna un cero si string s1 es ms corto
que el string s2 (ya que no se cumple la condicin del while); lo mismo sucede si string 1 es ms
largo que el string s2.
b) char *s1="12345678";
char *s2="12345";
if ( f2(s1,s2)==0) printf("no son iguales\n"); else printf("son iguales\n");
P2.5. Se tiene la estructura para un nodo,
con clave de tipo entera y tres punteros a nodo.
clave
p1
p2
p3
a) Definir los tipos: nodo y pnodo (puntero a nodo).

b) Disear, empleando malloc, la funcin con prototipo: pnodo creanodo(int clave); que solicita
espacio e inicializa el nodo con punteros nulos y la clave del nodo con el valor del argumento.
c) Si se tiene la siguiente definicin: pnodo pn; dibujar un diagrama con los datos, luego de
ejecutada la secuencia:
20-01-2010
23
pn=creanodo(5);
pn->p3=pn;
pn->p1=creanodo(3);
pn->p1->p3=pn;
pn->p2=creanodo(8);
pn->p2->p3=pn->p1;
d) Escribir el segmento que forma el siguiente diagrama:

pn
4
p1
6
p2
p3
p1
p2
p3
Figura P2.6.
Solucin.
a)
{ int clave;
struct moldenodo *p1;
} nodo , *pnodo;
b)
pnodo creanodo(int clave)
{ pnodo p;
if ((p = (pnodo) malloc(sizeof(nodo))) == NULL) {
printf ("Memoria insuficiente para crear nodo\n");
exit(1);
}
p->clave=clave;p->p2=NULL;p->p1=NULL;p->p3=NULL;
return(p);
}
c) Los diagramas se ilustran despus de ejecutada la instruccin.
20-01-2010
24

pn=creanodo(5);
pn
5
Figura P2.7.
pn->p3=pn;
pn
5
Figura P2.8.
pn->p1=creanodo(3);
pn
5
Figura P2.9.
pn->p1->p3=pn;
pn
5
Figura P2.10.
20-01-2010
25
pn->p2=creanodo(8);
pn
5
Figura P2.11.
pn->p2->p3=pn->p1;
pn
5
Figura P2.12.
c)
pn= creanodo(6); pn->p2=pn; pn->p3=pn;
pn->p1=creanodo(4); pn->p1->p1=pn->p1;
pn->p1->p3=pn; pn->p1->p2=pn;
20-01-2010
26
pn
4
p1
6
p2
p3
p1
p2
p3
Figura P2.13.
P2.6. Se tiene el siguiente programa.
#include <stdlib.h>
typedef struct nn
{ int x;
struct nn * p;
struct nn * q;
int y;
} t, *pt;
t w, z;
pt px=&w;
void main(void)
{ px->p=&z;
w.q = px->p;
px->q->q=px;
z.p = w.p;
w.x = z.x = 2;
(*px).y = 8;
(*(w.q)).y =9;
px=(pt) malloc(sizeof(t));
px->p=px->q = (pt ) 0;
px->x=px->y=12;
}
Efectuar un diagrama de los datos despus de ejecutar las instrucciones de main.
Solucin.
20-01-2010
27
Antes de main, el espacio de variables puede visualizarse segn:
px
w
z
x
p
p
q
Figura P2.13.
px
w
x
p
px->p =&z
w.q=px->p;
z
x
p
Figura P2.14.
20-01-2010
28
px
w
x
p
px->q->q=px
z
x
z.p=w.p
Figura P2.15.
px
w
x
w.x=z.x=2
(*px).y=8;
z
x 2
p
(*(w.q)).y=9
y
Figura P2.16.
20-01-2010
29
px
px =(pt)malloc(sizeof(t));
w
x
p
x
12
p
y
q
8
q
z
12
x 2
px ->p=px->q=(pt)0;
p
y
q
9
px ->x=px->y=12;
Figura P2.17.
Ejercicios propuestos.
E1. Determinar qu imprimen los siguientes segmentos:
a ) printf(\n%o %x %d, 17, 017, 0x17) ;
b) n = 3 ; printf(-05d %5d, n, n) ;
c) x = 1234E-2 ; printf(%6.3f, x) ;
d) j =2; if ( ( '1' -1 ) == --j ) printf("verdad"); else printf("falso");
E2. Colocar parntesis y evaluar las expresiones siguientes:
Si es preciso puede indicar los resultados de expresiones intermedias.
a) a != b && c + 1 == ! c + 2
con a1) a=2 ; b=3 ; c = 1;
a2) a=3 ; b=2 ; c=2 ;
b) 1 + 2 * ( n += 8) / 4
con n=3 ;
c) a < b ? a < b ? a+1 : a+2 : a+3 con a=2 ; b= 3 ;
20-01-2010
30
E3. Se tiene el siguiente programa:

Qu efecta la funcin, indicar tipo de parmetros.
Escribir el prototipo y dnde debe ubicarse en el programa.
Qu escribe el programa principal.
void main()
{ int i=11, j ;
j = funcion( i++, 5) ; printf(\n%d %d, j, i);
j = funcion( j+i, j-3) ; printf(\n%d %d, j, i);
}
int funcion( int x, int y)
{
int s,t ;
for( s=0 ; x != 0 ; x--) for ( t=0 ; t != y ; s++,t++) ;
return( s ) ;
}
E4. Escribir programa.
a) Que genere los primeros 20 nmeros de la secuencia: 1, 4, 7, 10, 14, ....
b) Que genere b elementos de la secuencia a partir del a-simo. Leer a y b.
E5. Indicar que escribe el programa.
#include <stdio.h>
int func(int *, float *, char);
void show();
float f1=1, f2=2.2;
int i1=2, i2;
void main()
{
i2 = func(&i1, &f2, '1'); show();
i1 = func(&i2, &f1, '2'); show();
for(;;);
}
void show()
{ printf("\ni1= %d i2= %d" ,i1,i2);
printf("\nf1= %f f2= %f",f1, f2); }
int func(int *i, float *f, char ch)
{
*f = (float)(*i+2); *i = (int)(*f)+2; printf("\n%c ", ch);
return(*i+2);
}
20-01-2010
31
E6. Indicar qu imprime el programa.

#include <stdio.h>
int a[5];
int i;
void arreglo(int j){ for(i=0;i<5; a[i]=j+i, i++); }
void show(void){for(i=0;i<5;i++) printf(" %3d" , a[i]); printf("\n");}
void main(void)
{ arreglo(1), show();
arreglo(2), show();
arreglo(a[2]+*a+3), show();
while(1);
}
Indicar qu efecta cada funcin.
#include <stdio.h>
void prt(int);
void f2(int&);
void f1(int&);
void main(void)
{ int i=1024;
prt(i);
i = 0x10; f1(i); prt(i);
i = -1; f2(i); prt(i);
}
void f1(int& i)
{ i = (i | 0x8000); }
void f2(int& i)
{ i = (i>>1); i = (i&0x7fff); }
void prt(int i)
{ int j;
for (j=15; j>=0; j--)(1<< j ) &i ? printf( '1') : printf( '0'); printf( '\n');
}
#include <stdio.h>
int f1(int& , int);
int f2(int *, int);
void main()
20-01-2010
32
{ int k, m =1;
k = f1(m,5); printf(%d \n %d , k, m);
k = 2; m = 3;
m= f2(&m, m); printf(%d \n, m );
k = 4; m = 6;
k = f1( m, f1(m,3)+5 ); printf(%d \n %d \n, k, m);
}
int f1(int&i , int j)
{ j = j+i ; i = i+j; return(i+j); }
int f2(int *i, int j)
{ *i = j+2+*i; return(j+*i); }
E9. Indicar qu escribe el programa.
#include <stdio.h>
struct punto{
int x;
int y;
};
struct molde{
int a[2];
char c;
punto p; };
void main()
{
molde m1={{2,4},'p',{3,5}}, m2={{5,6},'q',{7,1}};
molde *pm=&m2;
int *pi=&(m1.p.y);
printf(%d \n, *pi ) ;
printf(%d \n, cout << m2.a[1] + m1.p.x );
printf(%d \n, pm->a[1] + pm->p.x );
printf(%d \n , *(pi-1)) ;
pi = &m2.a[0];
printf(%d \n , *(pi+1));
}
E10. Determinar la salida.
#include <stdio.h>
int f2(int x, int y, int z)
{int i;
for(i=0; i<x; i++) y+=z;
20-01-2010
33
return(y);
}
int main(void)
{
printf("%d ", f2(5, 3, 2));
return(0);
}
#include <stdio.h>
int arr[10];
void f1(int x, int *y)
{ int i;
for(i=0; i<x; i++) *(y+i) = i;
}
{ int i;
for(i=0; i<x; i++) printf("%d, ", *(y+i));
putchar('\n');
}
int main(void)
{
f1(5, arr); f2(5, arr);
return(0);
}
#include <stdio.h>
int arr[10];
int *pi;
#define NULL ( (char *) 0)
{int i;
for(i=0; i<x; i++) *(y+i)=i;
}
int *f2(int x, int *y, int z)
{ int i;
for(i=0; i<x; i++) if(*(y+i)== z ) return(y+i);
return((int *) NULL);
}
20-01-2010
34
int main(void)
{
f1(5, arr); pi=f2(5, arr, 8);
if(pi!=((int *) NULL)) printf("%d ", *pi); else printf("no se encuentra\n");
return(0);
}
#include <stdio.h>
E13. Explicar que realizan las funciones.
void prtlong(unsigned long int i)
{ int j; unsigned long int k; k=1L;
for (j=31; j>=0; j--) if((k<<j)&i) putchar(1); else putchar(0);
}
void prtint(int i)
{ int j, k=1;
for (j=15; j>=0; j--) if( (k<<j)&i ) putchar(1); else putchar(0);
}
void sp(int i) { int j; for(j=i; j>0;j--) putchar( ); }
void lrs(int *p, int *q)
{
int k,m;
k=(*p)&0x0001; m=(*p)&0x8000;
(*p)>>=1; if(m) *p=(*p)&0x7fff;
(*q)>>=1; if(k) *q=(*q)|0x8000;else *q=(*q)&0x7fff;
}
void ars(int *p, int *q)
{ int k,m;
extern int s;
k=(*p)&0x0001; m=(*q)&0x0001;
(*p)>>=1;(*q)>>=1;if(k) *q=(*q)|0x8000; else *q=(*q)&0x7fff; s=m;
}
E14. Describir un multirbol
Mediante un arreglo de listas de los hijos de cada nodo. El arreglo debe tener una entrada por
cada nodo, adems considerar que la raz pueda se cualquier nodo.
20-01-2010
35
ndice general.
CAPTULO 2. ............................................................................................................................................ 1
DEFINICIN DE ESTRUCTURAS DE DATOS EN C......................................................................... 1
2.1. TIPOS PRIMITIVOS. ............................................................................................................................. 1
2.2. MECANISMOS DE ESTRUCTURACIN. ................................................................................................. 1
2.2.1. Grupos bsicos. ......................................................................................................................... 1
2.2.2. Vnculos. .................................................................................................................................... 2
2.3. EJEMPLOS BASADOS EN ARREGLOS. ................................................................................................... 3
2.3.1. Acceso a componentes del arreglo. ........................................................................................... 3
Definicin de matrices. .................................................................................................................................... 4
Definicin de arreglo de arreglos. .................................................................................................................... 5
Arreglo de punteros a renglones. ..................................................................................................................... 5
Arreglo de punteros a caracteres. ..................................................................................................................... 6
2.3.2. Lista simplemente enlazada en base a cursores. ....................................................................... 6

2.4. EJEMPLOS BASADOS EN ESTRUCTURAS. ............................................................................................. 7
2.4.1. Estructura para fecha. ............................................................................................................... 7
2.4.2. Lista simplemente enlazada en base a punteros. ....................................................................... 9
2.5. ESTRUCTURAS MS COMPLEJAS....................................................................................................... 10
2.5.1. Arreglo de listas. ..................................................................................................................... 10
2.5.2. Arreglo de estructuras. ............................................................................................................ 11
2.5.3. Multirboles. ........................................................................................................................... 11
2.5.3.1. Descripcin mediante punteros. ........................................................................................................ 12
2.5.3.2. Descripcin mediante arreglos de cursores. ...................................................................................... 12
2.5.3.3. Descripcin por arreglo de padres. .................................................................................................... 13
2.6. UN EJEMPLO REAL DE ESTRUCTURAS. .............................................................................................. 14

PROBLEMAS RESUELTOS. ........................................................................................................................ 15
P2.1. Se tiene el siguiente programa: ............................................................................................... 15
P2.2. Escribir una funcin: ............................................................................................................... 20
P2.3. Se tiene la siguiente funcin: ................................................................................................... 21
P2.4. Se tiene la siguiente funcin: ................................................................................................... 22
P2.5. Se tiene la estructura para un nodo, ........................................................................................ 22
P2.6. Se tiene el siguiente programa. ................................................................................................ 26
EJERCICIOS PROPUESTOS. ....................................................................................................................... 29
E1. Determinar qu imprimen los siguientes segmentos: ................................................................ 29
E2. Colocar parntesis y evaluar las expresiones siguientes: ........................................................... 29
E3. Se tiene el siguiente programa: .................................................................................................. 30
E4. Escribir programa. ..................................................................................................................... 30
E5. Indicar que escribe el programa. ................................................................................................ 30
E6. Indicar qu imprime el programa. ............................................................................................. 31
E7. Indicar qu imprime el programa. .............................................................................................. 31
E8. Indicar qu imprime el programa. .............................................................................................. 31
E9. Indicar qu escribe el programa. ................................................................................................ 32
E10. Determinar la salida. ................................................................................................................ 32
20-01-2010
36

E13. Explicar que realizan las funciones. ..........................................................................................34
E14. Describir un multirbol .............................................................................................................34
NDICE GENERAL. ....................................................................................................................................35
NDICE DE FIGURAS. ................................................................................................................................36
ndice de figuras.
FIGURA 2.1. AGRUPACIONES DE DATOS. ........................................................................................................2
FIGURA 2.2. VNCULOS ENTRE COMPONENTES DE DATOS. ............................................................................2
FIGURA 2.2.A. MATRIZ DE CARACTERES ......................................................................................................4
FIGURA 2.2.B. ARREGLO DE PUNTEROS A ARREGLOS DE CARACTERES ........................................................5
FIGURA 2.3. LISTA SIMPLEMENTE ENLAZADA................................................................................................7
FIGURA 2.4. LISTA SIMPLEMENTE ENLAZADA, MEDIANTE PUNTEROS. ...........................................................9
FIGURA 2.5. ARREGLO DE LISTAS. ...............................................................................................................10
FIGURA 2.6. MULTIRBOL. ..........................................................................................................................11
FIGURA 2.7. PRIMER DESCENDIENTE IZQUIERDO, HERMANO DERECHO. .......................................................12
FIGURA 2.8. MULTIRBOL MEDIANTE ARREGLO DE CURSORES. ..................................................................13
FIGURA 2.9. MULTIRBOL MEDIANTE ARREGLO DE PADRES........................................................................14
FIGURA 2.10 ARREGLO DE PADRES. .............................................................................................................14
FIGURA P2.1. ...............................................................................................................................................17
FIGURA P2.2. ...............................................................................................................................................17
FIGURA P2.3 ................................................................................................................................................18
FIGURA P2.4 ................................................................................................................................................18
FIGURA P2.5. ...............................................................................................................................................19
FIGURA P2.6. ...............................................................................................................................................23
FIGURA P2.7. ...............................................................................................................................................24
FIGURA P2.8. ...............................................................................................................................................24
FIGURA P2.9. ...............................................................................................................................................24
FIGURA P2.10. .............................................................................................................................................24
FIGURA P2.11. .............................................................................................................................................25
FIGURA P2.12. .............................................................................................................................................25
FIGURA P2.13. .............................................................................................................................................26
FIGURA P2.13. .............................................................................................................................................27
FIGURA P2.14. .............................................................................................................................................27
FIGURA P2.15. .............................................................................................................................................28
FIGURA P2.16. .............................................................................................................................................28
FIGURA P2.17. .............................................................................................................................................29
20-01-2010

c2 PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

c2 PDF

Încărcat de

Drepturi de autor:

Formate disponibile

1

Definicin de Estructuras de Datos en C.

2.1. Tipos primitivos.

2.2. Mecanismos de estructuracin.

Profesor Leopoldo Silva Bijit

Estructuras de Datos y Algoritmos

Figura 2.1. Agrupaciones de datos.

Figura 2.2. Vnculos entre componentes de datos.

Definicin de Estructuras de Datos en C.

2.3. Ejemplos basados en arreglos.

Estructuras de Datos y Algoritmos

\n", A[12]); imprime 12

Similares errores pueden generarse accesando componentes indireccionando va puntero:

Figura 2.2.a. Matriz de caracteres

Definicin de Estructuras de Datos en C.

Entonces: arr[3] es el cuarto rengln de la matriz arr, y es un arreglo de C caracteres. Puede

Figura 2.2.b. Arreglo de punteros a arreglos de caracteres

Profesor Leopoldo Silva Bijit

Estructuras de Datos y Algoritmos

Las siguientes declaraciones de tipos y definiciones de variables, crean el espacio que

Profesor Leopoldo Silva Bijit

Definicin de Estructuras de Datos en C.

Figura 2.3. Lista simplemente enlazada.

2.4. Ejemplos basados en estructuras.

Estructuras de Datos y Algoritmos

Profesor Leopoldo Silva Bijit

Definicin de Estructuras de Datos en C.

Se pueden crear arreglos de estructuras de tipo Fecha:

Figura 2.4. Lista simplemente enlazada, mediante punteros.

Profesor Leopoldo Silva Bijit

Estructuras de Datos y Algoritmos

2.5. Estructuras ms complejas.

Figura 2.5. Arreglo de listas.

Profesor Leopoldo Silva Bijit

Definicin de Estructuras de Datos en C.

Figura 2.6. Multirbol.

Profesor Leopoldo Silva Bijit

Estructuras de Datos y Algoritmos

Figura 2.7. Primer descendiente izquierdo, hermano derecho.

Profesor Leopoldo Silva Bijit

Definicin de Estructuras de Datos en C.

ndice Hijo izquierdo Hermano derecho Padre Clave Otros datos

Profesor Leopoldo Silva Bijit

Estructuras de Datos y Algoritmos

Figura 2.9. Multirbol mediante arreglo de padres.

2.6. Un ejemplo real de estructuras.

Profesor Leopoldo Silva Bijit

Definicin de Estructuras de Datos en C.

/* The ICMP and IP headers. */

Estructuras de Datos y Algoritmos

Definicin de Estructuras de Datos en C.

Dentro de la funcin, la ocurrencia de *ref, denota a la variable, cuya direccin es pasada en la

Profesor Leopoldo Silva Bijit

Estructuras de Datos y Algoritmos

void Push2(pnodo ref, int dato1, int dato2)

Definicin de Estructuras de Datos en C.

Las listas con cabecera ( header ) permiten diseos alternativos.

while ((p != NULL)&&( p->i1 != j )) p = p->next;

Lo cual funciona debido a que el and opera con cortocircuito.

Profesor Leopoldo Silva Bijit

Estructuras de Datos y Algoritmos

e) En primer trmino imprime el campo i1 del ltimo nodo de la lista1.

Definicin de Estructuras de Datos en C.