15/10/2015

HolaMundo.pascal(online):Captulo7
0

Ms Siguienteblog

Crearblog Acceder

Publicaciones del Autor

.pas

.c

.java

7 DE AG O STO DE 2 0 0 7

Captulo 7
...

Estructuras De Datos Dinmicas

Hasta aqu hemos trabajado con estructuras y tipos de datos estticos. Variables, arrays,
todos ellos definidos en un momento anterior a la ejecucin del algoritmo.
Los arrays (por ejemplo) son una coleccin de variables del mismo tipo asignadas en posiciones
consecutivas de memoria. Pero la cantidad mxima de elementos que pueden contener debe
fijarse previamente, al momento de definir el array en la seccin type o var.
En este captulo analizaremos tipos de datos dinmicos que nos permitirn alocar memoria
dinamicamente para almacenar informacin a medida que en nuestro algoritmo lo vayamos
necesitando.
>> Click para Ms Informacin <<

Punteros y Alocacin Dinmica de Memoria

En cualquier parte de nuestro programa podemos alocar memoria dinamicamente para
almacenar datos de cualquier tipo: integer, real, string, registros, etc. Pero claro, para
poder acceder a esa seccin de memoria necesitaremos conocer su direccin. As, entra en
juego un nuevo tipo de datos: el puntero.
Un puntero es una variable capz de contener una direccin de memoria. A travs del puntero
podemos acceder al espacio de memoria que este direcciona para asignar valores u operar con
ellos.

Recursos / Download
SZDelphi (por JDownloader)
Instalacin y uso de Delphi
Plantilla de Diagramas p/Visio
Contenidos

1 Introduccin

Veamos un ejemplo:

2 Operadores

testPtr.pas

3 Procedimientos y Funciones

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

4 Corte de Control
//lavariablepesdetipo^integer
//Esdecir:pesunpunteroainteger
varp:^integer;
begin
//alocamemoriaparaunintegery
//asignaladireccionenp
new(p);
//asignaelvalor10alcontenidodep
p^:=10;
writeln('Elcontenidodepes:',p^);
end.

En el ejemplo definimos la variable p de tipo "^integer" (lase "sombrero integer"). Esto

significa que p es una variable en la cual podemos asignar la direccin de memoria de un
integer. O simplemente: p es un puntero a integer.

5 Arrays
6 Archivos de Registros
7 Estructuras Dinmicas
8 Arboles y Recursividad
9 Teora de Objetos (intro)
EjemplosResueltos
Ahora en Video!

Para alocar la memoria necesaria para almacenar un nmero entero (2 bytes) utilizaremos la
funcin de Pascal new. Esta funcin aloca memoria y le asigna al puntero que recibe como
parmetro la direccin de la memoria alocada.
Por ltimo, para asignar un valor en la memoria que acabamos de alocar (en este caso el valor
10) tenemos que hacerlo a travs del puntero. p es el puntero y p^ (lase "p sombrero") hace
referencia al espacio de memoria direccionado por p por lo tanto la asignacin p^:=10 asigna
el valor 10 al integer que alocamos dinamicamente.
Resumiendo:
p es un puntero, contiene una direccin de memoria.
p^ ("p sombrero") es la memoria direccionada por p.

El ejemplo anterior tambin podramos haberlo escrito de la siguiente manera.

http://holamundopascal.blogspot.mx/2007/08/capitulo7.html

Acerca del Autor

Ing. Pablo A. Sznajdleder
Agradecimientos

1/11

15/10/2015

HolaMundo.pascal(online):Captulo7
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:

type
//lasvariablesdetipoPInteger
//seranpunterosainteger
PInteger=^integer;
//lavariablepesdetipoPInteger
varp:PInteger;
begin
//alocamemoriayasignaladireccionap
new(p);
p^:=10;

No al blog de Java

Super Baterista

writeln('Elcontenidodepes:',p^);
end.

