Anda di halaman 1dari 112

UNIVERSIDAD SALESIANA

DE BOLIVIA
CARRERA INGENIERIA DE SISTEMAS

DOSSIER
PROGRAMACION II
Tercer Semestre

Lic. Katya Maricela Prez Martnez


Lic. Gladys Francisca Chuquimia Mamani
Lic. Carmen Rosa Mollinedo Laura

INDICE
1.

CAPTULO I...........................................................................................1

INTRODUCCIN A LAS ESTRUCTURAS DE DATOS...........................................1


1.1.
INTRODUCCIN................................................................................................ 1
1.2.
ESTRUCTURAS FUNDAMENTALES.....................................................................1
1.3.
ABSTRACCIN.................................................................................................. 2
1.4.
DEFINICIN DE ESTRUCTURAS DE DATOS........................................................2
1.5.
T.D.A. (TIPO DE DATO ABSTRACTO)..................................................................3
1.6.
CLASIFICACIN DE LAS ESTRUCTURAS DE DATOS...........................................3
1.6.1. ESTRUCTURAS DE DATOS ESTTICAS...........................................................4
1.6.2. ESTRUCTURAS DE DATOS DINMICAS..........................................................4
1.6.3. ESTRUCTURAS DE DATOS LINEALES.............................................................4
1.6.4. ESTRUCTURAS DE DATOS NO LINEALES.......................................................4
1.7.
ESTRUCTURAS DE DATOS ESTTICAS...............................................................4
1.7.1. ARREGLOS................................................................................................... 4
1.7.2. ARREGLOS UNIDIMENSIONALES (VECTORES)...............................................5
1.7.3. Declaracin de vectores...............................................................................5
Ejercicios................................................................................................................. 6
EJERCICIOS PROPUESTOS........................................................................................8
1.7.4. CADENAS DE CARACTERES...................................................................................10
1.7.5. LOS METODOS DE LA CLASE STRING.............................................................11
1.8.
ARREGLOS MULTIDIMENSIONALES..................................................................18
1.8.1. Matrices..................................................................................................... 18

DECLARACIN DE UNA MATRZ..................................................................................19

OPERACIONES CON ARREGLOS BIDIMENSIONALES...........................................................20


1.9.
REGISTROS (ESTRUCTURAS)..........................................................................21
1.9.1. DEFINICIN DE REGISTRO Y DECLARACIN DE LA VARIABLE DE REGISTRO.
22
1.9.2. ACCESO A LOS CAMPOS DE UN REGISTRO.................................................22
1.9.3. ARRAYS DE ESTRUCTURAS:........................................................................24
1.9.4. ESTRUCTURAS ANIDADAS:.........................................................................24
1.10. CONJUNTOS.................................................................................................... 26
1.10.1. DEFINICIN DE CONJUNTOS...................................................................26
1.11. MATRICES POCO DENSAS...............................................................................27
1.12. ARCHIVOS...................................................................................................... 30
2.

CAPTULO II........................................................................................35

PILAS....................................................................................................... 35
2.1.
INTRODUCCIN.............................................................................................. 35
2.2.
REPRESENTACIN DE LAS PILAS....................................................................36
2.3.
ESTRUCTURA DE UNA PILA UTILIZANDO ARREGLOS.......................................37
2.4.
OPERACIONES CON PILAS..............................................................................38
2.5.
IMPLEMENTACIN DEL TAD PILA EN LENGUAJE JAVA.......................................38
2.6.
APLICACIONES................................................................................................ 42
2.6.1. LLAMADAS A SUBPROGRAMAS...................................................................43
........................................................................................................................ 44
2.6.2. RECURSIN................................................................................................44
2.6.3. TRATAMIENTO DE EXPRESIONES ARITMTICAS..........................................44
3.

CAPTULO III
3.1.

COLAS.........................................................................47

INTRODUCCIN.............................................................................................. 47

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 2

3.2.
CARACTERSTICAS.......................................................................................... 48
3.3.
REPRESENTACIN DE LAS COLAS..................................................................48
3.4.
ESTRUCTURA DE UNA COLA IMPLEMENTADO MEDIANTE ARREGLOS..............49
3.5.
OPERACIONES CON COLAS.............................................................................49
Insertar un elemento en la cola:............................................................................50
Eliminar un elemento de la cola:...........................................................................50
COLAS LINEALES.......................................................................................50
3.6.
3.7.
3.8.
3.9.
3.10.
4.

CAPTULO RECURSIVIDAD....................................................................60
4.1.
4.2.
4.3.
4.4.
4.5.
4.6.
4.7.
4.8.

5.

COLAS CIRCULARES.......................................................................................53
OPERACIONES CON COLAS CIRCULARES..................................................................54
EJERCICIOS CON COLAS CIRCULARES.............................................................56
COLAS DE PRIORIDADES................................................................................57
APLICACIN DE PILAS Y COLAS......................................................................58
INTRODUCCIN.............................................................................................. 60
AMBITO DE APLICACIN:................................................................................60
RAZONES DE USO:......................................................................................... 60
EN QU CONSISTE LA RECURSIVIDAD?.........................................................61
FORMA DE ENFRENTAR PROBLEMAS RECURSIVOS.........................................61
TIPOS DE RECURSIVIDAD...............................................................................63
LA PILA DE RECURSION..................................................................................64
LA LLAMADA A UNA FUNCIN........................................................................65

CAPITULO IV LISTAS ENLAZADAS.........................................................67


5.1.
INTRODUCCIN A LAS ESTRUCTURAS DE DATOS DINMICA..........................67
5.2.
MECANISMOS PARA ENLAZAR INFORMACIN.................................................68
5.3.
LISTAS ENLAZADAS........................................................................................68
5.4.
TIPO DE DATO ABSTRACTO NODO..................................................................70
5.5.
CONSTRUCCIN DE UN TAD LISTA ENLAZADA LINEAL SIMPLE.......................70
5.6.
OPERACIONES BSICAS SOBRE LISTAS ENLAZADAS.......................................71
Creacin de una lista vaca...................................................................................71
a) Insercin al Final de la lista............................................................................71
b)
Insercin al Inicio de la lista..........................................................................72
d) Eliminar el nodo del inicio de la Lista............................................................73
e) Eliminar el nodo del Final de la Lista.............................................................74
5.7.
IPLEMENTACIN EN EL LENGUAJE JAVA DE LA CLASE LISTAS LINEALES..........74
5.8.
LISTAS DOBLEMENTE ENLAZADAS.................................................................78
5.9.
LISTAS CIRCULARES DOBLES..........................................................................81

6.

CAPITULO VI RBOLES Y GRAFOS........................................................84


6.1.
6.2.
6.3.
6.4.
6.5.
6.6.
A.
A.
A.
A.
6.7.
6.8.
6.9.

DEFINICIN RBOL......................................................................................... 84
CONCEPTOS BSICOS....................................................................................84
CARACTERSTICAS DE LOS ARBOLES BINARIOS..............................................86
TRANSFORMACIN DE UN ARBOL GRAL. EN UN ARBOL BINARIO...................87
REPRESENTACIN DE UN RBOL EN MEMORIA..............................................87
CLASIFICACIN DE ARBOLES BINARIOS..........................................................88
B. DISTINTO....................................................................................................... 89
B. SIMILARES..................................................................................................... 89
B. EQUIVALENTES..............................................................................................89
B. COMPLETOS.................................................................................................. 89
RECORRIDO DE UN ARBOL BINARIO...............................................................90
ARBOLES ENHEBRADOS.................................................................................91
ARBOLES BINARIOS DE BSQUEDA................................................................91

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 3

6.10.
6.11.
6.12.
6.13.
6.14.
6.15.

GRAFOS.......................................................................................................... 92
DEFINICIONES BSICAS..................................................................................92
REPRESENTACIN EN MEMORIA SECUENCIAL................................................94
REPRESENTACIN EN MEMORIA ENLAZADA...................................................94
OPERACIONES SOBRE GRAFOS.......................................................................96
CAMINO MNIMO............................................................................................. 98

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 4

1. Captulo I

Introduccin a las Estructuras De Datos

Escribir en C o C++ es como utilizar un sierra elctrica sin ningn tipo de proteccin.
Escribir en C o C++ es como utilizar un sierra elctrica sin ningn tipo de proteccin.

Bob Gray
Bob Gray

1.1. INTRODUCCIN
Para procesar informacin en un computador es necesario hacer una
abstraccin de los datos que tomamos del mundo real, abstraccin en el
sentido de que se ignoran algunas propiedades de los objetos reales, es
decir, se simplifican. Se hace una seleccin de los datos ms
representativos de la realidad a partir de los cuales pueda trabajar el
computador para obtener unos resultados.
Cualquier lenguaje suministra una serie de tipos de datos simples, como
son los nmeros enteros, caracteres, nmeros reales. En realidad
suministra un subconjunto de stos, pues la memoria del ordenador es
finita. Los punteros (si los tiene) son tambin un tipo de datos.

El

tamao de todos los tipos de datos depende de la mquina y del


compilador sobre los que se trabaja.

1.2. ESTRUCTURAS FUNDAMENTALES


Los datos a procesar por una computadora se clasifican en:
Simples
Estructurados
Los datos simples ocupan slo una casilla de memoria, por tanto una
variable simple hace referencia a un nico valor a la vez.

Los datos Estructurados o Compuestos se caracterizan por el hecho


de que con un nombre (identificador de variable estructurada) se hace
referencia

un

grupo

de

casillas

de

memoria.

Tiene

varios

componentes.
Cabe hacer notar que en el presente texto, se tomar como herramienta para los
Cabe hacer notar que en el presente texto, se tomar como herramienta para los
programas y representar las diferentes estructuras de datos el Lenguaje C++ y
programas y representar las diferentes estructuras de datos el Lenguaje C++ y
Java.
Java.
Ejemplos:
Dato Simple
Declaramos una variable A de tipo entero y asignamos el valor 25.
A
int A;
A = 25;

Identificador

25

Dato Estructurado
Declaramos un dato compuesto o estructurado A que tendr 5 elementos de
tipo

entero.

int A[5] ;
A = {20,30,40,50,60};

A =

20 30 40 50 60

Identificador

1.3. ABSTRACCIN
Una abstraccin es un proceso mental donde se extraen rasgos
esenciales de algo para representarlos por medio de un lenguaje grfico
o escrito.

1.4. DEFINICIN DE ESTRUCTURAS DE DATOS

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 2

Una estructura de datos es cualquier coleccin de datos organizados


de tal forma que tengan asociados un conjunto de operaciones
para poder manipularlos.

1.5. T.D.A. (TIPO DE DATO ABSTRACTO)


Al disear una estructura de datos con la tcnica de abstraccin pasa a
ser un TDA, que:
Puede implementarse en cualquier lenguaje
Puede aplicarse en cualquier concepto
Ejemplo: Abstraemos el concepto Estudiante
ESTUDIANTE

Nombre del TAD


Elementos

Operaciones
o mtodos

Ru: entero
Nombre: Cadena
Sexo: carcter
Direccion: Cadena
LeerDatosEstudiante ()
ImprimirDatosEstudian
te ()
ModificarDireccion()
CalcularNotaFinal()

Como se puede notar existe una operacin No Permitida denominada:


CalcularNotaFinal(); que no debiera estar presente en el TAD, debido a
que no se cuenta con elementos que nos permitan realizar esta
operacin.
Recuerda en todo momento que slo deben incluirse las
operaciones

que

puedan

trabajar

con

los

elementos

que

contiene el TAD.

1.6. CLASIFICACIN DE LAS ESTRUCTURAS DE DATOS


Las estructuras de datos desde el punto de vista de asignacin de
memoria, se clasifican en:
Estructuras de datos estticas
[Estructura de Datos]
Lic. Katya Perez Martinez

Page 3

Estructuras de datos dinmicas


Tambin pueden ser clasificadas en:
Estructuras Lineales
Estructuras No Lineales
1.6.1. ESTRUCTURAS DE DATOS ESTTICAS

Son aquellas en las que el tamao ocupado en memoria se define antes


de que el programa se ejecute y no puede modificarse dicho tamao
durante la ejecucin del programa. Por ejemplo tenemos a los Arreglos,
Registros y Conjuntos.
1.6.2. ESTRUCTURAS DE DATOS DINMICAS

Las estructuras dinmicas de datos son estructuras que cuya dimensin


puede crecer o disminuir durante la ejecucin del programa. Por
ejmplos: Listas Enlazadas, rboles y Grafos.
1.6.3. ESTRUCTURAS DE DATOS LINEALES

Las estructuras de datos lineales se derivan de-l concepto de secuencia.


Primero se definen las secuencias como conjuntos de elementos entre
los que se establece una relacin de predecesor y sucesor. Los
diferentes TADs basados en este concepto se diferenciaran por las
operaciones de acceso a los elementos y manipulacin de la estructura.
Desde el punto de vista de la informtica, existen tres estructuras
lineales especialmente importantes: vectores, las pilas, las colas y las
listas.
1.6.4. ESTRUCTURAS DE DATOS NO LINEALES

Se denominan estructuras de datos No Lineales porque a cada elemento


le pueden seguir varios elementos o puede estar rodeado de elementos.
Por ejemplo: rboles, Grafos y Matrices

1.7. ESTRUCTURAS DE DATOS ESTTICAS


1.7.1. ARREGLOS

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 4

Definicin: Coleccin finita, homognea y ordenada de elementos.


Finita: Porque todo arreglo tiene un lmite. Homognea: Porque todos los
elementos son del mismo tipo. Ordenada: Porque se puede determinar
cul es el ensimo elemento.
Un arreglo tiene dos partes: Componentes e ndices

C1
i0

C2
i1

Componentes

Cn
iN

Indices

Componentes: Hacen referencia a los elementos que forman el arreglo.


ndices: Permiten referirse a los componentes del arreglo en forma
individual.
1.7.2. ARREGLOS UNIDIMENSIONALES (VECTORES)

Son los arreglos ms simples y constan de un solo ndice, tambin se


llaman vectores.
Notacin: Podra ser de diferentes maneras. Por ejemplo:
Array [0...9] de enteros: Vector
Vector: C

C=

30
0

50
1

elemento
70
60
2 8

Identificador
Indice

Donde, C hace referencia a todo el vector, mientras que los ndices


hacen referencia a los elementos en forma individual.
1.7.3. Declaracin de vectores

En Java
Para declarar un Array se utilizan corchetes para indicar que se trata de
un Array y no de una simple variable de tipo especificado. Su sintaxis es:
[Estructura de Datos]
Lic. Katya Perez Martinez

Page 5

Tipo_dato identificador[ ];

O bien:
Tipo_dato [ ] identificador;

Donde:
Tipo_dato: es el tipo de datos de los elementos del vector.
Identificador: es el nombre del vector.
Luego, se debe crear el Array con el operador new, de la siguiente
manera:
Identificador = new tipo [ cantidad_de_elementos ];

Por ejemplo:

public class Array


Archivo:
{
Array.java
public static void main (String arg [])
{
int losValores [];
losValores = new int [10];
losValores [0] = 100;
System.out.println (losValores [0]);
}
}
El programa: Array.java, trabaja con el vector losValores, que
almacena un mximo de 10 elementos enteros.
Implementacin del TAD Vector
Este es el diseo del TAD vector que maneja nmeros enteros.

VECTOR
V[15]: Entero
N: Entero
[Estructura de Datos]
Lic. Katya Perez Martinez

leedim()
leervector()
mostrarvector()

Page 6

Ejercicios
A continuacin se muestra la implementacin de este TAD en Java.
//ARCHIVO VECTOR.JAVA
import java.io.*;
public class Vector