La nica diferencia es que en este caso definimos un nuevo tipo de datos (en la seccin type):
type
...PInteger = ^integer;
Luego, la variable p de tipo PInteger tambin queda definida como un puntero a integer.

Sitios Relacionados
PascAlgo (por Lic. Hugo Cuello)
Algoritmia.net

Por convensin utilizaremos el prefijo P para identificar tipos que definan punteros. PInteger,
PString, etc.

Java Algorithm Framework

Estructuras Dinmicas
Utilizando punteros podemos crear dinamicamente distintos tipos de colecciones de elementos.
A cada elemento de la coleccin lo llamaremos nodo.
Un nodo es un registro (definido en la seccin type) que contiene campos para almacenar
informacin ms un campo especial para almacenar la direccin de memoria del prximo nodo
de la coleccin.

El grfico muestra una lista (coleccin) de nodos. Una seccin del nodo almacena informacin
(info) y la otra un puntero (ptr) o referencia al siguiente nodo en la lista. Tambin vemos un
puntero p que apunta al primer nodo de la lista.
Analizaremos algunas de las diferentes estructuras dinmicas que podemos conformar a partir
de enlazar nodos.
Cada estructura dinmica se compone de una coleccin de nodos relacionados entre si y de un
conjunto de operaciones.

Lista Enlazada
Este es el caso ms simple. Se trata de un conjunto de nodos donde cada nodo contiene la un
puntero al prximo nodo de la lista.
Analizaremos una lista de enteros (integer).

El grfico muestra que existe un puntero p que apunta al primer nodo de la lista. Cada nodo
contiene un valor entero y una referencia al nodo siguiente. El ltimo nodo tiene un valor nulo
representado por una crz. En Pascal el valor nulo se representa con NIL.
Las operaciones bsicas que podemos aplicar sobre una lista son las siguientes:
agregar Agregar un nodo al final de la lista.
insetarOrdenado Agregar un nodo en la posicin que corresponda para mantener la
lista ordenada.
buscar Buscar el nodo que contenga un valor determinado.
buscarEInsertarOrdenado Idem. anterior pero si no existe ningn nodo con el valor
que buscamos entonces crearlo e insertarlo ordenado.
eliminar Eliminar el nodo que contenga cierto valor.
liberar Eliminar toda la lista y liberar la memoria alocada.

http://holamundopascal.blogspot.mx/2007/08/capitulo7.html

2/11

15/10/2015

HolaMundo.pascal(online):Captulo7
Analizaremos la unidad (unit) untListas.pas en la que definiremos los tipos Nodo, PNodo y los
prototipos e implementaciones de los procedimientos y funciones necesarios para trabajar con
las listas.
untListas.pas
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:

unituntListas;
interface
type
//eltipoPNodorepresentaunpunteroaNodo
PNodo=^Nodo;
Nodo=record
//campoparaalmacenarelvalorentero
info:integer;
//referenciaalsiguientenododelalista
sig:PNodo;
end;
//agregaunnodoconelvalorespecificado
//alfinaldelalista,silalistaesta
//vacia(lst=NIL)leasignaelprimernodo
procedureagregar(varlst:PNodo;valor:integer);
//insertaunnodoconelvalorespecificado
//manteniendoelordenascendentedelalista
//retornaunpunteroalnodoqueinserto
functioninsertarOrdenado(varlst:PNodo
;valor:integer):PNodo;
//buscaelvalorespecificado.Siexisteentonces
//retornaunpunteroalnodoquelocontieney
//asignatruealparametroencontrado.Sino
//entoncesinserta(ordenado)unnodoconel
//valor,asignafalsealparametroencontrado
//yretornaunpunteroalnodoinsertado
functionbuscarEInsertarOrdenado(
varlst:PNodo
;valor:integer
;varencontrado:boolean):PNodo;
//buscaunvalorenlalista.Siloencuentra
//retornaunpunteroalnodoquelocontiene,
//sinoloencuentraretornaNIL
functionbuscar(lst:PNodo;valor:integer):PNodo;
//eliminayliberaelnodoquecontenga
//elvalorespecificado
procedureeliminar(varlst:PNodo;valor:integer);
//recorrelalistaliberandotodoslosnodos
procedureliberar(varlst:PNodo);
implementation
//:
//laseccionimplementationsedesarrolla
//masabajo...
//:

Definimos el tipo Nodo con dos campos: info (para almacenar un valor entero) y sig para
almacenar la direccin del prximo nodo de la lista.
A continuacin analizaremos cada uno de los procedimientos y funciones descriptos en la
seccin interface de untListas.

procedure agregar(var lst:PNodo; valor:integer)

El objetivo de este procedimiento es agregar un nuevo nodo al final de la lista. Para esto
debemos recorrer la lista hasta llegar al ltimo nodo (identificado por tener NIL en su campo
sig) y asignarle en el campo sig la direccin del nuevo.
Podemos distinguir un caso especial: que pasa si la lista an no existe (no tiene ningn
elemento)? En este caso el valor del parmetro lst ser NIL y entonces debemos asignar a lst la
direccin del nuevo nodo. Por tal motivo recibimos el parmetro lst con var (por referencia).
Veamos el algoritmo:

http://holamundopascal.blogspot.mx/2007/08/capitulo7.html

3/11

15/10/2015

HolaMundo.pascal(online):Captulo7

Leyendo paso a paso el algoritmo vemos que se crea un nuevo nodo al principio. Como la
consigna es agregar este nodo al final de la lista podemos asegurar que este nodo ser el
ltimo. Por eso tendr NIL en el campo sig. Luego preguntamos si el parmetro lst es NIL. Si
esto es as estamos en el caso en que la lista est vacia. An no tiene elementos. Por lo tanto
el nodo que recin creamos adems de ser el ltimo ser el primero y (entonces) debe ser
apuntado por el parmetro lst (este parmetro se recibe por referencia).
En el caso en que lst es distinto de NIL necesitamos recorrer la lista para llegar al ltimo nodo.
Para esto utilizamos una variable aux en la que asignamos el valor del primer nodo (lst) y
luego dentro de un while le asignamos su prximo valor. As, cuando su prximo valor sea NIL
cortamos el ciclo iterativo y en aux tendremos un puntero al ltimo nodo de forma tal que
haciendo aux^.sig:=nuevo estaremos enlazando el nuevo nodo al final de la lista.
untListas.pas (implementacin: procedure agregar)
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:

procedureagregar(varlst:PNodo;valor:integer);
varnuevo,aux:PNodo;
begin
//creoelnodoainsertar
new(nuevo);
nuevo^.info:=valor;
nuevo^.sig:=NIL;//vaalfinal...sig=>NIL
//lalistanotieneelementosaun
if(lst=NIL)thenbegin
//elnuevonodoenrealidadseraelprimero
lst:=nuevo;
endelsebegin
//recorrolalistahastallegaralfinal
aux:=lst;
while(aux^.sig<>NIL)dobegin
aux:=aux^.sig;
end;
//saleporqueelsiguientedeauxesNIL
//(auxeselultimo)entoncesenlazoel
//nuevonodocomosiguientedeaux
aux^.sig:=nuevo;
end;
end;

function insertarOrdenado(var lst:PNodo; valor:integer):PNodo

Esta funcin debe insertar un nuevo nodo en la lista pero ordenado en forma ascendente.
Retorna un puntero al nodo que insert.
Debemos analizar los diferentes casos:
que la lista no contenga elementos an, entonces el nuevo nodo ser el primer
elemento.
que el valor a insertar sea anterior al primer elemento de la lista
que el valor a insertar deba ser insertado en el medio de la lista
que el valor a insertar sea el ltimo elemento de la lista
En este caso comenzaremos analizando el cdigo Pascal y luego desarrollaremos el diagrama.