En
{ lenguaje
static java:
int v[];
static int n;
static InputStreamReader Caracteres;
static BufferedReader Buffer;
static String dato;
static void leedim () throws IOException
{
System.out.println ("Cuantos elementos insertara en el Vector? ");
dato = Buffer.readLine ();
n = Integer.parseInt (dato);
}
static void leervector () throws IOException
{
int i;

for(i=0; i < n; i++)


{ System.out.println("Ingrese elemento "+ i + " = ");
dato = Buffer.readLine();
v[i] = Integer.parseInt(dato);
}

static void mostrarvector () throws IOException


{
int i;
for(i=0; i < n; i++)
{ System.out.print(v[i] + "

");

}
}
public static void main (String [] args) throws IOException
{
v = new int[15];
Caracteres = new InputStreamReader (System.in);
Buffer = new BufferedReader(Caracteres);
leedim ();

leervector();
[Estructura
de Datos]

mostrarvector();
Lic. Katya Perez
Martinez
}
}

Page 7

EJERCICIOS PROPUESTOS
1. Se almacena en un vector las cosechas de lechugas durante 6
meses, se pide : Leer la cantidad de plantas de lechuga
cosechadas por mes.
C es el vector que tiene en cada mes una cantidad de
plantas de lechuga cosechadas, como se ve a continuacin:
15 75 23 55 85 13
1
2
3
4
5 6
a. Imprimir la cosechas mayores a 50 plantas por mes
La salida como la siguiente:
MES COSECH
A
2
75
4
55
5
85
b. Sabiendo que cada planta de lechuga cuesta 4Bs, se pide
hallar cuanto ha ganado el productor cada mes por su
cosecha, y luego mostrar el total ganado en los 6 meses.
La salida como la siguiente:
MES COSECH
COSTO
A
BS
1
15
60
2
75
300
3
23
92
4
55
220
5
85
340
[Estructura de Datos]
Lic. Katya Perez Martinez

Page 8

13
52
TOTAL GANADO 1064 BS

2. Realice un programa que elimine elementos duplicados de un


vector.
Ejemplo:
4
2
4
4
7
7
A=
1
2
3
4
5 6
Eliminando los duplicados queda:
4
2
7
A=
1
2
3
3. En la Universidad se conoce el nmero de alumnos que
ingresaron en sus 5 diferentes carreras (Ingeniera de
Sistemas, Psicomotricidad, Derecho, Contadura Pblica y
Educacin), en los ltimos 4 aos. Disee un TAD y luego
implementarlo para que suministre la siguiente informacin:
a. Total de alumnos por ao
b. Porcentaje de alumnos ingresados en el ao X de la carrera Y
c. Ao en el cual la carrera Y tuvo el mayor ingreso de
alumnos.

4. Disee el TAD necesario para formar una matriz de orden


NxM y la llene de datos enteros, (toda esta informacin la
proporciona el usuario), a continuacin obtenga e imprima:
a. Contar los elementos negativos y positivos
b. Hallar la suma de los elementos de la diagonal principal
c. Buscar el elemento X dado por el usuario y retorne el valor
1 si fue encontrado y 0 caso contrario.
5. Una cooperativa de productores de naranjas almacena el
total de toneladas cosechadas durante el ltimo ao en N
parcelas. En cada parcela se pueden cultivar dos tipos de
naranjas: para jugo y para comer. Se conoce el total de
toneladas cosechadas de cada uno de los tipos de naranjas.
Si en una parcela no se hubiera cosechado alguno de los
tipos, entonces habr 0.La informacin se almacena en un
arreglo como se muestra en el siguiente ejemplo.

Naranjas
para jugo

[Estructura de Datos]
Lic. Katya Perez Martinez

Naranjas
para comer

Page 9

A= 10
0
1

50
0
2

Parcela 1

60
0
3

80
0
5

Parcela 2

30
0
6

50
0

35
0
n

Parcela 3

En la parcela 1 se cosechan: 100 toneladas de naranjas para jugo y


500 toneladas de naranjas para comer
En la parcela 2 se cosecharon: 600 toneladas de naranjas para jugo y
0 toneladas de naranjas para comer.
NOTA: Observe que la informacin de una misma parcela
ocupa posiciones consecutivas en el arreglo.
Se pide:
a. Leer la informacin y las toneladas por tipo de naranja de cada
una de las parcelas
b. Calcular e imprimir el total de la produccin por parcela
c. Imprimir las parcelas que tuvieron una produccin de 0.

6. Realice un programa que de un vector de N elementos, por


cada elemento indique la cantidad de veces que se repite.
Ejemplo:
4
2
4
4
7
7
B=
1
2
3
4
5 6
La salida sera :
Element
o
4
2
7

1.7.4.

Se repite
3
1
2

Cadenas de Caracteres

Los arreglos de caracteres tienen varias caractersticas nicas.


Un arreglo de caracteres puede inicializarse de la siguiente forma:

char CADENA1[ ] = "rosa";


[Estructura de Datos]
Lic. Katya Perez Martinez

Page 10

El tamao de CADENA1 est determinado por el compilador, y


generalmente es de 256 caracteres mximo.

La cadena "rosa" contiene cuatro caracteres, ms un caracter


especial de terminacin denominado caracter nulo (' \0 ').

Los arreglos de caracteres pueden inicializarse tambin con


constantes individuales dentro de una lista.
char CADENA1[ ]= {' r ', ' o ', ' s ', ' a ', ' \0 ' };

Tambin podemos colocar una cadena de caracteres directamente


dentro de un arreglo de caracteres desde el teclado. Por ejemplo:
char CAD2[20];
cin >> CAD2;

1.7.5.

LOS METODOS DE LA CLASE STRING

Las cadenas no se pueden comparar con = = .

Los caracteres en las cadenas tienen un nmero de posicin que


inicia en CERO y termina en n-1, donde n es la longitud de la
cadena.

Los siguientes son algunos de los mtodos ms comunes en


aplicaciones java y su sintaxis.
Considerar cadena1 y cadena2 como variables (objetos) de tipo
String.

cadena1.equals(cadena2) regresa true si cadena1 y cadena2


son iguales, false de otra manera.

cadena1.equalsIgnoreCase(cadena2)

regresa true si las

cadenas son iguales ignorando las maysculas, false de otra


manera.

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 11

cadena1.compareTo(cadena2) regresa un valor entero 0 si son


iguales,

un

valor

menor

que

si

cadena1

es

menor

lexicogrficamente que cadena2 y un valor mayor que 0 si


cadena1 es mayor lexicogrficamente que cadena2.

cadena1.replace(char1,char2)

regresa

otra

cadena

remplazando char1 por char2.


Por ejemplo:
cadena2 =Cochabamba.replace( 'a','I');

cadena2 tendr el

valor de CochIbImbI

cadena1.toLowerCase();

regresa otra cadena convirtiendo

todas las letras a minsculas.

cadena1.toUpperCase();

regresa otra cadena convirtiendo

todas las letras a maysculas.

cadena1.trim();

regresa otra cadena sin espacios en blanco,

caracteres de nueva lnea y tabuladores del inicio y del final de la


cadena original.

cadena1.length(); regresa el numero, entero, de caracteres en


la cadena.

cadena1.substring(indiceInicial,

indiceFinal);

regresa

una

subcadena que empieza en indiceInicial y termina en indiceFinal-1.

cadena1.charAt(i); regresa el i-simo carcter de la cadena.

cadena1.indexOf(subcadena,indiceInicial); regresa un entero


que indica la posicin donde inicia la subcadena en la cadena. Si
no existe la subcadena regresa -1.

cadena1.endsWith(subcadena);

regresa true si cadena1

termina con subcadena, false de otra manera.

cadena1.concat(cadena2); equivalente a cadena1 + cadena2 .

String.valueOf(arregloDeCaracteres);

regresa

la

representacin String del arreglo de caracteres. Esta conversin

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 12

tambin puede ser realizada usando el constructor de la clase


String.

String cadena1= new String(arregloDeCaracteres);

cadena1.toCharArray(); regresa el arreglo de caracteres


correspondiente a cadena1.

CONVERSIN DE TIPOS PRIMITIVOS NUMRICOS A CADENA


Integer.toString(valorEntero); regresa el valor convertido en
cadena.
Double.toString(valorDoble); regresa el valor convertido en
cadena.
De manera semejante se convierten los otros tipos primitivos a cadena.
Integer.parseInt(cadenaNumerica);

regresa

el

valor

numrico entero correspondiente al valor representado en la


cadena.
Double.parseDouble(cadenaNumerica);

regresa el valor

numrico doble correspondiente al valor representado en la


cadena.
De manera semejante se convierten los otros tipos primitivos de cadena
a valores numricos.
Integer.parseInt(cadenaNumerica, base);

regresa el valor

entero de la cadena representado en la base numrica base.


Integer.toBinaryString(numeroEntero); regresa un valor
binario en cadena.
Integer.toHexString(numeroEntero);

regresa un valor

hexadecimal en cadena.
Integer.toOctalString(numeroEntero);

regresa un valor octal

en cadena

EJERCICIOS RESUELTOS
[Estructura de Datos]
Lic. Katya Perez Martinez

Page 13

1. Contar el numero de palabras que hay en una cadena,


palabras estn separadas por un espacio en blanco.
Diseamos el TAD

las

Guia31
contar():entero
main()

/*Este programa pretende contar el numero de palabras que hay en una


cadena las palabras estan separadas por un espacio en blanco
*/
public class Guia31
{
public static void main (String args[])
{
String cad = new String ("");
char blanco = ' ';
int cuantos = 0;
System.out.print ("deme la cadena ");
cad = Leer.Cadena ();
cuantos = contar (cad);
System.out.println ("Habia " + cuantos + "palabras");
}
public static int contar (String st)
{
char a;
int n = 1; // para contar la primera palabra
int i = st.indexOf (" "); //para encontrar la posicion del primer blanco

while (i > 0)
{ // mientras haya espacios en blanco
n++; // sumo 1 al contador
st = st.substring (i + 1); // recorto la cadena para quitar una palabra
i = st.indexOf (" "); // encuentro el siguiente blanco
}
return n++; // para contar la ultima palabra
}

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 14

2. Escribir un programa para reemplazar todas las


ocurrencias de un carcter c en la cadena cad por un
asterisco. El resultado queda en otra cadena. No usar la
funcin replace.
Diseamos el TAD
Guia32
reemplazar():Cadena
main()
/*
Este programa pretende reemplazar todas las ocurrencias de un caracter c
en la cadena cad por un asterisco. El resultado queda en otra cadena
No puede usar la funcion replace
*/
public class Guia32
{
public static void main (String args[])
{
String cad = new String (""); // cadena a revisar
char c; // caracter a buscar
String nueva = new String ("");
System.out.print ("deme la cadena.. ");
cad = Leer.Cadena ();
System.out.print ("Deme el caracter .");
c = Lectura.Caracter ();
nueva = reemplazar (cad, c);
System.out.println ("la cadena nueva es. " + nueva);
}
public static String reemplazar (String st, char letra)
{
char a;
String otra = new String (""); // nueva cadena a formar
for (int i = 0 ; i < st.length () ; i++)
{ // recorremos la cadena caracter a caracter
a = st.charAt (i); // tomamos un caracter
if (a == letra)
{ // si el caracter es el buscado
otra = otra + '*'; // colocamos un asterisco en al cadena nueva
}
else
{
otra = otra + a; // de lo contrario colocamos el mismo caracter que
tenia

}
}
return otra; // devolvemos la nueva cadena

}
}
[Estructura

de Datos]

Lic. Katya Perez Martinez

Page 15

3. programa
que pretende suprimir todos los espacios en
blanco de una
cadena cad. El resultado queda en otra
cadena.
Diseamos el TAD

Guia33

suprime():Cadena
main()
/* Este programa pretende suprimir todos los espacios en blanco de
unacadena cad El resultado queda en otra cadena
*/
public class Guia33
{
public static void main (String args[])
{
String cad = new String ("");
char blanco = ' ';
String nueva = new String ("");
System.out.print ("dame la cadena .");
cad = Lectura.Cadena ();
nueva = suprime (cad, blanco);
System.out.println ("la cadena nueva es " + nueva);
}
public static String suprime (String st, char espacio)
{
char a;
String otra = new String ("");
for (int i = 0 ; i < st.length () ; i++)
{
a = st.charAt (i);
if (a != espacio)
{
otra = otra + a;
}
}
return otra;
}
}

[Estructura de Datos]
Katya Perez Martinez
Lic.

Page 16

4. Programa que sirve para contar cuntas vocales tiene una


palabra o frase.
Diseamos el TAD

Guia34

Contar()
main()
// Programa que sirve para contar cuntas vocales tiene una palabra o
frase.
class Guia34
{
public static void main (String args[])
{
String palabra;
System.out.print(Dame una palabra o una frase..);
palabra = Lectura.Cadena ();
Contar (palabra);
}
static void Contar (String p)
{
int n = 0, cont = 0;
n = p.length ();
for (int i = 0 ; i < n ; i++)
{
if ((p.charAt (i) == 'a') || (p.charAt (i) == 'e') || (p.charAt
(i) == 'i') || (p.charAt (i) == 'o') || (p.charAt (i) == 'u'))
cont++;
}
System.out.println ("La palabra tiene " + cont + "
vocales");
}
}

5. Escribir una aplicacin para generar un cdigo a partir del


nombre, paterno, materno, dia, mes y anio de los datos del
usuario.
Guia35

[Estructura de Datos]
Lic. Katya Perez Martinez

Nombre:cadena
Paterno:cadena
Materno:cadena
dia:entero
mes:entero
anio:entero

Generar():cadena
main()

Page 17

Diseamos el TAD

// PROGRAMA PARA CODIFICAR UN NOMBRE CON LAS INICIALES DEL


nOMBRE+PATERNO+MATERNO
// +DIA+MES+ANIO DE NACIMIENTO
import java.lang.String;
public class Guia35
{
static String Nombre, paterno, materno;
static int dia, mes, anio;
static String Generar (String nom, String pat, String mat, int d, int m, int a)
{
char cod;
String Codigo = new String ("");
cod = nom.charAt (0); //extrae el primer caracter del nombre
Codigo = Codigo + cod; //almacena en Codigo la inicial del nombre
cod = pat.charAt (0); //extrae el primer caracter del apellido paterno
Codigo = Codigo + cod; // concatena la inicial del nombre con la inicial del
paterno

cod = mat.charAt (0); //extrae la inicial del apellido materno


Codigo = Codigo + cod; //concatena lo que tenia codigo con la inicial
materno
Codigo = Codigo + (Integer.toString (dia)) + (Integer.toString (mes)) +
(Integer.toString (anio));
return Codigo;
}
public static void main (String args[])
{
String Micodigo;
System.out.print ("Cual es tu nombre....");
Nombre = Lectura.Cadena ();
System.out.print ("Cual es tu Apellido paterno....");
paterno = Lectura.Cadena ();
System.out.print ("Cual es tu Apellido Materno....");
materno = Lectura.Cadena ();
do
{
System.out.print ("Dia de nacimiento....");
dia = Lectura.Entero ();
}
while (dia > 31 || dia < 1);
do
{

System.out.print ("Mes de nacimiento...");


[Estructura
de Datos]
mes = Lectura.Entero ();
Lic. Katya Perez Martinez

}
while (mes > 13 || mes < 1);

Page 18

do
{

System.out.print ("Anio de nacimiento Ej 97...");


anio = Lectura.Entero ();
Micodigo = Generar (Nombre, paterno, materno, dia, mes, anio);
} while (anio > 99);
System.out.print (" el codigo generado es ...." + Micodigo);

EJERCICIOS PROPUESTOS
1. Crear una clase donde dado un string que representa un nombre
en maysculas o minsculas devolver un string formado por las
iniciales en maysculas seguidas de un punto.
2. Crear una clase donde dado un string de palabras sustituir cada
ocurrencia de un caracter dado por otro caracter. (por ejemplo:
todas las s por *)
3. Escriba una clase que permita eliminar un substring substr de un
string str, si no est devuelve el mismo string sin alterar.
4. Escriba una clase que reciba como parmetro el nombre de una
persona, con el apellido seguido de una coma, un espacio y
despus el nombre de pila. El procedimiento debe imprimir el
nombre de pila de la persona seguido de su apellido.

1.8. ARREGLOS MULTIDIMENSIONALES

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 19

Existe en la mayora de los

lenguajes una estructura de arreglos

multidimensionales. El nmero de dimensiones (ndices) permitido


depende del lenguaje elegido.
1.8.1.

Matrices

Una matriz es un arreglo de dos dimensiones, y para especificar


cualquier elemento, debemos hacer referencia a dos ndices (que
representan la posicin como rengln y columna). Aunque no se
justificar aqu, es conveniente mencionar que la representacin
matricial es puramente conceptual y con el nico fin de facilitar al
programador el manejo de los elementos, ya que la computadora
almacena los datos en una forma totalmente diferente.
Se analizarn primero los arreglos bidimensionales (caso especial de
los multidimensionales) por ser los mas utilizados.
C++ soporta hasta arreglos con 12 dimensiones. En arreglos de dos
dimensiones, el primer elemento representa el rengln y el segundo
la columna.
Cada elemento de un arreglo bidimensional puede referenciarse de
la siguiente manera: arreglo [ i ] [ j ].
Un arreglo multidimensional puede inicializarse desde su
declaracin. Por ejemplo, un arreglo bidimensional b[2][2] puede
declararse e inicializarse as:
int b[2][2] = { {1,2} , {3,4} };
Los valores son agrupados en renglones.
Declaracin de una Matrz
La sintaxis en el lenguaje C++ es el siguiente:
tipo nombre_de_variable [rango1][rango2];

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 20

donde:
tipo puede ser cualquier tipo de dato (int, float, char, etc.).
nombre_de_variable es el nombre del arreglo.
rango 1 corresponde al nmero de renglones que conforman el
arreglo.
rango 2 corresponde al nmero de columnas.
Podemos trabajar con cada uno de los elementos de la matriz:
X[3][5]

= 20;

Operaciones con arreglos bidimensionales


Las operaciones que pueden realizarse con arreglos bidimensionales son
las siguientes:

Lectura/escritura

Asignacin

Actualizacin:
//programa
para manejo Insercin
de matrices de numeros enteros.
import java.io.*;
Eliminacin
class matriz
{
Modificacin
static int M[] [] = new int [20] [20];
int f, c;
static
Ordenacin
static
Bsqueda
void leerMatriz ()
{
En general
los arreglos bidimensionales son una generalizacin de los
System.out.println ("******REGISTRO DE MATRIZ ******");

System.out.print
("Ingrese
el numero
de filascon
de algunas
la matriz......");
unidimensionales,
por lo que
se realizar
un ejemplo
de
f = Leer.Entero ();

estas operaciones
a continuacin.
System.out.print
("Ingrese el numero de columnas de la matriz....");
c = Leer.Entero ();
for (int i = 1 ; i <= f ; i++)
Ejemplo:for (int j = 1 ; j <= c ; j++)
{
System.out.print ("Ingrese elemento (" + i + "," + j + ")....");
M [i] [j] = Leer.Entero ();
}
}
static void imprimir ()
{
System.out.println (".......IMPRIMIENDO LA MATRIZ.....");
for (int i = 1 ; i <= f ; i++)
{
System.out.println ();
for (int j = 1 ; j <= c ; j++)
{ Datos]
[Estructura de
Page
Lic. Katya Perez Martinez System.out.print (M [i] [j] + " ");
}
}
}

21

public static void main (String args[])


{
leerMatriz ();
imprimir ();
}

1.9. REGISTROS (ESTRUCTURAS)


Cuando se habl de los arreglos se mencion que se trataba de una
coleccin de datos, todos del mismo tipo, que era un tipo estructurado
de datos, y que son ellos se poda solucionar un gran nmero de
problemas. Sin embargo, en la prctica a veces se necesitan estructuras
que permitan almacenar distintos tipos de datos (caracterstica con la
cual no cuentan los arreglos).
Ejemplo
Una compaa tiene por cada empleado los siguientes datos:

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 22

Nombre (cadena de caracteres)


Direccin (cadena de caracteres)
Edad
(entero)
Sexo
(carcter)
Antigedad (entero)

Si lo vemos grficamente estos datos tenemos;


Nom
Juan
Maria

Nombre
Pat
Rodrgu
ez
Alvarez

Mat
Salas
Varga
s

Direccion
Calle
Nro Zona
Av. Arce 123 Centr
Calle 12 134 al
5
Obraj
es

Edad Sexo
25
M
29
F

Antig
2
3

Si se quisiera almacenar estos datos no sera posible usar un arreglo, ya


que sus componentes deben ser todos del mismo tipo.
1.9.1.DEFINICIN DE REGISTRO Y DECLARACIN DE LA VARIABLE DE
REGISTRO.

Un registro es un dato estructurado, donde cado uno de sus


componentes se denomina campo. Los campos de un registro pueden
ser todos de diferentes tipos. Por lo tanto tambin podrn ser registros o
arreglos. Cada campo se identifica por un nombre nico (el identificador
de campo). No se establece orden entre los campos.
1.9.2.ACCESO A LOS CAMPOS DE UN REGISTRO

Como un registro es un dato estructurado no puede accecsarse directamente


como un todo, sino que debe especificarse qu elemento (campo) del registro
interesa. Para ello, en la mayora de los lenguajes se sigue la siguiente sintaxis:

Variable_registro.campo
Ejemplo:

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 23

Escribir un programa para leer los registros de un empleado, sus datos


son CI, nombre, sueldo y fecha de ingreso.

Empleado.java
class empleado
{
private int ci;
private String nombre;
private float sueldo;
private class fecha
{
int dia, mes, anio;
}
public private
void leeDatos
fecha ()
fechaing = new fecha ();
{

System.out.println ("Ingrese los datos del empleado:");


System.out.print ("CI...");
ci = Lectura.Entero ();
System.out.print ("Nombre:.....");
nombre = Lectura.Cadena ();
System.out.print ("sueldo...");
sueldo = Lectura.Real ();
System.out.println ("INGRESE LA FECHA DE INGRESO:");
System.out.print ("DIA..");
fechaing.dia = Lectura.Entero ();
System.out.print ("MES...");
fechaing.mes = Lectura.Entero ();
System.out.print ("ANIO...");
fechaing.anio = Lectura.Entero ();

public void ImprimeDatos ()


{
System.out.println ("CI:___" + ci);
System.out.println ("NOMBRE:___" + nombre);
System.out.println ("SUELDO:___" + sueldo);
System.out.println ("FECHA DE INGRESO ");
System.out.println ("dia:___" + fechaing.dia);
System.out.println ("mes:___" + fechaing.mes);
System.out.println ("anio:___" + fechaing.anio);
}
public boolean VerificaSueldo (float X)
{
if (sueldo < X)
return true;
else
[Estructura
de Datos]
Lic. Katya Perez Martinez
return false;
}
}

Page 24

A continuacin codificamos el programa para llamar al programa de


empleado.java (el anterior programa)

LlamaEmpleado.java
class LlamaEmpleado
{
public static void main (String arg[])
{
empleado E;
E = new empleado ();
E.leeDatos ();
E.ImprimeDatos ();
}
}

1.9.3.

ARRAYS DE ESTRUCTURAS:

La combinacin de las estructuras con los arrays proporciona una


potente herramienta para el almacenamiento y manipulacin de datos.
1.9.4.

ESTRUCTURAS ANIDADAS:

Tambin est permitido anidar estructuras, con lo cual se pueden


conseguir superestructuras muy elaboradas.

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 25

En general, no es una prctica corriente definir estructuras dentro de estructuras, ya que


resultan tener un mbito local, y para acceder a ellas se necesita hacer referencia a la
estructura ms externa.

Ejemplo:

//PROGRAMA PARA LEER N EMPLEADOS EN UN VECTOR DE REGISTROS


class regemp
Utilizaremos el registro del empleado, que se escribi en el archivo
{
static empleadopara
e[] =implementar
new empleado [10];
empleado.java,
ahora mediante un arreglo que
static int n;
almacena
a NLeerEmpleados
empleados. El(empleado
programa
es elint
siguiente
regemp.java.
static int
ve[],
n)
{
System.out.print ("Cuantos empleados desea registrar...");
n = Lectura.Entero ();

for (int i = 1 ; i <= n ; i++)


{
System.out.println ();
System.out.println ("EMPLEADO :
ve [i] = new empleado ();
ve [i].leeDatos ();
}
return n;

" + i);

static void ImprimirEmpleados (empleado ve[], int n)


{
System.out.println (".....IMPRIMIENDO DATOS DE LOS EMPLEADOS....");
System.out.println ();
for (int i = 1 ; i <= n ; i++)
{
System.out.println ("EMPLEADO: " + i);
System.out.println ();
ve [i].ImprimeDatos ();
}
}
static void ListaConSueldoMenorX (empleado ve[], int n)
{
float sx;
System.out.println (".....EMPLEADOS CON SUELDOS MENOR A X....");
System.out.println ();
System.out.println ("Menores a cual sueldo desea listar...");
sx = Lectura.Real ();
for (int i = 1 ; i <= n ; i++)
{
System.out.println ("EMPLEADO: " + i);
System.out.println ();
if (ve [i].VerificaSueldo (sx) == true)
ve [i].ImprimeDatos ();
}
[Estructura de Datos]
}
Lic. Katya
Perez Martinez

Page 26

public static void main (String args[])


{
n = LeerEmpleados (e, n);
ImprimirEmpleados (e, n);
ListaConSueldoMenorX (e,n);
}

1.10.

CONJUNTOS

El conjunto es tambin un tipo de dato estructurado. Puede definirse un


conjunto como una coleccin de objetos del mismo tipo base. El tipo
base puede ser solamente un tipo ordinal (enteros, caracteres,
enumerados y subrangos).

1.10.1.

DEFINICIN DE CONJUNTOS

Los conjuntos sern definidos de la siguiente manera:


[Estructura de Datos]
Lic. Katya Perez Martinez

Page 27

Ident_conjunto = CONJUNTO DE tipo_base


Donde:
Tipo_base es cualquier tipo ordinal de dato.
Ejemplo:
Se

definen

los

conjuntos

NUMEROS,

MAYUSCULAS

ALUMNOS.

NUMEROS es el tipo conjunto formado por todos los nmeros enteros


comprendidos entre el 1 y el 50 inclusive. MAYUSCULAS es el tipo
conjunto formado por las letras maysculas, y finalmente ALUMNOS es
el tipo conjunto formado por todos los elementos del tipo enumerado
NOMBRES.
NOMBRES = (Juan, Jose, Julio,Javier)
NUMEROS = CONJUNTO DE 1..50
MAYUSCULAS = CONJUNTO DE A..Z
ALUMNOS = CONJUNTO DE nombres

1.11.

MATRICES POCO DENSAS

Matriz es un trmino matemtico utilizado para definir un conjunto de


elementos organizados por medio de renglones y columnas, equivalente
al trmino arreglo bidimensional utilizado en computacin.
Poco Densa indica una proporcin muy alta de ceros entre los
elementos de la matrz. Es decir una matriz poco densa es aquella que
tiene gran cantidad de elementos ceros.
Ejemplo:
La matriz A de 4 filas por 4 columnas, del total de elementos que es 16,
solo 4 de ellos son diferentes de cero.
0
0
0
0
Existen diversos mtodos para
A=

1
1
0
0
1
0
1
0
0
1
0
0
almacenar los valores diferentes de cero

de una matrz poco densa. A continuacin presentamos uno de ellos.


[Estructura de Datos]
Lic. Katya Perez Martinez

Page 28

Arreglo de Registros
Se utiliza un arreglo unidimensional, donde cada elemento es un registro
formado por tres campos: uno para guardar la fila donde se encontr el
valor diferente de cero, otro para guardar la columna, y el tercero para
guardar el valor del elemento distinto de cero de la matriz.
El siguiente programa nos permite crear la estructura para una matriz
poco densa, se lo ha denominado MatrizPocoDensa.java:

MatrizPocoDensa.java
public class MatrizPocoDensa
{
private int fila;
private int col;
private int valor;
MatrizPocoDensa (int f, int c, int v)
{
fila = f;
col = c;
valor = v;
}
public int FILA ()
{
return fila;
}
public int COL ()
{
return col;
}
public int VALOR ()
{
return valor;
}
[Estructura de Datos]
Lic. Katya Perez Martinez

Page 29

El programa para utilizar matrices poco densas es el siguiente:


class MatrizPD
{
static MatrizPocoDensa[] LeerMatrizPocoDensa ()
{
int i, j, k, e, m, n;
MatrizPocoDensa M[] = new MatrizPocoDensa [20];
k = 0;
System.out.print ("INGRESE EL NUMERO DE FILAS DE LA MATRIZ....");
m = Lectura.Entero ();
System.out.print ("INGRESE EL NUMERO DE COLUMNAS DE LA MATRIZ....");
n = Lectura.Entero ();
k = 1;
for (i = 1 ; i <= m ; i++)
{
for (j = 1 ; j <= n ; j++)
{
MatrizPD.java
System.out.print ("Ingrese el valor de la posicion (" + i +
"," + j + ") =");
e = Lectura.Entero ();
if (e != 0)
{
M [k] = new MatrizPocoDensa (i, j, e);
k = k + 1;
}

}
}
M [0] = new MatrizPocoDensa (m, n, (k - 1));
return M;

static void ImprimirMatrizPocoDensa (MatrizPocoDensa D[])


{
int i, j, k;
k = 1;
System.out.println ("IMPRIMIENDO LA MATRIZ POCO DENSA....");
for (i = 1 ; i <= D [0].FILA () ; i++)
{
System.out.println ();
for (j = 1 ; j <= D [0].COL () ; j++)
{
if ((D [k].FILA () == i) && (D [k].COL () == j))
{
System.out.print (" " + D [k].VALOR () + " ");
if (D [0].VALOR () > k)
k = k + 1;
}
[Estructura de Datos]
Page
else
Lic. Katya Perez Martinez
System.out.print (" 0 ");
}
}
}

30

public static void main (String args[])


{
MatrizPocoDensa A[] = new MatrizPocoDensa [20];
A = LeerMatrizPocoDensa ();
ImprimirMatrizPocoDensa (A);
}

1.12.

ARCHIVOS
Ejercicios Propuestos

ARREGLOS DE UNA DIMENSIN


1. Declare e inicialice un vector de N elementos de modo que los
componentes de indice par valgan 0 y los de indice impar valgan
1. Ejm. V(1,0,1,0, . . . . .)

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 31

2. Escriba un programa que almacene en un vector los N primeros


nmeros de Fibonacci. Una vez calculados, el programa los
mostrar por pantalla en orden inverso.
3. Escriba un programa que almacene en un vector los N primeros
nmeros de Fibonacci. Una vez calculados, el programa pedir al
usuario que introduzca un nmero y dir si es o no es uno de los N
primeros nmeros de Fibonacci.
4. Modifica el programa del ejercicio anterior para que muestre,
adems, cuntas edades hay

entre 0 y 9 aos, entre 10 y 19,

entre 20 y 29, etc. Considera que ninguna edad es igual o superior


a 150.

Ejemplo:

si el usuario introduce las siguientes edades

correspondientes a

12

personas:

10 23 15 18 20 18 57 12 29 31 78 28
el programa mostrar (adems de la media, desviacin estndar,
moda y mediana), la

siguiente tabla:

0 - 9: 0
10 - 19: 5
20 - 29: 4
30 - 39: 1
40 - 49: 0
50 - 59: 1
60 - 69: 0
70 - 79: 1
80 - 89: 0
90 - 99: 0
100 - 109: 0
110 - 119: 0
120 - 129: 0
130 - 139: 0
140 - 149: 0
4 Modifica el programa para que muestre un histograma de edades.
La tabla anterior se mostrar ahora como este histograma:
0 - 9:
10 - 19:
20 - 29:
30 - 39:
40 - 49:
50 - 59:
60 - 69:
70 - 79:
[Estructura de Datos]
Lic. Katya Perez Martinez

*****
****
*
*
*
Page 32

80 - 89:
90 - 99:
100 - 109:
110 - 119:
120 - 129:
130 - 139:
140 - 149:
Como puedes ver, cada asterisco representa la edad de una
persona.
5 Modifica el programa anterior para que el primer y ltimo rangos
de edades mostrados en el histograma correspondan a tramos de
edades en los que hay al menos una persona. El histograma
mostrado antes aparecer ahora as:
10
20
30
40
50
60
70

19:
29:
39:
49:
59:
69:
79:

*****
****
*
*
*

6 Modifica el programa del ejercicio anterior para que muestre el


mismo histograma de esta otra forma:

| ####### |
|
|
|
|
| ####### | ####### |
|
|
|
|
| ####### | ####### |
|
|
|
|
| ####### | ####### |
|
|
|
|
| ####### | ####### | ####### |
####### |
| ####### |
+----------+-----------+-----------+-----------+-----------+----------+-----------+
| 10 19 | 20 - 29 | 30 39 | 40 49 | 50 59 | 60
69 | 70 79 |

|
|
|
|
|

7 Disee un programa que pida el valor de N nmeros enteros


distintos y los almacene en un vector. Si se da el caso, el programa
[Estructura de Datos]
Lic. Katya Perez Martinez

Page 33

advertir al usuario, tan pronto sea posible, si introduce un


nmero repetido y solicitar nuevamente el nmero hasta que sea
diferente de todos los anteriores. A continuacin, el programa
mostrar los N nmeros por pantalla
8 Disee un programa que lea y almacene en un vector N nmeros
enteros asegurndose de que sean positivos. A continuacin, el
programa pedir que se introduzca una serie de nmeros enteros
y nos dir si cada uno de ellos est o no en el vector. El programa
finaliza cuando el usuario introduce un nmero negativo. Luego
ordenar el vector, por el mtodo de la burbuja.
9 En un arreglo se ha almacenado el nmero total de toneladas de
cereales cosechadas durante cada mes del ao anterior. Se desea
la siguiente informacin:
i. El promedio anual de toneladas cosechadas
ii. Cuntos meses tuvieron una cosecha superior al
promedio anual?
iii. Cuntos meses tuvieron una cosecha inferior al
promedio anual?Escriba un programa que proporcione
estos datos.
ARREGLOS MULTIDIMENSIONALES
20.

Escriba un programa que intercambie por rengln los

elementos de un arreglo bidimensional. Los elementos del rengln


1 deben intercambiarse con los del rengln N, los del rengln 2
con los del N-1, y as sucesivamente.
21.

Escriba un programa que asigne valores a A, a partir de B

teniendo en cuenta los siguientes criterios:


iv. Aij = (bi)
v. Aij = 0

[Estructura de Datos]
Lic. Katya Perez Martinez

si i <= j
si i >j

Page 34

22.

Disee el TAD necesario para formar una matriz de orden

NxM y la llene de datos enteros, (toda esta informacin la


proporciona el usuario), a continuacin obtenga e imprima:
d. Contar los elementos pares e impares
e. Hallar la suma de los elementos de la diagonal secundaria
f. Dado la fila y la columna por el usuario, devuelva el
elemento que corresponda a esa posicin
23.

Una agencia automotriz distribuye 6 modelos diferentes de

coches y tiene 5 vendedores. Se desea un programa que escriba


un informe mensual del nmero de automviles vendidos por cada
vendedor y por modelo y el nmero total de cada modelo vendido
por cada uno de los vendedores. Asimismo, para entregar el
premio al mejor vendedor, necesita saber cul es el vendedor que
ms coches ha vendido.
Vendedores
Modelos
Juan
M1
4
M2
2
M3
0
M4
3
M5
4
M6
0

24.

La Tabla

Pedro
0
3
3
5
1
0

Maria
2
1
0
7
2
3

Rosa
1
1
2
3
2
2

Luis
5
2
1
1
0
5

Rosa
vendi 2
autos del
modelo
M3

contiene gastos que registra una ama de casa

correspondiente a los 12 meses del ao anterior.


Meses/Gas
tos
Enero
Febrero
Marzo
Abril
Mayo
Junio
Julio
Agosto
Septiembre

Agua

Luz

23
28
34
24
29
34
45
48
32

57
60
55
87
80
65
67
78
54

[Estructura de Datos]
Lic. Katya Perez Martinez

Telefon
o
840
560
400
700
450
670
560
570
540

Mercad
o
250
280
275
340
310
320
325
323
290
Page 35

Octubre
Noviembre
Diciembre

33
35
38

50
70
62

250
330
300

300
350
430

Es posible interpretar esta tabla de la siguiente manera: dado un mes,


se conocen los gasto realizados por la ama de casa; y dado un gasto se
conocen los gastos mensuales.
REGISTROS
25.

Una compaa distribuye N productos a distintos comercios

de la ciudad. Para ellos almacena en un arreglo toda la


informacin relacionada con su mercanca:

Clave

Descripcin

Existencia

Mnimo a mantener de existencia

Precio unitario

Escriba un programa que pueda llevar a cabo las siguientes


operaciones:
a) Venta de un producto: se deben actualizar los campos que
correspondan, y verificar que la nueva existencia no est por
debajo del mnimo. (datos: clave, cantidad_vendida)
b) Reabastecimientos de un producto: se deben actualizar los
campos que correspondan. (Datos: clave, cantidad comprada)
c) Actualizar el precio de un producto: se deben proporcionar todos
los datos relacionados con un producto. (Dato: clave)

2. Captulo II
Pilas

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 36

SiJava
Javadispusiera
dispusierade
deun
unmecanismo
mecanismoreal
realde
derecoleccin
recoleccinde
debasura,la
basura,lamayora
mayora
Si

de
los
programas
deberan
autoeliminarse
al
ser
ejecutados.
de los programas deberan autoeliminarse al ser ejecutados.
Robert Sewell
Robert Sewell

2.1. INTRODUCCIN
La pila es una lista de elementos caracterizada porque las operaciones de insercin y
eliminacin se realizan solamente en un extremo de la estructura. El extremo donde se
realizan estas operaciones se denomina habitualmente 'cima' o tope
(top en
nomenclatura inglesa).
Dada una pila P = (a, b, c, ... k ), se dice que a, es el elemento ms inaccesible de la pila,
est en el fondo de la pila (bottom) y que k, por el contrario, el ms accesible, est en el
Tope.
Las restricciones definidas para la pila implican que si una serie de elementos A, B, C, D,
E se aaden, en este orden a una pila, entonces el primer elemento que se borre de la
estructura deber ser el E. Por tanto, resulta que el ltimo elemento que se inserta en una
pila es el primero que se borra. Por esta razn, se dice que una pila es una lista LIFO
(Last Input First Output, es decir, el ltimo que entra es el primero que sale).
Un ejemplo tpico de pila lo constituye un montn de platos, cuando se quiere introducir un
nuevo plato, ste se pone en la posicin ms accesible, encima del ltimo plato. Cuando
se coge un nuevo plato, ste se extrae, igualmente, del punto ms accesible, el ltimo que
se ha introducido. Ejemplos: Una pila de papeles, una pirmide humana

Otro ejemplo natural de la aplicacin de la estructura pila aparece


durante la ejecucin de un programa de ordenador, en la forma en que
la mquina procesa las llamadas a los procedimientos. Cada llamada a
un procedimiento (o funcin) hace que el sistema almacene toda la
[Estructura de Datos]
Lic. Katya Perez Martinez

Page 37

informacin asociada con ese procedimiento (parmetros, variables,


constantes, direccin de retorno, etc..) de forma independiente a otros
procedimientos y permitiendo que unos procedimientos puedan invocar
a otros distintos (o a si mismos) y que toda esa informacin almacenada
pueda ser recuperada convenientemente cuando corresponda.
Como

en

un

procesador

slo

se

puede

estar

ejecutando

un

procedimiento, esto quiere decir que slo es necesario que sean


accesibles los datos de un procedimiento (el ltimo activado que est en
la cima). De ah que la estructura pila sea muy apropiada para este fin.
Como en cualquier estructura de datos, asociadas con la estructura pila
existen una serie de operaciones necesarias para su manipulacin, stas
son:
a.

Crear la pila.

b.

Comprobar si la pila est vaca. Es necesaria para saber si es


posible eliminar elementos.

c.

Acceder al elemento situado en la cima.

d.

Aadir elementos a la cima.

e.

Eliminar elementos de la cima.

La especificacin correcta de todas estas operaciones permitir definir


adecuadamente una pila.

2.2. REPRESENTACIN DE LAS PILAS


Las pilas no son estructuras fundamentales de datos, es decir, no estn
definidas como tales en los lenguajes de programacin (como lo estn
por ejemplo los arreglos). Las pilas pueden representarse mediante el
uso de:

Arreglos

Listas Enlazadas

Aqu se utilizarn arreglos. En consecuencia deber definirse cul ser el


tamao mximo de la pila, y adems una variable auxiliar a la que se

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 38

denominar TOPE, que ser un apuntador al ltimo elemento insertado


en la pila.
En la figura siguiente se presentan dos alternativas de representacin de
una pila, utilizando arreglos.

MAX

PILA =
TOPE

TOPE

1555 2434

4
3
2
1

3222

44444

MAX

TOPE
PILA

2.3.

444

ESTRUCTURA DE UNA PILA UTILIZANDO


ARREGLOS

222

Nombre del TAD

434

elementos

555

operaciones

PILA
V[MAX]:
tipo_dato
Tope: entero
Poner(e)
Quitar()
Imprimir()
Vacia()

Donde los elementos son:


V[MAX]:es el vector que representa a la pila y es de tamao de la pila.
Tope: es la varible que indica la posicin del ultimo elemento de la pila.
Y las operaciones como se describen a continuacin.

2.4. OPERACIONES CON PILAS


[Estructura de Datos]
Lic. Katya Perez Martinez

Page 39

La definicin de una estructura de datos queda completa al incluir las


operaciones que se pueden realizar en ella. Las operaciones principales
con pilas son:

Pone (e)

un elemento en la pila (push)

boolean llena ()
{
if (tope == MAX)
Quita
()
un elemento de la pila (pop)
return (true);
else
return (false);
}Llena()
verifica si la pila esta llena, si es asi, retorna el valor

verdad, caso contrario falso.

void poner (int elem)


{
if (llena
()) si la pila esta vacia, si es asi, reotrna el valor
Vacia()
verifica
System.out.println ("PILA LLENA...");
verdad,
else caso contrario falso.
{
tope++;
Imprime()
Permite
imprimir todos los elementos de la pila
v [tope]
= elem;
} el tope hasta el fondo de la pila.
desde
}
2.5.
IMPLEMENTACIN
DEL TAD PILA EN LENGUAJE
int quitar
()
{JAVA
int elem = 0;
if (vacia ())
System.out.println ("PILA VACIA...");
//clase pila y sus operaciones
else
import java.io.*;
{
public class Pila
elem = v [tope];
{
tope--;
private final int MAX = 20;
}
private int v[] = new int [MAX];
return (elem);
private int tope;
}
void imprimir ()
Pila ()
{
{
System.out.println ("...IMPRIMIENDO LA PILA...");
tope = 0;
for (int i = tope ; i >= 1 ; i--)
System.out.println ("PILA CREADA...");
System.out.println (v [i]);
}
}
boolean vacia ()
void llenarPila ()
{
{
if (tope == 0)
int n, e;
return (true);
System.out.println ("cuantos elementos ??...");
else
n = Lectura.Entero ();
return (false);
for (int i = 1 ; i <= n ; i++)
}
{
System.out.print ("elemento?...... ");
[Estructura dee Datos]
= Lectura.Entero ();
Lic. Katya Perez Martinez
poner (e);
}
}
}

Page 40

Ejercicios con pilas


[Estructura de Datos]
Lic. Katya Perez Martinez

Page 41

a. Sumar dos pilas del mismo tamao.

//sumar dos pilas del mismo tamao


class EjPila1
{
static Pila P1 = new Pila ();
static Pila P2 = new Pila ();
static Pila P3 = new Pila ();
static void sumarPilas (Pila A, Pila B, Pila C)
{
int e, f;
while (!A.vacia ())
{
e = A.quitar ();
f = B.quitar ();
C.poner (e + f);
}
//ELIMINAR ELEMENTOS NEGATIVOS DE LA PILA
}
class EjPila2
{
static
P = void
new Pila
publicPila
static
main ();
(String args[])
{
static void EliminaNegativos (Pila A)
{
Pila
aux = new Pila
P1.llenarPila
(); ();
int
e;
P2.llenarPila
();

P1.imprimir ();
System.out.println ("Eliminando Elementos Negativos de
la Pila...");
P2.imprimir ();
while
(!A.vacia
sumarPilas
(P1,())
P2, P3);
{ P3.imprimir ();
e = A.quitar ();
if (e > 0)
}
aux.poner (e);
}
}
while (!aux.vacia ())
{
e = aux.quitar ();
A.poner (e);
}
}
publiclosstatic
void
main (String
args[])
b. Eliminar
elementos
negativos
de una pila.
{

P.llenarPila ();
P.imprimir
[Estructura de
Datos] ();
EliminaNegativos
(P);
Lic. Katya Perez Martinez
P.imprimir ();
}
}

Page 42

c. Realizar un procedimiento para intercalar los elementos de una pila A con

los elementos de una pila B en una pila C. Es decir:

A=

13 24

377

489

B = 1 23

TOPE

C=

89 33 77
2
3

[Estructura de Datos]
Lic. Katya Perez Martinez

44

11
2

344

433 5
TOPE

4
5

11
6

3
7

23
8
Page 43

TOPE

//intercalar los elementos de una pila A con los elementos de una pila B
//en una pila c
class EjPila3
{
static Pila p1 = new Pila ();
static Pila p2 = new Pila ();
static void Intercala (Pila A, Pila B)
{

Pila aux = new Pila ();


int e;
System.out.println ("****** INTERCALANDO LA PILA *********");
while (!A.vacia ())
{
e = A.quitar ();
aux.poner (e);
e = B.quitar ();
aux.poner (e);
}
aux.imprimir ();

public static void main (String args[])


{
p1.llenarPila ();
p2.llenarPila ();
p1.imprimir ();
p2.imprimir ();
Intercala (p1, p2);
}

2.6. APLICACIONES
Las pilas son una estructura de datos muy usada en la solucin de diversos tipos de
problemas. Ahora se vern algunos de los casos ms representativos de aplicacin de
pilas:

Llamadas a subprogramas

Recursin

Tratamiento de expresiones aritmticas

Ordenacin

2.6.1.

LLAMADAS A SUBPROGRAMAS

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 44

Cuando se tiene un programa que llama a un subprograma, internamente se usan pilas


para guardar el estado de las variables del programa en el momento que se hace la
llamada. As, cuando termina la ejecucin del subprograma, los valores almacenados
en la pila pueden recuperarse para continuar con la ejecucin del programa en el punto
en el cual fue interrumpido. Adems de las variables debe guardarse la direccin del
programa en la que se hizo la llamada, porque es a esa posicin a la que regresa el
control del proceso.
Por ejemplo, se tiene un programa principal (PP) que llama a los subprogramas UNO y
DOS. A su vez, el subprograma DOS llama al subprograma TRES. Cada vez que la
ejecucin de uno

de los subprogramas concluye, se regresa el control al nivel

inmediato superior.
Cuando el programa PP llama a UNO, se guarda en una pila la posicin en la que se
hizo la llamada. Al terminar UNO, el control se regresa a PP recuperando previamente
la direccin de la pila. Al llamar a DOS, nuevamente se guarda la direccin de PP en la
pila. Cuando DOS llama a TRES, se pone en la pila la direccin de DOS. Despus de
procesar TRES, se recupera la posicin de DOS para continuar con su ejecucin. Al
terminar DOS se regresa el control a PP, obteniendo previamente la direccin guardada
en la pila.

UNO
.
DOS
.

.
.
UNO

PP

.
TRES
.

DOS

.
.

TRES

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 45

TOPE

5
4

5
4

5
4

TOPE

PP

TOPE

2
1

PP

TOPE

5
4

5
4

5
4

DOS

PP

TOPE

PP

TOPE

1
0

PP

Finalmente podemos concluir que las pilas son necesarias en esta rea
de aplicaciones por lo siguiente:

Permiten guardar la direccin del programa (subprograma) desde


donde se hizo la llamada a otros subprogramas, para poder
regresar y seguir ejecutndolo a partir de la instruccin inmediata
a la llamada.

Permiten guardar el estado de las variables en el momento que se


hace la llamada, para poder seguir ocupndolas al regresar del
subprograma.

2.6.2.

RECURSIN

Se Tratar en el tema 5 el tema de recursin. Se dejar para entonces la


aplicacin de pilas en procesos recursivos.
2.6.3.

TRATAMIENTO DE EXPRESIONES ARITMTICAS

Un problema interesante en computacin es poder convertir expresiones


en notacin infija a su equivalente en notacin postfija.(o prefija).
Revisaremos algunos conceptos:

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 46

Dada la expresin A+B se dice que est en notacin infija, y su


nombre se debe a que el operador (+) est entre los operandos ( A
y B).

Dada la expresin AB+ se dice que est en notacin postfija, y su


nombre se debe a que el operador (+) est despus de los
operandos (A y B).

Dada la expresin +AB se dice que est en notacin prefija, y su


nombre se debe a que el operador (+) est antes que los
operando (A y B).

La ventaja de usar expresiones en notacin polaca postfija o


prefija radica en que no son necesarios los parntesis para indicar
orden de operacin, ya que ste queda establecido por la
ubicacin de los operadores con respecto a los operandos.

Para convertir una expresin dada en notacin infija a una


notacin postfija (o prefija) debern establecerse previamente
ciertas condiciones:

Solamente se manejarn los siguientes operadores (estn dados


ordenadamente de mayor a menor segn su prioridad de
ejecucin):
^

(potencia)

*/

(multiplicacin y divisin)

+-

(suma y resta)

Los operadores de ms alta prioridad se ejecutan primero.

Si hubiera en una expresin dos o ms operadores de igual


prioridad, entonces se procesarn de izquierda a derecha.

La subexpresiones

patentizadas tendrn ms prioridad que

cualquier operador.

Presentaremos, paso a paso, algunos ejemplos de conversin de


expresiones infijas a notacin polaca postfija.

EJEMPLO

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 47

En este ejemplo se presentan dos casos de traduccin de notacin infija


a postfija. El primero de ellos es una expresin simple, mientras que el
segundo presenta un mayor grado de complejidad.
a) expresin infija:

X+Z*W
X + [ZW*]

Expresin postfija

XZW*+

b) transformamos a notacin prefija la misma expresin anterior


X+Z*W
X + [* Z W]
Notacin prefija

+ X*ZW

EJERCICIOS PROPUESTOS
1.
1.1.
1.2.
1.3.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

Traduzca las siguietes expresiones a notacin postfija utilizando el algoritmo de


evaluacin.
X*(Z+W)/(T-V)
Z-W*Y+XK
W*(Z/(K-T))
Realizar un programa para hallar el mayor elemento de una pila P.
Realizar un procedimiento para intercambiar el ltimo elemento de la pila por el
primer elemento.
Escriba un programa que elimine los elementos repetidos de una pila. Los elementos
repetidos ocupan posiciones sucesivas.
Escriba un subprograma que invierta los elementos de una pila.
Insertar n elementos despus al fondo de una pila que ya tiene datos.
Eliminar los elementos divisores de X de la pila
Intercambiar cada elemento de la pila con su adyacente.
Eliminar el primer elemento par de la pila
Hallar la frecuencia de repeticin de cada elemento de la pila
Apilar los elementos de la pila B sobre la pila A.
Insertar el elemento X en una pila cuyos elementos estan ordenados en forma
ascendente desde el fondo hasta el tope. La pila debe quedar ordenada
Escriba un programa que lea una expresin en notacin infija, y la traduzca anotacin
postfija.

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 48

3. Captulo III

Colas

caminodel
delTigre
Tigre
ElElcamino
Un hombre caminaba por el bosque cuando vi una zorra lisiada. "Cmo har para alimentarse?", pens.
Un hombre caminaba por el bosque cuando vi una zorra lisiada. "Cmo har para alimentarse?", pens.
En ese momento, se acerc un tigre, con un animal entre los dientes. Saci su apetito, y le dej a la zorra lo que haba
Ensobrado.
ese momento,
se ayuda
acercaun
un animal
los dientes.
Saci su apetito, y le dej a la zorra lo que haba
"Si Dios
la tigre,
zorra,con
tambin
me vaentre
a ayudar",
reflexion.
sobrado. "Si Dios ayuda a la zorra, tambin me va a ayudar", reflexion.
Volvi a su casa, se encerr en ella, y se qued esperando que los Cielos le proveyeran de alimento. Nada pas. Cuando
Volvi
su casa,
se encerr
en ella, dbil
y se qued
esperando
que los
le proveyeran
ya se aestaba
quedando
demasiado
para salir
a trabajar,
se Cielos
le apareci
un ngel. de alimento. Nada pas. Cuando
ya se estaba quedando demasiado dbil para salir a trabajar, se le apareci un ngel.
- Por qu decidiste imitar a la zorra lisiada? -pregunt el ngel.
- Por qu decidiste imitar a la zorra lisiada? -pregunt el ngel.
- Levntate, toma tus herramientas, y sigue el camino del tigre!
- Levntate, toma tus herramientas, y sigue el camino del tigre!

de Paulo Coelho
de Paulo Coelho

3.1. INTRODUCCIN
La estructura de datos "cola" tambin llamada "Queue", es un tipo de
datos abstracto "TDA". Una cola TDA permite a una lista de cosas ser
removidos en el orden en que fueron almacenados.
Una cola es una lista de elementos en la que stos se introducen por un
extremo y se eliminan por otro. Los elementos se eliminan en el mismo
orden en el que se insertaron. Por lo tanto, el primer elemento que entra
a la cola ser el primero en salir. Debido a esta caracterstica, las colas
tambin reciben el nombre de estructuras FIFO (First In, First Out:
Primero en entrar, primero en salir).
Las colas en computacin son muy similares a las colas de la vida real.
Ejemplos:
[Estructura de Datos]
Lic. Katya Perez Martinez

Page 49

a. cola de clientes esperando pagar en una caja de supermercado


b. cola de clientes esperando ser atendidos por algn cajero en un
banco
c. cola de procesos esperando ser ejecutados por una CPU
Al igual que la pila, la cola es una estructura de datos dinmica, pero
puede ser representado en forma esttica (arreglos).

3.2. CARACTERSTICAS

Todos los elementos de la cola son del mismo tipo.

Existe un orden de elementos ya que es una estructura lineal, pero


los elementos no estn ordenados por su valor sino por orden de
introduccin en la cola.

Existen dos extremos en la estructura lineal cola, el frente y el


final de la cola.

Slo se puede acceder y eliminar al dato que est en el frente de


la cola.

Slo se puede aadir informacin al final de la cola.

3.3. REPRESENTACIN DE LAS COLAS

Al igual que las pilas, las colas no existen como estructuras de datos
estndares en los lenguajes de programacin. Las colas pueden
representarse mediante el uso de:
Arreglos
Listas Enlazadas.
Como en el caso de las pilas, utilizaremos arreglos. Debe definirse el
tamao mximo para la cola y dos variables auxiliares. Una de ellas para
que guarde la posicin del primer elemento de la cola (FRENTE) y otra
para que guarde la posicin del ltimo elemento de la cola (FINAL). En el
ejemplo siguiente se muestra una representacin de una cola en la cual
se ha insertado cuatro elementos: 11, 22, 33 y 44, en ese orden.
[Estructura de Datos]
Lic. Katya Perez Martinez

Page 50

El elemento 11 est en el frente ya que fue el primero que entr en la


cola. Mientras que el elemento 44, que fue el ltimo en entrar, est en el
FINAL de la cola.
MAX=6
Ejemplo: sea una cola Q de nmeros enteros:

Q=

11

22

33

Frente

44

Final

3.4. ESTRUCTURA DE UNA COLA IMPLEMENTADO


MEDIANTE ARREGLOS
A continuacin diseamos la estructura de datos para una cola
representada mediante un arreglo:
COLA
elementos

V[MAX]:
tipo_dato
frente: entero
fin: entero

operaciones

Insertar(e)
Eliminar()
Imprimir()
Vacia()
Llena()
FRENTE()

Donde los elementos son:


V[MAX]:es el vector que representa a la cola y es de tamao MAX.
Frente: es la variable que indica la posicin del elemento del frente de
la cola.
Fin: es la variable que indica la posicin del ltimo elemento de la cola.
Y las operaciones, como se describen a continuacin.
[Estructura de Datos]
Lic. Katya Perez Martinez

Page 51

3.5. OPERACIONES CON COLAS


Anlogamente

las

pilas,

es

necesario

definir

el

conjunto

de

operaciones bsicas para especificar adecuadamente una estructura


cola. Estas operaciones seran:

Insertar(e):

Inserta un elemento al final de la cola.

Eliminar():

Elimina un elemento del frente de la cola.

Imprimir():

Imprime los elementos desde el frente hasta el

final de la cola.

Vacia():

Verifica si la cola esta vaca, retorna un valor booleano.

Llena():

Verifica si la cola est llena, retorna un valor booleano.

FRENTE(): Retorna el valor del frente.

FINAL():

Retorna el valor del fin.

Insertar un elemento en la cola:


Debido a la implementacin esttica de la estructura cola es necesario
determinar si existen huecos libres donde poder insertar antes de
hacerlo. Esto puede hacerse de varias formas.
//COLA LINEAL
DE NUMEROS
Eliminar
un elemento
deENTEROS
la cola:Y SUS OPERACIONES
class Cola
{
Comofinal
veraint
la MAX
eliminacin
= 20;

no borra nada 'fsicamente', slo se encarga

de actualizar el puntero 'frente' en una posicin y devolver el valor x


private int v[] = new int [MAX];

como private
mucho,intaunque
esto ltimo no sea estrictamente necesario.
fin;
private int frente;

Aunque esa posicin aun contenga datos ser considerada como vaca a
Cola
efectos
del()otro puntero 'fin'.
{

frente = 0;
fin = 0;
System.out.println ("COLA CREADA....");

COLAS LINEALES

A continuacin
implementamos el cdigo correspondiente al programa
}
boolean
de manejo
devacia
colas ()
lineales en java:
{

if (frente == 0)
return (true);
else
return (false);
}
boolean llena ()
{
[Estructura
de Datos]
(fin == MAX)
Lic. Katya Perezif
Martinez
return (true);
else
return (false);
}

Page 52

void insertar (int elem)


{
if (!llena ())
{
fin++;
v [fin] = elem;
if (frente == 0)
frente = 1;
}
else
{
}

System.out.println ("COLA LINEAL LLENA....");


System.exit (0);

}
int eliminar ()
{
int e = 0;
if (!vacia ())
{
e = v [frente];
if (frente == fin)
{
frente = 0;
fin = 0;
}
else
frente = frente + 1;
}
else
{
System.out.println ("LA COLA ESTA VACIA...");
System.exit (0);
}
return (e);
}
void imprimir ()
{
System.out.println ("IMPRIMIENDO LA COLA......");
for (int i = frente ; i <= fin ; i++)
System.out.println (v [i]);
}

[Estructura
de Datos]
int FINAL
()
Lic. Katya
{ Perez Martinez

return (fin);

Page 53

int FRENTE ()
{
return (frente);
}
void llenarCola ()
{
int N;
int e;
System.out.println ("Cuantos elementos desea insertar a la cola
??");
N = Lectura.Entero ();
for (int i = 1 ; i <= N ; i++)
{
System.out.print ("Introduzca un elemento....");
e = Lectura.Entero ();
insertar (e);
}
}
}

EJERCICIOS CON COLAS LINEALES


a.

Eliminar los divisores de x de una cola

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 54

// ELIMINAR LOS DIVISORES DE X DE UNA COLA LINEAL


class EjCola1
{
static Cola Q = new Cola ();
static void EliminarDivisoresX (Cola A)
{
int x;
int e;
int m = A.FINAL ();
System.out.print ("/////" + m);
System.out.println ("***** Eliminando Divisores de X de la
Cola Lineal****** ");
System.out.print ("Ingrese el valor de x....");
x = Lectura.Entero ();
while (A.FRENTE () != m + 1)
{
e = A.eliminar ();
if (x % e != 0)
A.insertar (e);
}
}

A.imprimir ();

public static void main (String args[])


{
Q.llenarCola ();
Q.imprimir ();
EliminarDivisoresX (Q);
}

3.6. COLAS CIRCULARES


Para hacer un uso ms eficiente de la memoria disponible se trata a la
cola como una estructura circular. Es decir, el elemento anterior al
primero es el ltimo. En la siguiente figura se muestra la representacin
de una cola circular.
9

Ejemplo

8
1

[Estructura de Datos]
Lic. Katya Perez Martinez

33

45

Page 55

22
Final

85

67

Frente

3
4

Para el siguiente ejemplo (a), en el cual ya no es posible adicionar


elementos siguiendo la anterior estructura, se propone la

alternativa

(b):

Frente Final
(a)

F
1

Final
Frente
FinalCIRCULARFinal
//COLA
DE NUMEROS ENTEROS Y SUS OPERACIONES
(b)
class ColaCircular
{

Final
Frente
final int MAX
= 20;
El diseo de la estructura de datos de una cola circular no varia en
(a) v[]
private
= new intde
[MAX];
relacin
a int
una
estructura
datos lineal, por tanto a continuacin
private int fin;

mostramos
las operaciones
que sufren cambios en este tipo de colas.
private int
frente;
ColaCircular ()

3.7.
{ Operaciones Con Colas Circulares
frente = 0;
fin = 0; bsicas con colas circulares son: insertar, eliminar y
Las operaciones
System.out.println ("COLA CREADA....");
mostrar
una cola circular. A continuacin mostramos la implementacin
}

en Java de una Cola Circular.


boolean vacia ()
{
if (frente == 0)
return (true);
else
[Estructura de
Datos]
return
(false);
Lic. Katya
} Perez Martinez

Page 56

boolean llena ()
{
if ((fin == MAX && frente == 1) || (fin + 1 == frente))
return (true);
else
return (false);
}
void insertar (int elem)
{
if (!llena ())
{
if (fin == MAX)
fin = 1;
else
if (frente == 0)
{
frente = 1;
fin = 1;
}
else
fin++;
v [fin] = elem;
}
else
{
}

System.out.println ("COLA CIRCULAR LLENA....");


System.exit (1);

}
int eliminar ()
{
int e = 0;
if (!vacia ())
{
e = v [frente];
if (frente == fin)
{
frente = 0;
fin = 0;
}
else
if (frente == MAX)
frente = 1;
else
frente = frente + 1;

}
[Estructura
de Datos]
else
Lic. Katya Perez
Martinez
{
}

System.out.println ("LA COLA ESTA VACIA...");


System.exit (0);

Page 57

return (e);
}
void imprimir ()
{
System.out.println ("IMPRIMIENDO LA COLA......");
for (int i = frente ; i <= fin ; i++)
System.out.println (v [i]);
}
int FINAL ()
{
return (fin);
}
int FRENTE ()
{
return (frente);
}
void llenarCola ()
{
int N;
int e;
System.out.println ("Cuantos elementos desea insertar a la
cola ??");
N = Lectura.Entero ();
for (int i = 1 ; i <= N ; i++)
{
System.out.print ("Introduzca un elemento....");
Lectura.Entero ();
[Estructura ede= Datos]
Page
insertar
(e);
Lic. Katya Perez Martinez
}
}
}

58

3.8. EJERCICIOS CON COLAS CIRCULARES


a.

Eliminar los elementos negativos de la cola circular

// ELIMINAR LOS NEGATIVOS DE LA COLA CIRCULAR


class EjColaCircular1
{
static ColaCircular Q = new ColaCircular ();
static void EliminarNegativos (ColaCircular A)
{
int e;
int m = A.FINAL ();
System.out.println ("***** Eliminando elementos Negativos de la
Cola Circular ****** ");
while (A.FRENTE () != m + 1)
{
e = A.eliminar ();
if (e>0)
A.insertar (e);
}
A.imprimir ();
}
public static void main (String args[])
{
Q.llenarCola
();
[Estructura
de Datos]
Q.imprimir
();
Lic. Katya Perez Martinez
}
}

EliminarNegativos(Q);

Page 59

3.9. COLAS DE PRIORIDADES


Una cola de prioridad es una estructura caracterstica, donde se pude
retirar e insertar un tem teniendo en cuenta la clave ms grande o ms
chica (segn la implementacin) definida por el programador. Si los
tems tienen claves iguales, entonces la regla usual utilizada es que el
primer tem insertado es el que se retirar primero.
Algunas aplicaciones de ste tipo de estructura son: la representacin
simulada de eventos dependientes del tiempo, como por ejemplo el
funcionamiento de un aeropuerto, controlando partidas y aterrizajes de
aviones. Otro ejemplo puede verse en los sistemas informticos, el CPU
asigna prioridades a las distintas tareas que debe ejecutar y las inserta
en su cola, para de esta manera realizarlas en el orden correcto
(multitareas).
Podemos representar una cola de prioridad como una lista contigua
ordenada, en la cual retirar un tem es una operacin inmediata, pero la
insercin tomara un tiempo proporcional al nmero de elementos que
se encuentren en la cola, hay que tener en cuenta que dicha operacin
se debe realizar en forma tal que la cola quede ordenada. Otra forma de
representacin es a travs de una lista desordenada, en la cual el
proceso de insercin es inmediato, pero el de extraccin es muy lento,
ya que debo recorrer toda la cola para encontrar el tem que debo
retirar.

3.10.

APLICACIN DE PILAS Y COLAS

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 60

Hasta ahora se ha tratado solamente con la representacin en memoria


y

manipulacin

de

una

nica

pila

cola.

Se

han

visto

dos

representaciones secuenciales eficientes para dichas estructuras. Sin


embargo, en ocasiones, es preciso representar varias estructuras
utilizando el mismo espacio de memoria.
Supongamos que seguimos transformando las estructuras de datos en
representaciones Secuenciales, tipo array. Si slo hay que representar
dos pilas sobre un mismo array A[1..n], la solucin puede resultar
simple. Se puede hacer crecer las dos pilas partiendo desde los
extremos opuestos del array, de forma que A[1] ser el elemento
situado en el fondo de la primera pila y A[n] el correspondiente para la
segunda pila. Entonces, la pila 1 crecer incrementando los ndices hacia
A[n] y la pila 2 lo har decrementando los ndices hacia A[1]. De esta
manera, es posible utilizar eficientemente todo el espacio disponible.
Si se plantea representar ms de dos pilas sobre ese mismo array A, no
es posible seguir la misma estrategia, ya que un array unidimensional
slo tiene dos puntos fijos, A[1] y A[n], y cada pila requiere un punto fijo
para representar el elemento ms profundo.
Cuando se requiere representar secuencialmente ms de dos pilas, por
ejemplo m pilas, es necesario dividir en m segmentos la memoria
disponible, A[1..n], y asignar a cada uno de los segmentos a una pila. La
divisin inicial de A[1..n] en segmentos se puede hacer en base al
tamao esperado de cada una de las estructuras. Si no es posible
conocer esa informacin, el array A se puede dividir en segmentos de
igual tamao. Para cada pila i, se utilizar un ndice f(i) para representar
el fondo de la pila i y un ndice c(i) para indicar dnde est su tope. En
general, se hace que f(i) est una posicin por debajo del fondo real de
la pila, de forma que se cumpla la condicin f(i)=c(i) si y solamente si la
pila i est vaca.

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 61

EJERCICIOS
1.

Realizar un programa para eliminar los elementos positivos de una


cola.

2.

Escribir un programa para intercambiar con su adyacente los


elementos de una cola

3.

Eliminar los elementos impares de la cola lineal

4.

Insertar dos elementos despus del elemento X de la cola

5.

Hallar el promedio de los elementos de la cola

6.

Sumar dos colas A y B en una Cola C.

7.

Intercambiar el elemento del frente de la cola por el elemento del


final de la cola.

8.

Intercambiar cada elemento con su adyacente.

9.

Hallar el menor elemento de la cola

10. Llevar

los elementos primos al frente de la cola

11. Eliminar

los elementos mltiplos de X de la cola circular

12. Utilizando
13. Utilice

colas circulares resuelva el problema de Josefo.

una estructura de cola para simular el movimiento de

clientes en una cola de espera de un banco..


14. Escriba

un programa que invierta los elementos de una cola.

15. Escriba

un procedimiento para insertar un elemento en una doble

cola Escriba un programa que cree una pila a partir de una cola.

4. CAPTULO RECURSIVIDAD

[Estructura

Aprende a nacer desde el dolor y a ser ms grande


Aprende a nacer desde el dolor y a ser ms grande
que el ms grande de los obstculos,
que el ms grande de los obstculos,
mrate en el espejo de ti mismo y sers libre y fuerte
mrate en el espejo de ti mismo y sers libre y fuerte
y dejars de ser un ttere de las circunstancias,
y dejars de ser un ttere de las circunstancias,
porque
tu mismo eres tu destino.
de
Datos]
porque
tu mismo eres tu destino.

Lic. Katya Perez Martinez

Pablo Neruda
Pablo Neruda

Page 62

4.1. INTRODUCCIN
Definicin de Recursividad: Tcnica de programacin muy potente
que puede ser usada en lugar de la iteracin.
Se dice que un objeto es recursivo, si en parte est formado por s
mismo o se define en funcin de s mismo
El concepto de recursividad va ligado al de repeticin. Son recursivos
aquellos algoritmos que, estando encapsulados dentro de una funcin,
son llamados desde ella misma una y otra vez, en contraposicin a los
algoritmos iterativos, que hacen uso de bucles while, do-while, for, etc.

4.2. AMBITO DE APLICACIN:


General
Problemas cuya solucin se puede hallar solucionando el mismo
problema pero con un caso de menor tamao.

4.3. RAZONES DE USO:


Problemas casi irresolubles con las estructuras iterativas.
Soluciones elegantes.
Soluciones ms simples.

Condicin necesaria: ASIGNACIN DINMICA DE MEMORIA

4.4. EN QU CONSISTE LA RECURSIVIDAD?


En el cuerpo de sentencias del subalgoritmo se invoca al propio
subalgoritmo para resolver una versin ms pequea del problema
original.
Habr un caso (o varios) tan simple que pueda resolverse directamente
[Estructura de Datos]
Lic. Katya Perez Martinez

Page 63

sin necesidad de hacer otra llamada recursiva.


Aspecto de un subalgoritmo recursivo.
ALGORITMO Recursivo(...)
INICIO
...
Recursivo(...);
...
FIN
... Como el costo de la programacin aumenta con regularidad y el
costo de la computacin disminuye, hemos llegado al punto en donde la
mayora de los casos no vale la pena que un programador desarrolle
laboriosamente una solucin no recursiva para un problema que se
resuelve con mayor naturalidad en forma recursiva.
La recursividad desde el punto de vista de la programacin es una
poderosa herramienta que facilita la implementacin de algunos
algoritmos que de otro modo se haran muy complejos. El ejemplo
clsico de esto ltimo es el recorrido de arboles.

4.5. FORMA DE ENFRENTAR PROBLEMAS RECURSIVOS.


a) Debe existir un caso BASE o Fin de recursin
ete debe ser un caso en que la funcin se puede computar en forma
simple (sin llamar a ninguna "copia" de ella). Este es el caso en que
se DETIENE la recursin
b) b) Parte puramente recursiva
Se debe confiar en que, al llamar a una COPIA de la funcin, ESA
funcin VA A RESOLVER EL PROBLEMA QUE LE ENTREGAMOS. No
importa cuan difcil sea ese problema, debemos creer que lo
soluciona.
Hay que verificar que el problema "ms pequeo" sea efectivamente
MS PEQUEO, es decir, que el problema est ms cerca de

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 64

solucionarse. La idea es que sepamos que en cada llamada recursiva


estamos mas cerca del caso BASE
PROBLEMA
DE TAMAO
N

PEQUEO
CALCULO

PROBLEMA
DE TAMAO
N-1

Ejemplo definicin de n natural:


El N 0 es natural
El N n es natural si n-1 lo es
El factorial de un nmero natural esta definido como:
n! = n*(n-1)*(n-2)* ... *3*2*1
con 0!= 1
claramente se ve que:
n! = n * (n-1)!
^
^ ^
|
|
|
|
|
Problema de tamao (n-1)
|
Calculo
Problema de tamao n
//ITERATIVO:
int Factorial( int n )
{ int i, res=1;
for (i=1; i <= n; i++ )
res = res * i;
return ( res );
}

//RECURSIVO:
int Factorial ( int n )
{ if (n == 0)
return (1); return (n * Factorial
(n-1) );
}

En la siguiente figura vemos el proceso de la recursividad

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 65

Es necesario llevar un registro de todas las operaciones que se dejan


pendientes hasta que se llega al caso base.
El patrn que sigue este registro es el de una pila, en donde la
operacin original se deja en el fondo y en el tope aparecera el caso
base.
Una vez que se llen la pila, se efecta la operacin de vaciar la pila
efectuando todos los clculos que previamente se haban dejado
pendientes

Por lo general, los lenguajes de alto nivel como el C, enmascaran todos


los detalles de la implementacin. A pesar de lo anterior es necesario
tomarlo en cuenta debido a que la pila exige una gran cantidad de
recursos (memoria y tiempo) de la mquina a la hora de ponerla a
funcionar.

4.6. TIPOS DE RECURSIVIDAD


Recursividad simple: Aquella en cuya definicin slo aparece
una llamada recursiva. Se puede transformar con facilidad en
algoritmos iterativos.
Recursividad mltiple: Se da cuando hay ms de una llamada a
s misma dentro del cuerpo de la funcin, resultando ms dificil de
hacer de forma iterativa.

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 66

Ejemplo

int Fib( int n )


/* ej: Fibonacci */
{ if ( n <=1)
return(1);
return ( Fib( n-1) + Fib(n-2) );
}

Recursividad anidada:
En algunos de los arg. de la llamada recursiva hay una nueva llamada
a s misma.
int Ack ( int n, int m ) /* ej: Ackerman */
{
if (n == 0 ) return (m+1)
else
if ( m == 0 ) return (Ack (n-1,1) );
return( Ack (n-1, Ack(n,m-1) ) );
}

Recursividad cruzada o indirecta:


Son algoritmos donde una funcin provoca una llamada a s misma de
forma indirecta, a travs de otras funciones.
Ejemplo: Par o Impar:
int par ( int nump )
{ if ( nump == 0 )
return(1);
return (impar (nump-1) );
}

int impar ( int numi )


{ if ( numi == 0 )
return(0);
return( par ( numi -1) );
}

4.7. LA PILA DE RECURSION

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 67

La memoria del ordenador se divide (de manera lgica, no fsica) en


varios segmentos (4):
Segmento de cdigo: Parte de la memoria donde se guardan las
instrucciones del programa en cod. Mquina.
Segmento de datos: Parte de la memoria destinada a almacenar las
variables estticas.
Montculo: Parte de la memoria destinada a las variables dinmicas.
Pila

del

programa:

Parte destinada a las variables locales y

parmetros de la funcin que est siendo ejecutada.

4.8. LA LLAMADA A UNA FUNCIN


Se reserva espacio en la pila para los parmetros de la funcin y sus
variables locales.
Se guarda en la pila la direccin de la lnea de cdigo desde donde se
ha llamado a la funcin.
Se almacenan los parmetros de la funcin y sus valores en la pila.
Al terminar la funcin, se libera la memoria asignada en la pila y se
vuelve a la instruccin actual.
En el caso recursivo, cada llamada genera un nuevo ejemplar de la
funcin con sus correspondientes objetos locales:
La funcin se ejecutar normalmente hasta la llamada a s misma. En
ese momento se crean en la pila nuevos parmetros y variables locales.
El nuevo ejemplar de funcin comieza a ejecutarse.
Se crean ms copias hasta llegar a los casos bases, donde se resuelve
directamente el valor, y se va saliendo liberando memoria hasta llegar a
la primera llamada (ltima en cerrarse)

EJERCICIOS
1) Calcular x elevado a n de forma recursiva:
3^2 = 9

3^0 = 1

float xelevn ( float base, int exp )


{ if (exp == 0 )
return(1);
[Estructura
de Datos]
Lic. Katya Perezreturn(
Martinez

1));
}

base * xelevn (base , exp-

Page 68

b). Multiplicar 2 ns con sumas sucesivas recursiva:


3*2 = 6
int multi( int a, int b )
{ if ( b == 0 )
return(0);
return( a + multi(a, b-1) );
}

C)

realizar en forma recursiva la funcin de Stirling

d) implementar en forma recursiva la funcin de ackerman


e) implementar en forma recursiva el problema de las torres
de Hanoi

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 69

5. Capitulo IV Listas Enlazadas

Muere lentamente, quien abandona un proyecto antes


Muere lentamente, quien abandona un proyecto antes
de iniciarlo, no preguntando de un asunto que desconoce
de iniciarlo, no preguntando de un asunto que desconoce
o no respondiendo cuando le indagan sobre algo que sabe.
o no respondiendo cuando le indagan sobre algo que sabe.
Evitemos la muerte en suaves cuotas, recordando
Evitemos la muerte en suaves cuotas, recordando
siempre que estar vivo exige un esfuerzo mucho mayor
siempre que estar vivo exige un esfuerzo mucho mayor
que el simple hecho de respirar.
que el simple hecho de respirar.
Pablo Neruda
Pablo Neruda

5.1. INTRODUCCIN A LAS ESTRUCTURAS DE DATOS


DINMICA
Hasta ahora, todos los tipos de datos que se han visto, ya sean simples o
estructurados, tienen una propiedad comn: son estticos. Esto significa
que las variables que se declaran en un programa de alguno de estos
tipos mantendrn la misma estructura durante la ejecucin del mismo.
Son variables estticas y se definen en tiempo de compilacin.
Ejemplo 1:
Si se declara un Vector de 5 elementos de tipo int, ste podr cambiar
su contenido, pero no su estructura.
Hay muchas situaciones en las que se desea cambiar el tamao de las
estructuras usadas.
La tcnica usada para manejar estas situaciones es la asignacin
dinmica de memoria. Con este tipo de asignacin se tendrn variables
dinmicas o referenciadas, que pueden crearse y destruirse en tiempo
de ejecucin.
Ejemplo 2:
[Estructura de Datos]
Lic. Katya Perez Martinez

Page 70

Si se pide disear un programa para gestionar una agenda de telfonos


con los datos de personas (nombre, apellidos, direccin, cumpleaos,
telfono, email, etc...). Qu estructura puede utilizarse para realizarla?
Una respuesta inmediata pareciera ser la de usar un array (vector o
matriz).
Si se usa un arreglo de dimensin MAX, pueden surgir los siguientes
problemas:
Qu pasa si se quieren insertar ms personas de MAX en la agenda?
Hay que recompilar el programa para ampliar MAX
Si el nmero de personas de la agenda es mucho menor que MAX se
est desperdiciando memoria que podra ser utilizada por otros
programas
En muchos otros casos no es posible conocer anteladamente el numero
de elementos que se van a usar.
Ejemplo 3:
Bases de datos para almacenar los datos de los estudiantes de la
universidad
Elementos de un dibujo de pantalla, cuyo tamao depende del dibujo
trazado

5.2. MECANISMOS PARA ENLAZAR INFORMACIN


1. LISTAS
o Listas simplemente enlazadas

Solo hay un enlace por nodo

Solo se puede recorrer en una direccin

o Listas doblemente enlazadas


o Lista circular simplemente enlazada
o Lista circular doblemente enlazada
2. RBOLES Y GRAFOS
[Estructura de Datos]
Lic. Katya Perez Martinez

Page 71

5.3. LISTAS ENLAZADAS


Las listas enlazadas son estructura de datos naturales
donde el nmero de elementos que la integran no
es conocido, o en su mejor caso, la cantidad de los
mismos puede variar.

Una lista enlazada es una estructura de datos en la que los objetos


estn ubicados linealmente.

En lugar de ndices de arreglo aqu se emplean punteros para


agrupar linealmente los elementos.

La lista enlazada permite implementar todas las operaciones de un


conjunto dinmico.

Si el predecesor de un elemento es NULL, se trata de la cabeza de


la lista.

Si el sucesor de un elemento es NULL, se trata de la cola de la


lista.

Cuando la cabeza es NULL, la lista est vaca o no existe la lista

Toda lista cuenta con una cabecera y


nodos.
Grficamente una lista simplemente enlazada se representa de la
siguiente forma:
Direccin de memoria

Cabeza de la
Lista

Nodo
23

Ultimo elemento de
la Lista

Info

12

enlace

NOTA Las listas almacenadas en arreglos estn sujetos al tamao del


arreglo para su crecimiento. Si estos estn vacos se esta ocupando
[Estructura de Datos]
Lic. Katya Perez Martinez

Page 72

memoria sin uso. Adems las listas reflejan el orden lgico y el orden
fsico de los elementos en el arreglo.

Caractersticas:
Las listas son una secuencia ordenada de
elementos llamados nodo
Toda lista tiene una cabecera y una
cola.
Todos los nodos de la lista son del
mismo tipo.
Una lista enlazada es una secuencia ordenada de elementos llamados
nodos

5.4. TIPO DE DATO ABSTRACTO NODO

Un NODO es una estructura compuesta bsicamente de dos partes:

Un campo de informacin, en cual se almacenan datos o


estructuras

Un campo de direccin, en el cual se almacena la direccin


del nodo siguiente.

La implementacin de un nodo podra ser de la siguiente forma:

5.5. CONSTRUCCIN DE UN TAD LISTA ENLAZADA


LINEAL SIMPLE
Nodo
Info: tipo_dato
Dirsgte: Nodo
Nodo()

[Estructura de Datos]
Lic. Katya Perez Martinez

ListaLineal
P: Nodo
InsertarInicio(e)
InsertarFinal()
EliminarInicio()
EliminarFinal()
Recorrido()

Page 73

La estructura del nodo para una lista enlazada Lineal Simple es la


siguiente, para datos de tipo doubl, implementado en java
private class nodo
{
private double info;
private nodo dirsgte;
private nodo ()
{
}

Donde:
Info:

es la informacin del nodo.

dirsgte:

almacena la direccin del siguiente nodo de la lista, en

caso de ser el ltimo nodo entonces apunta a nulo.

5.6. OPERACIONES BSICAS SOBRE LISTAS


ENLAZADAS
Existen cinco operaciones bsicas que se pueden hacer sobre listas
enlazadas:

Creacin: de una lista vaca

Vaca: Retorna verdadero si la lista L est vaca y falso en caso


contrario.

Insercin: Agregar un elemento al final de la lista.

Acceso: Examinar el primer elemento de la lista.

Eliminar: Se puede quitar el primer elemento de la lista, o


remover todos los elementos de la misma.

Buscar: ver si la lista contiene un elemento determinado.

Anula: Permite convertir la lista en una lista vaca

Imprime Lista: Imprime los elementos de la lista L

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 74

Creacin de una lista vaca

A continuacin implementamos la sentencia para crear una lista


vaca en java.
nodo p = null;

Insercin
a)

Insercin al Final de la lista

En el siguiente segmento de cdigo se ejemplifica solamente el caso


en el que el elemento se adiciona al final de la lista tal y como si se
tratase de una estructura Pila o Cola.
La implementacin en java es la siguiente:
public void insertarFinal (double elem)
{
//Inserta un elemento elem al final de la lista p en el nodo q
nodo q = new nodo ();
nodo t = p;
q.info = elem;
q.dirsgte = null;
if (p == null)
p = q;
else
{
while (t.dirsgte != null)
t = t.dirsgte;
t.dirsgte = q;
}
}

b)

Insercin al Inicio de la lista

En el siguiente segmento de cdigo se implementa el caso en el que el nuevo nodo


se inserta en la cabeza de la lista, a continuacin se muestra la implementacin en
public void insertarInicio (double elem)
java:
{
//Aniadir un elemento al principio de la lista
nodo q = new nodo ();
q.info = elem;
[Estructura de Datos]
Page 75
q.dirsgte = p;
Lic. Katya Perez Martinez
p = q;
}

Para el siguiente ejemplo se ilustra el proceso de adicin de un nuevo nodo


p = Inserta_Inicio(&p,10);

c)

Recorrido de una Lista:

Para mostrar los elementos de la lista se realiza el recorrido de la misma,


a partir del nodo cabeza de la lista hasta encontrar el ltimo nodo.
Recordemos que el ltimo nodo tiene la propiedad que su miembro
dirsgte es igual a NULL.
public void recorrido ()
{
//Recorrer la lista
System.out.println (" ....RECORRIDO DE LA LISTA....");
nodo q = p;
while (q != null)
{
System.out.println (q.info + " ");
[Estructura de Datos]
Page 76
q = q.dirsgte;
Lic. Katya Perez Martinez
}
}

d)

Eliminar el nodo del inicio de la Lista

La siguiente funcin recibe una lista y devuelve esa misma lista, sin el
nodo que ocupaba inicialmente la posicin de la cabeza.
La funcin ser la siguiente:

void eliminaInicio ()
{
//elimina el nodo del inicio de la lista
nodo q = p;
p = p.dirsgte;
q = null;
}

e)

Eliminar el nodo del Final de la Lista

void eliminaFinal ()
{
//elimina un nodo del final de la lista
nodo q = p;
if (p.dirsgte == null)
p = null;
else
{
nodo t = p;
while (q.dirsgte != null)
{
t = q;
q = q.dirsgte;
}
t.dirsgte = null;
q = null;
[Estructura}de Datos]
Lic. Katya Perez
} Martinez

Page 77

5.7. IPLEMENTACIN EN EL LENGUAJE JAVA DE LA


CLASE LISTAS LINEALES

//LISTAS LINEALES
import java.io.*;
A continuacin realizamos la implementacin del programa completo de
public class listaLineal
{ listas simples, para datos de tipo doubl en java
//p: referencia al primer elemento de la lista, es el puntero
cabecera
private nodo p = null; //crea la lista p
//nodo de una lista lineal simplemente enlazada
private class nodo
{
private double info;
private nodo dirsgte;
private nodo ()
{
}
}
public listaLineal ()
{
}
public void insertarInicio (double elem)
{
//Aniadir un elemento al principio de la lista
nodo q = new nodo ();
q.info = elem;
q.dirsgte = p;
p = q;
}
public void insertarFinal (double elem)
{
//Inserta un elemento elem al final de la lista p en el nodo q
nodo q = new nodo ();
nodo t = p;
q.info = elem;
q.dirsgte = null;
if (p == null)
p =Datos]
q;
[Estructura de
Lic. Katya Perez
Martinez
else
{
while (t.dirsgte != null)
t = t.dirsgte;

Page 78

}}

t.dirsgte = q;

public void recorrido ()


{
//Recorrer la lista
System.out.println (" ....RECORRIDO DE LA LISTA....");
nodo q = p;
while (q != null)
{
System.out.println (q.info + " ");
q = q.dirsgte;
}
}
void eliminaInicio ()
{
//elimina el nodo del inicio de la lista
nodo q = p;
p = p.dirsgte;
q = null;
}
void eliminaFinal ()
{
//elimina un nodo del final de la lista
nodo q = p;
if (p.dirsgte == null)
p = null;
else
{
nodo t = p;
while (q.dirsgte != null)
{
t = q;
q = q.dirsgte;
}
t.dirsgte = null;
q = null;
}
}
public void llenarLista () throws IOException
{
//llena la lista enlazada con elementos de tipo real con N
elementos
InputStreamReader
isr = new InputStreamReader (System.in);
[Estructura
de Datos]
Page 79
br = new BufferedReader (isr);
Lic. KatyaBufferedReader
Perez Martinez
String dato;
int N;

double elem;
System.out.println ("Cuantos elementos desea ingresar a la
lista ?");
dato = br.readLine ();
N = Integer.parseInt (dato);
for (int i = 1 ; i <= N ; i++)
{
System.out.println ("ingrese elemento ....");
dato = br.readLine ();
elem = Double.valueOf (dato).doubleValue ();
insertarFinal (elem);
}

}
}

import java.io.*;
class ejemLista1
{
public static void main (String args[]) throws IOException
{
EJERCICIO //crear una lista lineal L vacia
listaLineal
L para
= new
listaLineal
();
Escribir una aplicacin
en java
llamar
a todas las operaciones
con listas.
//leer datos reales y agregarlos a la lista
L.llenarLista ();
L.recorrido ();
L.eliminaInicio ();
L.recorrido ();
L.eliminaFinal ();
L.recorrido ();

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 80

5.8. LISTAS DOBLEMENTE ENLAZADAS


Una lista doble, doblemente enlazada es una coleccin de nodos en la
cual cada nodo tiene dos punteros, uno de ellos apuntando a su
predecesor (li) y otro a su sucesor (ld). Por medio de estos punteros se
podr avanzar o retroceder a travs de la lista, segn se tomen las
direcciones de uno u otro puntero.
La estructura de un nodo en una lista doble es la siguiente:

Existen dos tipos de listas doblemente ligadas:

Listas dobles lineales. En este tipo de lista doble, tanto el


puntero izquierdo del primer nodo como el derecho del ltimo
nodo apuntan a NIL.

Listas dobles circulares. En este tipo de lista doble, el puntero


izquierdo del primer nodo apunta al ltimo nodo de la lista, y el
puntero derecho del ltimo nodo apunta al primer nodo de la lista.

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 81

Debido a que las listas dobles circulares son ms eficientes, los


algoritmos que en esta seccin se traten sern sobre listas dobles
circulares.
En la figura siguiente se muestra un ejemplo de una lista doblemente
ligada lineal que almacena nmeros:

En la figura siguiente se muestra un ejemplo de una lista doblemente


ligada circular que almacena nmeros:

A continuacin mostraremos algunos algoritmos sobre listas enlazadas.


Como ya se mencion, llamaremos li al puntero izquierdo y ld al puntero
derecho, tambin usaremos el apuntador top para hacer referencia al
primer nodo en la lista, y p para referenciar al nodo presente.

Algoritmo de creacin
top<--NIL
repite
si top=NIL entonces
new(p)
lee(p(dato))
p(ld)<--p
p(li)<--p
top<--p
en caso contrario
new(p)
lee(p(dato))
p(ld)<--top
p(li)<--p
p(ld(li))<--p
mensaje(otro nodo?)
lee (respuesta)
hasta respuesta=no

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 82

Algoritmo para recorrer la lista


--RECORRIDO A LA DERECHA.
p<--top
repite
escribe(p(dato))
p<--p(ld)
hasta p=top
--RECORRIDO A LA IZQUIERDA.
p<--top
repite
escribe(p(dato))
p<--p(li)
hasta p=top(li)

Algoritmo para insertar antes de 'X' informacin


p<--top
mensaje (antes de ?)
lee(x)
repite
si p(dato)=x entonces
new(q)
leer(q(dato))
si p=top entonces
top<--q
q(ld)<--p
q(li)<--p(li)
p(ld(li))<--q
p(li)<--q
p<--top
en caso contrario
p<--p(ld)
hasta p=top

Algoritmo para insertar despues de 'X' informacin


p<--top
mensaje(despues de ?)
lee(x)
repite
si p(dato)=x entonces
new(q)

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 83

lee(q(dato))
q(ld)<--p(ld)
q(li)<--p
p(li(ld))<--q
p(ld)<--q
p<--top
en caso contrario
p<--p(ld)
hasta p=top

Algoritmo para borrar un nodo


p<--top
mensaje(Valor a borrar)
lee(valor_a_borrar)
repite
si p(dato)=valor_a_borrar entonces
p(ld(li))<--p(ld)
p(li(ld))<--p(li)
si p=top entonces
si p(ld)=p(li) entonces
top<--nil
en caso contrario
top<--top(ld)
dispose(p)
p<--top
en caso contrario
p<--p(ld)
hasta p=top

5.9. LISTAS CIRCULARES DOBLES


Las listas circulares tienen la caracterstica de que el ltimo elemento de
la misma apunta al primero
La siguiente figura es una representacin grfica de una lista circular.

Enseguida se mostrarn los algoritmos ms comunes en listas circulares.


Al igual que en las secciones anteriores, utilizaremos el apuntador top
para hacer referencia al primer nodo en la lista.
[Estructura de Datos]
Lic. Katya Perez Martinez

Page 84

Algoritmo de creacin
repite
new(p)
lee(p(dato))
si top=nil entonces
top<--p
q<--p
en caso contrario
q(liga)<--p
q<--p
p(liga)<--top
mensaje (otro nodo ?)
lee(respuesta)
hasta respuesta=no

Algoritmo para recorrer la lista


p<--top
repite
escribe(p(dato))
p<--p(liga)
hasta p=top

Algoritmo para insertar antes de 'X' informacin


new(p)
lee(p(dato))
si top=nil entonces
top<--p
p(liga)<--top
en caso contrario
mensaje(antes de ?)
lee(x)
q<--top
r<--top(liga)
repite
si q(dato)=x entonces
p(liga)<--q
r(liga)<--p
si p(liga)=top entonces
top<--p
q<--q(liga)
r<--r(liga)
hasta q=top

Algoritmo para insertar despus de 'X' informacin


new(p)
lee(p(dato))
mensaje(despus de ?)
lee(x)
q<--top
r<--top(liga)
repite
si q(dato)=x entonces
q(liga)<--p
p(liga)<--r

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 85

q<--q(liga)
r<--r(liga)
hasta q=top

Algoritmo para borrar


mensaje(valor a borrar )
lee(valor_a_borrar)
q<--top
r<--top
p<--top
mientras q(liga)<>top haz
q<--q(liga)
repite
si p(dato)=valor_a_borrar entonces
si p=top entonces
si top(liga)=top entonces
top<--NIL
en caso contrario
top<--top(liga)
q(liga)<--top
en caso contrario
r(liga)<--p(liga)
dispose(p)
p<--top
en caso contrario
r<--p
p<--p(liga)
hasta p=top

EJERCICIOS

1. Eliminar el primer elemento negativo de la lista lineal


2. Insertar un nuevo nodo despus del tercer nodo de la lista lineal
3. Eliminar todos los elementos X dado por el usuario de una lista
circular simple.
4. Escriba

un

programa

que

permita

adicionar

elementos

no

repetidos a una lista. Es decir antes de insertar un determinado


elemento se debe verificar antes que ste no se encuentre en la
lista.
5. adicionar un elemento X a una lista de forma ordenada, de tal
forma que la lista quede ordenada, una vez insertado X.

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 86

6. Escriba un programa que permita eliminar el elemento de la cola


de una lista
7. En una lista doble eliminar todos los elementos cuya informacin
sea X. X dado por el usuario
8. Insertar N nodos nuevos despus del nodo K-esimo.
9. Eliminar N nodos desde la posicin k de la lista enlazada circular
simple.
10.

Considere que dos listas L1 y L2, ya tienen elementos de tipo

doubl, entonces se desea llevar todos los elementos impares al


final de la lista L1, de la lista L2.

6. Capitulo VI rboles y Grafos


Tu vida no cambia cuando cambia tu jefe,
Tu vida no cambia cuando cambia tu jefe,
Cuando tus amigos cambian,
Cuando tus amigos cambian,
Cuando tus padres cambian,
Cuando tus padres cambian,
Cuando tu pareja cambia.
Cuando tu pareja cambia.
Tu vida cambia, cuando tu cambias,
Tu vida cambia, cuando tu cambias,
Eres el nico responsable por ella.
Eres el nico responsable por ella.
"examnate.. Y no te dejes vencer"
"examnate.. Y no te dejes vencer"

6.1. DEFINICIN RBOL

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 87

Un rbol es una estructura no lineal en la que cada nodo puede


apuntar a uno o
varios nodos.

6.2. CONCEPTOS BSICOS

a. Nodo hijo:
cualquiera de los
nodos apuntados
por uno de los
nodos del rbol. En
el ejemplo, 'L' y 'M'
son hijos de 'F'.
b. Nodo padre: nodo
que contiene un
puntero al nodo actual. En el ejemplo, el nodo 'A' es padre de 'B',
'C' y 'D'.
Los rboles con los que trabajaremos tienen otra caracterstica
importante: cada nodo slo puede ser apuntado por otro nodo, es decir,
cada nodo slo tendr un padre. Esto hace que estos rboles estn
fuertemente jerarquizados, y es lo que en realidad les da la apariencia
de rboles.
En cuanto a la posicin dentro del rbol:
c. Nodo raz: nodo que no tiene padre. Este es el nodo que
usaremos para referirnos al rbol. En el ejemplo, ese nodo es el
'A'.
d. Nodo hoja: nodo que no tiene hijos. En el ejemplo hay varios: 'G',
'H', 'I', 'K', 'L', 'M', 'N' y 'O'.
[Estructura de Datos]
Lic. Katya Perez Martinez

Page 88

e. Nodo rama: aunque esta definicin apenas la usaremos, estos


son los nodos que no pertenecen a ninguna de las dos categoras
anteriores. En el ejemplo: 'B', 'C', 'D', 'E', 'F' y 'J'.

Existen otros conceptos que definen las caractersticas del rbol, con
relacin a su tamao:
f. Orden: es el numero potencial de hijos que puede tener cada
elemento de rbol. De este modo, diremos que un rbol en el que
cada nodo puede apuntar a otros dos es de orden dos, si puede
apuntar a tres ser de orden tres, etc.
g. Grado: el nmero de hijos que tiene el elemento con ms hijos
dentro del rbol. En el rbol del ejemplo, el grado es tres, ya que
tanto 'A' como 'D' tienen tres hijos, y no existen elementos con
ms de tres hijos.
h. Nivel: se define para cada elemento del rbol como la distancia a
la raz, medida en nodos. El nivel de la raz es cero y el de sus hijos
uno. As sucesivamente. En el ejemplo, el nodo 'D' tiene nivel 1, el
nodo 'G' tiene nivel 2, y el nodo 'N', nivel 3.
i. Altura: la altura de un rbol se define como el nivel del nodo de
mayor nivel. Como cada nodo de un rbol puede considerarse a su
vez como la raz de un rbol, tambin podemos hablar de altura de
ramas. El rbol del ejemplo tiene altura 3, la rama 'B' tiene altura
2, la rama 'G' tiene altura 1, la 'H' cero, etc.

6.3. CARACTERSTICAS DE LOS ARBOLES BINARIOS


A los arboles ordenados de grado dos se les conoce como arboles
binarios ya que cada nodo del rbol no tendr ms de dos descendientes
directos. Las aplicaciones de los arboles binarios son muy variadas ya
que se les puede utilizar para representar una estructura en la cual es
posible tomar decisiones con dos opciones en distintos puntos.
La representacin grfica de un rbol binario es la siguiente:

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 89

Los arboles representan las estructuras no lineales y dinmicas de datos


ms importantes en computacin . Dinmicas porque las estructuras de
rbol pueden cambiar durante la ejecucin de un programa. No lineales,
puesto que a cada elemento del rbol pueden seguirle varios elementos.
Los arboles pueden ser construidos con estructuras estticas y
dinmicas. Las estticas son arreglos, registros y conjuntos, mientras
que las dinmicas estn representadas por listas.
La definicin de rbol es la siguiente: es una estructura jerrquica
aplicada sobre una coleccin de elementos u objetos llamados nodos;
uno de los cuales es conocido como raz. adems se crea una relacin o
parentesco entre los nodos dando lugar a trminos como padre, hijo,
hermano, antecesor, sucesor, ansestro, etc.. Formalmente se define un
rbol de tipo T como una estructura homognea que es la concatenacin
de un elemento de tipo T junto con un nmero finito de arboles
disjuntos, llamados subarboles. Una forma particular de rbol puede ser
la estructura vaca.
La figura siguiente representa a un rbol general.

Se utiliza la recursin para definir un rbol porque representa la forma


ms apropiada y porque adems es una caracterstica inherente de los
mismos.
[Estructura de Datos]
Lic. Katya Perez Martinez

Page 90

Los arboles tienen una gran variedad de aplicaciones. Por ejemplo, se


pueden utilizar para representar frmulas matemticas, para organizar
adecuadamente la informacin, para construir un rbol genealgico,
para el anlisis de circuitos elctricos y para numerar los captulos y
secciones de un libro.

6.4. TRANSFORMACIN DE UN ARBOL GRAL. EN UN


ARBOL BINARIO
Estableceremos los mecanismos necesarios para convertir un rbol
general en un rbol binario. Para esto, debemos seguir los pasos que se
describen a continuacin:
1. Enlazar los hijos de cada nodo en forma horizontal (los hermanos).
2. Enlazar en forma vertical el nodo padre con el nodo hijo que se
encuentra ms a la izquierda. Adems, debe eliminarse el vnculo de
ese padre con el resto de sus hijos.
3. Rotar el diagrama resultante aproximadamente 45 grados hacia la
izquierda, y as se obtendr el rbol binario correspondiente.

6.5. REPRESENTACIN DE UN RBOL EN MEMORIA


Hay dos formas tradicionales de representar un rbol binario en
memoria:
Por medio de datos tipo punteros tambin conocidos como variables
dinmicas o listas.
Por medio de arreglos.
Sin embargo la ms utilizada es la primera, puesto que es la ms natural
para tratar este tipo de estructuras.
Los nodos del rbol binario sern representados como registros que
contendrn como mnimo tres campos. En un campo se almacenar la
[Estructura de Datos]
Lic. Katya Perez Martinez

Page 91

informacin del nodo. Los dos restantes se utilizarn para apuntar al


subarbol izquierdo y derecho del subarbol en cuestin.
Cada nodo se representa grficamente de la siguiente manera:

El algoritmo de creacin de un rbol binario es el siguiente:


Procedimiento crear(q:nodo)
inicio
mensaje("Rama izquierda?")
lee(respuesta)
si respuesta = "si" entonces
new(p)
q(li) <-- nil
crear(p)
en caso contrario
q(li) <-- nil
mensaje("Rama derecha?")
lee(respuesta)
si respuesta="si" entonces
new(p)
q(ld)<--p
crear(p)
en caso contrario
q(ld) <--nil
fin
INICIO
new(p)
raiz<--p
crear(p)
FIN

6.6. CLASIFICACIN DE ARBOLES BINARIOS


Existen cuatro tipos de rbol binario:.

A. B. Distinto.

A. B. Similares.

A. B. Equivalentes.

A. B. Completos.

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 92

A continuacin se har una breve descripcin de los diferentes tipos de


rbol binario as como un ejemplo de cada uno de ellos.
A. B. DISTINTO
Se dice que dos rboles binarios son distintos cuando sus estructuras
son diferentes. Ejemplo:

A. B. SIMILARES
Dos arboles binarios son similares cuando sus estructuras son idnticas,
pero la informacin que contienen sus nodos es diferente. Ejemplo:

A. B. EQUIVALENTES
Son aquellos arboles que son similares y que adems los nodos
contienen la misma informacin. Ejemplo:

A. B. COMPLETOS
Son aquellos arboles en los que todos sus nodos excepto los del ultimo
nivel, tiene dos hijos; el subarbol izquierdo y el subarbol derecho

6.7. RECORRIDO DE UN ARBOL BINARIO

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 93

Hay tres manera de recorrer un rbol : en inorden, preorden y postorden.


Cada una de ellas tiene una secuencia distinta para analizar el rbol
como se puede ver a continuacin:
1. INORDEN
o

Recorrer el subarbol izquierdo en inorden.

Examinar la raz.

Recorrer el subarbol derecho en inorden.

2. PREORDEN
o

Examinar la raz.

Recorrer el subarbol izquierdo en preorden.

recorrer el subarbol derecho en preorden.

3. POSTORDEN
o

Recorrer el subarbol izquierdo en postorden.

Recorrer el subarbol derecho en postorden.

Examinar la raz.

A continuacin se muestra un ejemplo de los diferentes recorridos en un


rbol binario.

Inorden: GDBHEIACJKF
Preorden: ABDGEHICFJK
Postorden: GDHIEBKJFCA

6.8. ARBOLES ENHEBRADOS


[Estructura de Datos]
Lic. Katya Perez Martinez

Page 94

Existe un tipo especial de rbol binario llamado enhebrado, el cual


contiene hebras que pueden estar a la derecha o a la izquierda. El
siguiente ejemplo es un rbol binario enhebrado a la derecha.

ARBOL ENHEBRADO A LA DERECHA. Este tipo de rbol tiene un


apuntador a la derecha que apunta a un nodo antecesor.

ARBOL ENHEBRADO A LA IZQUIERDA. Estos arboles tienen un


apuntador a la izquierda que apunta al nodo antecesor en orden

6.9. ARBOLES BINARIOS DE BSQUEDA


Un rbol de bsqueda binaria es una estructura apropiada para muchas
de las aplicaciones que se han discutido anteriormente con listas. La
ventaja especial de utilizar un rbol es que se facilita la bsqueda.
Un rbol binario de bsqueda es aquel en el que el hijo de la izquierda
(si existe) de cualquier nodo contiene un valor ms pequeo que el nodo
padre, y el hijo de la derecha (si existe) contiene un valor ms grande
que el nodo padre.
Un ejemplo de arbol binario de bsqueda es el siguiente:

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 95

6.10. GRAFOS
Un grafo dirigido G consiste en un conjunto de vrtices V y un conjunto
de arcos o aristas A. Los vertice se denominan tambin nodos o puntos.
Un arco, es un par ordenado de vrtices(V,W) donde V es el vrtice
inicial y W es el vrtice terminal del arco. Un arco se expresa como: V->W y se representa de la siguiente manera:

Los vrtice de un grafo pueden usarse para representar objetos. Los


arcos se utilizan para representar relaciones entre estos objetos.
Las aplicaciones ms importantes de los grafos son las siguientes:

Rutas entre ciudades.

Determinar tiempos mximos y mnimos en un proceso.

Flujo y control en un programa.

6.11.

DEFINICIONES BSICAS

La terminologa que manejaremos regularmente para el uso de grafos es


la siguiente:

CAMINO.Es una secuencia de vrtices V1, V2, V3, ... , Vn, tal que
cada uno de estos V1-&gtV2, V2-&gtV3, V1-&gtV3.

LONGITUD DE CAMINO. Es el nmero de arcos en ese camino.

CAMINO SIMPLE. Es cuando todos sus vrtices, excepto tal vez el


primero y el ltimo son distintos.

CICLO SIMPLE. Es un camino simple de longitud por lo menos de


uno que empieza y termina en el mismo vrtice.

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 96

ARISTAS PARALELAS. Es cuando hay ms de una arista con un


vrtice inicial y uno terminal dados.

GRAFO CICLICO. Se dice que un grafo es cclico cuando contiene


por lo menos un ciclo.

GRAFO ACICLICO. Se dice que un grafo es aciclco cuando no


contiene ciclos.

GRAFO CONEXO. Un grafo G es conexo, si y solo si existe un


camino simple en cualesquiera dos nodos de G.

GRAFO COMPLETO FUERTEMENTE CONEXO.Un grafo dirigido


G es completo si para cada par de nodos (V,W) existe un camino
de V a W y de W a V (forzosamente tendrn que cumplirse ambas
condiciones), es decir que cada nodo G es adyacente a todos los
dems nodos de G.

GRAFO

UNILATERALMENTE

CONEXO.Un

grafo

es

unilateralmente conexo si para cada par de nodos (V,W) de G hay


un camino de V a W o un camino de W a V.

GRAFO PESADO ETIQUETADO. Un grafo es pesado cuando sus


aristas contienen datos (etiquetas). Una etiqueta puede ser un
nombre, costo un valor de cualquier tipo de dato. Tambin a este
grafo se le denomina red de actividades, y el nmero asociado al
arco se le denomina factor de peso.

VERTICE ADYACENTE. Un nodo o vrtice V es adyacente al nodo


W si existe un arco de m a n.

GRADO DE SALIDA.El grado de salida de un nodo V de un grafo


G, es el nmero de arcos o aristas que empiezan en V.

GRADO DE ENTRADA.El grado de entrada de un nodo V de un


grafo G, es el nmero de aristas que terminan en V.

NODO FUENTE.Se le llama as a los nodos que tienen grado de


salida positivo y un grado de entrada nulo.

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 97

NODO SUMIDERO.Se le llama sumidero al nodo que tiene grado


de salida nulo y un grado de entrada positivo.

6.12. REPRESENTACIN EN MEMORIA SECUENCIAL


Los grafos se representan en memoria secuencial mediante matrices de
adyacencia.
Una matrz de adyacencia, es una matrz de dimensin n*n, en donde n
es el nmero de vrtices que almacena valores booleanos, donde matrz
M[i,j] es verdadero si y solo si existe un arco que vaya del vrtice y al
vrtice j.
Veamos el siguiente grafo dirigido:

La matrz de adyacencia, que se obtuvo a partir del grafo anterior es la


siguiente:

6.13. REPRESENTACIN EN MEMORIA ENLAZADA


Los grafos se representan en memoria enlazada mediante listas de
adyacencia.
Una lista de adyacencia, se define de la siguiente manera: Para un
vrtice i es una lista en cierto orden formada por todos los vrtices

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 98

adyacentes [a,i]. Se puede representar un grafo por medio de un arreglo


donde cabeza de i es un apuntador a la lista de adyacencia al vrtice i.
Veamos el siguiente grafo dirigido:

La lista de adyacencia, que se obtuvo a partir del grafo anterior es la


siguiente:

Otros ejemplos de Representacin de grafo son los siguientes

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 99

6.14. OPERACIONES SOBRE GRAFOS


En esta seccin analizaremos algunas de las operaciones sobre grafos,
como

Creacin.

Insercin.

Bsqueda.

Eliminacin.

En esta seccin, continuaremos utilizando los apuntadores que se usaron


en las secciones anteriores. TOP para hacer referencia al primer nodo,
LD para indicar liga derecha y LA para indicar liga abajo, por ltimo
usaremos los apuntadores P y Q para hacer referencia a los nuevos
nodos que vayan a ser usados.

ALGORITMO DE CREACION.
repite
si top=NIL entonces
new(top)
top(la)<--NIL
top(ld)<--NIL
lee(top(dato))
q<--top
en caso contrario
new(p)
p(ld)<--NIL
p(la)<--NIL
q(la)<--p
lee(p(dato))
q<--p
mensaje(otro vertice ?)
lee(respuesta)
hasta repuesta=no
p<--top
mientras p<>NIL haz
mensaje(tiene vrtices adyacentes p(dato) ?)
lee(respuesta)
si respueta=si entonces
repite
new(q)
lee(q(dato))
q(ld)<--p(ld)
p(ld)<--q
mensaje(otro vrtice ?)
lee(respuesta2)
hasta respuesta2=no

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 100

p<--p(la)

ALGORITMO DE INSERCION
mensaje(valor a insertar ?)
lee(valor_a_insertar)
si top<>NIL entonces
p<--top
mientras p(la)<>NIL haz
p<--p(la)
new(q)
lee(q(dato))
p(la)<--q
q(la)<--NIL
mensaje(Hay vrtices adyacentes?)
lee(respuesta)
si respuesta=si entonces
mensaje(Cuantos vrtices?)
lee(nmero_vrtices)
desde i=1 hasta nmero_vrtices haz
new(p)
lee(p(dato))
q(ld)<--p
q<--q(ld)
en caso contrario
mensaje(no existe lista)

ALGORITMO DE BUSQUEDA
mensaje(vrtice a buscar)
lee(vrtice_a_buscar)
p<--top
repite
si p(dato)=vrtice_a_buscar entonces
repite
p<--p(ld)
escribe(p(dato))
hasta p(ld)=NIL
en caso contrario
p<--(la)
hasta p=NIL

ALGORITMO DE BORRADO
mensaje(vrtice a borrar ?)
lee(vrtice_a_borrar)
p&Lt--top
r<--p
q<--p
sw<--falso
repite
si p(dato)=vrtice_a_borrar entonces
si p=top entonces
top<--top(la)
r<--top
sw<--verdadero
en caso contrario
r(la)<--p(la)
repite

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 101

p<--p(ld)
dispose(q)
q<--p
hasta p=NIL
si sw=verdadero entonces
p<--r
q<--p
en caso contrario
p<--r(la)
q<--p
en caso contrario
r<--p
repite
q<--p(ld)
si q(dato)=vrtice_a_borrar entonces
p(ld)<--q(ld)
dispose(q)
q<--p
en caso contrario
p<--p(ld)
hasta p=NIL

6.15. CAMINO MNIMO


Se denomina camino mnimo entre dos vrtices V y W, al camino ptimo
entre ambos vrtices.Para determinar el camino mnimo entre dos
vrtices se utiliza el siguiente algoritmo:
desde i=1 hasta nmero_vrtices haz
desde j=1 hasta nmero_vrtices haz
si w[i,j]=0 entonces
q[[i,j]<--infinito
en caso contrario
q[i,j]<--w[i,j]
desde k=1 hasta nmero_vrtices haz
desde i=1 hasta nmero_vrtices haz
desde j=1 hasta nmero_vrtices haz
q[i,j]<--min(q[i,j], q[i,k] + q[k,j])

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 102

EJERCICIOS

3. Dado un rbol binario de busqueda , que contiene el nombre,


el apellido y la edad de un grupo de personas , ordenados por
edades .
Se pide :
Hacer un algoritmo que visualice los datos de las personas de
mayor a menor edad .
4. Dado un ABB que contiene nmeros enteros .
Se pide :
- Hacer un procedimiento que reciba como parmetros: el
puntero a raiz del arbol , y un nmero entero . El procedimiento
debe buscar el elemento NUM y una vez encontrado visualizar
todos sus antecesores (los anteriores).

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 103

GLOSARIO
ALGORITMO. Es una descripcin de los pasos de una tarea.
ASCII. American Standard Code for Information Interchange. Es un
cdigo

muy

utilizado

para

el

intercambio

de

datos.

Como

los

ordenadores solo procesan dgitos binarios, cada letra, dgito o carcter


especial tiene su correspondiente cdigo binario.
ASIGNACIN. Usado en programacin. Es la accin de poner en una
variable un valor, l contenido de otra variable o el resultado de evaluar
una expresin. En la mayora de los lenguajes se representa con el signo
igual.
RBOL. Es uno de los posibles tipos de estructurar los datos. Todos los
elementos menos uno, (el raz), tienen un antecedente. Todos pueden
tener otros elementos asociados llamados consecuentes.
BIFURCACIN. En programacin: transferencia de la secuencia de
ejecucin

otra

parte

del

programa.

Puede

ser

condicional

incondicional aunque esta ltima est mal vista en los lenguajes


estructurados.
BUCLE. En un programa es un grupo de instrucciones que se repiten
hasta que se cumple una condicin.
BYTE. Conjunto de bits que contiene el cdigo para un carcter. El byte
de 8 bits, llamado octeto, es el ms usado actualmente. Las capacidades
de almacenamiento se miden en bytes o en sus mltiples. 1 K (kilobyte)
= 1024 bytes. 1 Mb (megabyte) = 1024K. 1Gb (Gigabyte) = 1024 Mb.
C. Lenguaje de programacin de alto nivel que posee caractersticas de
los de bajo nivel y esto lo hace adecuado para escribir software de
sistemas.
C++. Lenguaje C orientado a objetos
CADENA. Tipo de estructura de datos que es un conjunto de caracteres
almacenados

consecutivamente.

Tambin

recibe

este

nombre

un

conjunto de programas relacionados lgicamente para realizar una


tarea.
[Estructura de Datos]
Lic. Katya Perez Martinez

Page 104

CARCTER. Dgito, letra o smbolo que puede ser tratado por un


ordenador. Es la unidad elemental de informacin desde el punto de
vista externo.
CODIFICAR. Es la parte de la programacin consistente en escribir en
un lenguaje informtico el algoritmo que resuelve un problema.
CDIGO. Tabla de traduccin entre todos los posibles smbolos de dos
alfabetos. El ms conocido es el cdigo ASCII (American Standard Code
for Information Interchange).
COLA. Estructura de informacin consistente en una lista lineal en la
que la nueva informacin se coloca en un extremo y la salida para
procesar es por el otro extremo. Ejemplos: la cola de trabajos pendientes
de ejecutar o la cola de espera de impresin de resultados.
COMANDO. Mandato ejecutable por el ordenador. Cada una de las
instrucciones que componen el sistema operativo y que el ordenador
puede traducir en acciones especficas.
CONTADOR. Usado en programacin. Variable que contiene el nmero
de acciones realizadas.
COMPILADOR. Programa que traduce un programa escrito en un
lenguaje de alto nivel a lenguaje de mquina. Adems de traducir se
detectan posibles errores de sintaxis.
DIRECCIN. Etiqueta, nombre o nmero que identifica la posicin de un
dato en la memoria o en una unidad de almacenamiento
EDITOR. Programa que permite escribir y corregir ficheros de texto
como documentos o programas.
EJECUTAR. Realizar una instruccin en cdigo mquina o bien hacer
que se realicen las instrucciones de un programa.
ESTRUCTURA DE DATOS. Conjunto de datos en que sus componentes
estn relacionados entre s de una forma particular y sobre los que se
pueden realizar ciertas operaciones segn sea el tipo de relacin que
hay entre ellos.
EXPRESIN. Conjunto de variables, constantes, funciones y smbolos
de operacin que expresan un clculo a realizar. Proporcionan un valor
que ser del tipo (aritmtico, alfanumrico o lgico) de las variables y
constantes que contiene.

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 105

FICHERO. Conjunto organizado de informacin almacenado en un


soporte. Est formado por registros que contienen la informacin de
cada elemento del fichero. Los registros a su vez estn divididos en
campos, siendo cada campo uno de los datos del registro. Por ejemplo
en un fichero de clientes, cada cliente sera un registro y tendramos los
campos: nombre, apellidos, direccin, telfono, etc.
I/O.

Smbolo

de Input/Output.

Entrada/Salida

desde o hacia un

ordenador.
IMPLEMENTAR. Instalar y hacer funcionar
INSTRUCCIN. Se llama instruccin a cada una de las lneas que
componen un programa de ordenador.
Lenguaje de programacin. Conjunto de smbolos e instrucciones que
pueden ser reconocidos y procesados por un ordenador.
LIBRERA.

Conjunto

de

programas

mdulos

almacenados

generalmente sobre un dispositivo magntico.


LISTA. Conjunto de elementos de datos organizados de modo que se
conoce la posicin relativa de cada elemento.
MENU. Es un conjunto de opciones presentado por un programa. La
eleccin se efecta tecleando un cdigo, con los cursores o sealndolo
con algn dispositivo como el ratn o el lpiz ptico.
MDULO. En programacin, cada uno de los bloques lgicos en que se
puede dividir un programa.
PILA. Un tipo de estructura de datos en el que el ltimo dato en llegar
es el primero en salir.
RECURSIVIDAD. Propiedad de algunos lenguajes de programacin de
permitir que un programa solicite su propia ejecucin en el curso de su
desarrollo.
SUBPROGRAMA. Conjunto de instrucciones que efectan una tarea
especfica dentro de un programa y al que es posible referirse.
USUARIO. Es la persona que hace uso de un sistema de ordenadores.
VARIABLE. En programacin es una entidad dedicada a contener
valores que pueden cambiar durante la ejecucin de un programa.
VENTANA. Una parte de la pantalla dedicada a representar un
subconjunto de datos particulares.

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 106

LECTURAS COMPLEMENTARIAS
1. Estructuras de Datos
http://cuhwww.upr.clu.edu/~jse/cursos/4097/notas/
2. versin electrnica y en lnea de uno de los libros sobre estructuras de datos
de mayor inters (Baeza-Yates).
http://www.dcc.uchile.cl/~rbaeza/handbook/hbook.html
3. Algorithms and Data Structures Research & Reference Material". Muchas
implementaciones, algoritmos y material de referencia
http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/index.html
4. Estructuras arbreas
http://www.infor.uva.es/~jmrr/TAD2003/home.htm
5. MANUAL DE C++
http://kataix.umag.cl/~mmarin/topinf/cs23/c++/pagina022a.htm
6. Recursividad
http://www.conclase.net/c/curso/index.php?cap=024
http://decsai.ugr.es/~lcv/Docencia/mp2/apuntes/tema3.pdf.

7. Tutorial de estructuras de datos en C++ interactivo


http://decsai.ugr.es/~jfv/ed1/c++/cdrom5/index.htm

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 107

8. MetodologadelaProgramacionII

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 108