http://holamundopascal.blogspot.mx/2007/08/capitulo7.html

4/11

15/10/2015

HolaMundo.pascal(online):Captulo7
untListas.pas (implementacin: function insertarOrdenado)
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:

functioninsertarOrdenado(varlst:PNodo
;valor:integer):PNodo;
varaux,ant,nuevo:PNodo;
begin
//creamoselnodoainsertar
new(nuevo);
nuevo^.info:=valor;
//ahoraloscasosposiblesson:
//1lalistaestavacia,lstesNIL
//2elvalorainsertaresanterioral1ro.
//3elvalorainsertaresmayorquetodos
//4elvalorainsertarvaenelmedio
//caso1:lalistaestavacia,elnuevoesel1ro.
if(lst=NIL)thenbegin
//nuevoeseluniconodo...notienesiguiente
nuevo^.sig:=NIL;
//asignoladirecciondenuevoalst
lst:=nuevo;
//lafunciondeberetornaelpuntero
//alnodoinsertado
insertarOrdenado:=nuevo;
//finalizalafuncionaqui...
exit;
end;
//caso2:elvalorainsetaresmenorqueel1ro.
if(valor<lst^.info)thenbegin
//elnuevoseraelprimeroentonces
//elsiguientedelnuevodebeserlst
//recordemosquelsthastaahoraesel1ro...
nuevo^.sig:=lst;
//modificolstparaqueeliniciodelalista
//ahoraseaapartirdelnuevonodo
lst:=nuevo;
//lafuncionretornaelputeroalnodo
//insertado
insertarOrdenado:=nuevo;
//finalizaaqui
exit;
end;
//sillegamoshastaestepuntoentoncessolo
//existendosposibilidades:loscasos3y4
aux:=lst;
ant:=NIL;
//recorrolalistamientrasnoencuentreunnodo
//cuyovalorseamayorynoselleguealfinal
while((aux<>NIL)AND(aux^.info<=valor))dobegin
ant:=aux;
aux:=aux^.sig;
end;
//siauxesNILentoncesfinalizolalistay
//ningunvalorresultomayorqueelquetenemos
//queinsertarentoncesagregamosalfinal
if(aux=NIL)thenbegin
ant^.sig:=nuevo;//antapuntaalultimo
nuevo^.sig:=NIL;//nuevoahoraeselultimo
endelsebegin
//saliodelwhileporqueencontroun
//valormayorentoncesinsertamosel
//nodoentreelanterioryelmayor
ant^.sig:=nuevo;
nuevo^.sig:=aux;
end;
//lafuncionretornaelvalordelnuevonodo
insertarOrdenado:=nuevo;
end;

Analicemos los dos primeros casos. Si lst es NIL entonces la lista an no existe y valor debe ser
el elemento del primer nodo de la lista. Por lo tanto nuevo^.sig debe ser NIL y lst debe
apuntar al nuevo nodo.
Notemos que luego de esto utilizamos la sentencia exit. Esta sentencia finaliza la llamada a la
funcin por lo tanto el resto del cdigo ser ejecutado solo si el programa no cumpli con la
condicin anterior (lst = NIL).
Luego preguntamos si valor es menor que lst^.info. Si esto se cumple estamos ante el caso en
el que el valor a insertar es anterior al primer elemento de la lista. Para enlazarlo
correctamente asignamos nuevo^.sig:=lst y luego a lst (primer nodo de la lista) lo hacemos

http://holamundopascal.blogspot.mx/2007/08/capitulo7.html

5/11

15/10/2015

HolaMundo.pascal(online):Captulo7
apuntar a nuevo. Tambin utilizamos la sentencia exit para indicar que la funcin debe
finalizar all.
El resto de la funcin solo se ejecutar si no se verific ninguna de las dos condiciones
anteriores. Es decir: los dos primeros casos estn descartados.
Sabiendo que la lista no es nula y que el valor a insertar no debe insertarse antes que el
primero entonces vamos a recorrer la lista mientras todos los elementos sean menores o
iguales a valor y (obviamente) mientras no lleguemos al ltimo nodo.
Utilizamos una variable ant para guardar el nodo actual, antes de avanzar al siguiente nodo de
la lista. As, si al avanzar nos encontramos con NIL entonces en ant tendremos el puntero al
ltimo.
Cuando finalizamos el while preguntamos por cual de las dos condiciones finaliz. Si aux es
NIL entonces lleg el ltimo nodo y todos los nodos fueron menores o iguales al nodo a
insertar. En este caso tenemos que agregar el nuevo nodo al final de la lista. Para esto
asignamos a ant^.sig:=nuevo y (dado que nuevo ser el ltimo nodo) a nuevo^.sig:=NIL.
Recordemos que ant apunta al ltimo nodo, por lo tanto estamos enlazando el nuevo nodo al
final de la lista.
Si aux es distinto de NIL entonces encontramos un nodo cuyo valor es mayor al valor que
queremos insertar. Tenemos que insertarlo entre aux y el nodo anterior (ant). Esto lo hacemos
asignando a ant^.sig:=nuevo y nuevo^.sig:=aux.

Para resolver esta funcin utilizamos la sentencia exit para descartar los posibles casos a
medida que los vamos resolviendo. Esta metodologa se llama "programacin por descarte". Y
es muy til para este tipo de problemas.
Si no hubiramos utilizado la sentencia exit tendramos que utilizar if (ifes) anidados lo cual
(para mi gusto) es demasiado engorroso.
Ahora si, veamos el diagrama.

function buscar(lst:PNodo; valor:integer):PNodo

Para buscar un elemento en la lista utilizaremos una funcin. La funcin buscar recibe el
puntero al primer elemento de la lista (lst) y el valor a buscar. Recorre la lista y si encuentra
un nodo cuyo campo info sea igual a valor entonces retorna el puntero a ese nodo. Si no (no se
encuentra el valor en la lista) retorna NIL.

http://holamundopascal.blogspot.mx/2007/08/capitulo7.html

6/11

15/10/2015

HolaMundo.pascal(online):Captulo7

Simplemente iteramos mientras el elemento actual sea distinto de valor y mientras no

lleguemos al final de la lista. Cuando finaliza el while tenemos el valor de retorno. Si el
while finaliz porque aux^.info=valor entonces encontramos el nodo que buscbamos. Si el
while finaliz porque aux=NIL entonces el valor que buscamos no se encuentra en la lista.
En cualquier caso, siempre aux ser el valor que debemos devolver en la funcin.
untListas.pas (implementacin: function buscar)
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

functionbuscar(lst:PNodo;valor:integer):PNodo;
varaux:PNodo;
begin
aux:=lst;
while((aux<>NIL)AND(aux^.info<>valor))dobegin
aux:=aux^.sig;
end;
buscar:=aux;
end;

procedure eliminar(var lst:PNodo; valor:integer)

Este procedimiento busca un valor en la lista apuntada por lst. Si lo encuentra lo elimina de la
lista. Si el valor no existe en lista entonces no hace nada.

Recorremos la lista mientras no lleguemos al ltimo nodo y mientras no encontremos el valor

que estamos buscando. La variable aux apunta al nodo actual en la iteracin y la variable ant

http://holamundopascal.blogspot.mx/2007/08/capitulo7.html

7/11

15/10/2015

HolaMundo.pascal(online):Captulo7
apunta al nodo anterior.
Cuando corta el ciclo iterativo preguntamos si cort porque encontramos el elemento que
buscbamos, ya que si no lo encontramos no tenemos nada que hacer.
Si aux^.info es igual a valor encontramos el elemento y aux es el nodo que debemos eliminar,
pero antes de hacerlo nos tenemos que asegurar de que dejaremos bien enlazada la lista.
Si ant es distinto de NIL significa que aux no es el primer nodo de la lista. Entonces tenemos
que asignar a ant^.sig el valor de aux^.sig. Luego liberamos (con la funcin de Pascal
dispose) el nodo aux.
Si ant es NIL entonces el valor que buscamos lo encontramos en el primer nodo. Es decir:
tenemos que modificar el valor del parmetro lst para hacerlo apuntar al segundo nodo. Es
decir: a aux^.sig. Por este motivo recibimos el parmetro lst por referencia. Luego si,
liberamos aux.
untListas.pas (implementacin: procedure eliminar)
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:

procedureeliminar(varlst:PNodo;valor:integer);
varaux,ant:PNodo;
begin
aux:=lst;
ant:=NIL;
//recorromientrasnolleguealfinaly
//mientrasnoencuentreelvalorquebusco
while((aux^.sig<>NIL)AND(aux^.info<>valor))
dobegin
ant:=aux;
aux:=aux^.sig;
end;
//sisalioporqueseencontroelvalorbuscado
if(aux^.info=valor)thenbegin
//elvalorseencontroporelmediodelalista
if(ant<>NIL)thenbegin
//elsiguientedelanteriordebeapuntar
//alsiguientedelquevamosaeliminar
ant^.sig:=aux^.sig;
endelsebegin//elnodoaeliminaresel1ro.
//eliniciodelalistadebeapuntaral
//segundonodo(elsiguientedelprimero)
lst:=aux^.sig;
end;
//liberamoselnodo
dispose(aux);
end;
end;

procedure liberar(var lst:PNodo)

El objetivo de este procedimiento es liberar todos los nodos de la lista enlazada. Simplemente
recorremos la lista y liberamos el nodo actual (apuntado por aux).
La nica precaucin que debemos tener es guardar en alguna variable temporal la direccin del
prximo nodo antes de liberar el nodo actual porque una vez liberado no tendremos forma de
acceder al siguiente. Para esto usamos la variable auxSig.

http://holamundopascal.blogspot.mx/2007/08/capitulo7.html

8/11

15/10/2015

HolaMundo.pascal(online):Captulo7
El cdigo es el siguiente:
untListas.pas (implementacin: procedure liberar)
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

procedureliberar(varlst:PNodo);
varauxSig,aux:PNodo;
begin
//recorremoslalista
aux:=lst;
while(aux<>NIL)dobegin
//guardamoselsiguiente
auxSig:=aux^.sig;
//liberamoselactual
dispose(aux);
//avanzamosalsiguiente
aux:=auxSig;
end;
end;

Utilizar Listas para Indexar Archivos

As como estudiamos la implementacin del ndice de un archivo sobre arrays, si el archivo no
est acotado (no sabemos cuantos registros puede llegar a tener) podemos utilizar una lista
enlazada para implementar su ndice.
Consideraremos el mismo tipo de registro (REmpleado) que utilizamos en el captulo de
archivos y analizaremos un programa que recorre el archivo, lo indexa y luego permite al
usuario consultar el archivo por el campo legajo.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:

type
//tipoderegistrodelarchivo
REmpleado=record
legajo:integer;
nombre:string[20];
end;

//tipodearchivo
FEmpleado=fileofREmpleado;

//punteroanodoindice
PNodoIdx=^NodoIdx;

//nodoindice
NodoIdx=record
legajo:integer;
pos:integer;//nohabramasde32767registros
sig:PNodoIdx;
end;

http://holamundopascal.blogspot.mx/2007/08/capitulo7.html

9/11

15/10/2015

HolaMundo.pascal(online):Captulo7
El programa principal abre el archivo y lo indexa llamando al procedimiento
indexarEmpleados. Luego simplemente pide legajos al usuario, los busca invocando a la
funcin buscar, (y si la funcin no retorn un valor negativo) posiciona el puntero en el
archivo, lee el registro y muestra los resultados. Por ltimo libera la lista con el
procedimiento liberar.
El procedimiento indexarEmpleados recibe el puntero al inicio de la lista y el archivo
(abierto). Lo recorre hasta el eof e insertaOrdenado en la lista.

Las modificaciones respecto de las funcines estudiadas ms arriba son de tipo de datos. Para
resolver este problema utilizamos punteros de tipo PNodoIdx y los valores a buscar e insertar
los consideramos de tipo REmpleado.

Algoritmos y Estructuras de Datos UTN UBA.

Publicado por PabloSZ

5 comentarios:
Annimo dijo...
Hay un error en el diagrama para eliminar nodo, dentro de while, en la asignacion del
puntero "ant", se lo vuelve a poner en NIL, en lugar de aux.
Saludos
PD: Estaria bueno que publiques esta guia y lo vendas como cuadernillo oficial,
siempre que llegues a un acuerdo con la gente el CEIT.

http://holamundopascal.blogspot.mx/2007/08/capitulo7.html

10/11

15/10/2015

HolaMundo.pascal(online):Captulo7
22 noviembre, 2007 13:36
Pablin dijo...
Hola me harias el favor de explicarme o subir un codigo como ejemplo para crear una
lista anidada (una lista dentro de otra lista, ya sea en un nodo de la misma o como
parte de un campo de un registro) y si posee restricciones este tipo de estructura.
Millones de gracias por todo lo q tenes esta muy completo el Blog y mas q nada por
tomarte la molestia de leer el comentario...
28 junio, 2008 16:42
Annimo dijo...
Hay manera de que pueda hacer que compile el free pascal con el edit pad pro en
ubuntu?
si alguien sabe por favor que me ayude.
Gracoas.
24 noviembre, 2008 07:13
Annimo dijo...
hola Pablo, soy Hernan Ceballos (telmex).
te quera preguntar, si en los finales de algoritmos de la utn, a la hora de invocar a un
procedimiento bastante genrico como ser el procedure "insertaOrdenado", por ms
que cambien los elementos a enviar (no las estructuras) hace falta detallar cada
insertaOrdenado, o si solo basta con llamar a uno genrico.
Osea a lo que me refiero es,
tengo dos listas con estructuras diferentes:
*insertaOrdenado(lstAlumnos,regAlu.nom,regAlu.ape)*
*insertaOrdenado(lstNotas,regNotas.nCruso)*
hace falta que defina los dos procedure "insertaOrdenado" o con solo tener uno de la
siguiente manera alcanza:
* insertaOrdenado(var lst Pnodo,reg) *

desde ya muchas gracias!

PD: me compre el librito tuyo, esta barbaro, lastima que los del ceit no se tomaron el
tiempo de vectorizar o al menos dejarle la misma calidad a los diagramas, pero fuera
de eso, muy bueno.

hernan
15 diciembre, 2008 23:48
Pablo dijo...
hola. acabo de leer la guia que tienes de pascal y me parcio interesante, pero tengo
un problema con un proyecto que hago. necesito introducir 10 alumnos con 3 notas
cada alumno y de esas 3 notas sacar los promedios de cada uno de los alumnos. ya
tengo todo el programa armado pero no se como acumular esas 3 notas de cada
alumno y sacar sus respectivos promedios. quisiera a ver que conejo me `puedes dar
con respecto a eso. gracias.....
13 febrero, 2009 13:39
Publicar un comentario en la entrada

Entrada ms reciente

Pgina principal

Entrada antigua

Suscribirse a: Enviar comentarios (Atom)

Todos los Derechos Reservados Propiedad Intelectual Nro. 591212

http://holamundopascal.blogspot.mx/2007/08/capitulo7.html

11/11