Katia Perez Programacion en Java

UNIVERSIDAD SALESIANA
DE BOLIVIA
CARRERA INGENIERIA DE SISTEMAS
DOSSIER
PROGRAMACION II
Tercer Semestre
Lic. Katya Maricela Pérez Martínez

Lic. Gladys Francisca Chuquimia Mamani
Lic. Carmen Rosa Mollinedo Laura
INDICE
1. CAPÍTULO I...........................................................................................1
INTRODUCCIÓN A LAS ESTRUCTURAS DE DATOS...........................................1
1.1. INTRODUCCIÓN................................................................................................ 1
1.2. ESTRUCTURAS FUNDAMENTALES.....................................................................1
1.3. ABSTRACCIÓN.................................................................................................. 2
1.4. DEFINICIÓN DE ESTRUCTURAS DE DATOS........................................................2
1.5. T.D.A. (TIPO DE DATO ABSTRACTO)..................................................................3
1.6. CLASIFICACIÓN DE LAS ESTRUCTURAS DE DATOS...........................................3
1.6.1. ESTRUCTURAS DE DATOS ESTÁTICAS...........................................................4
1.6.2. ESTRUCTURAS DE DATOS DINÁMICAS..........................................................4
1.6.3. ESTRUCTURAS DE DATOS LINEALES.............................................................4
1.6.4. ESTRUCTURAS DE DATOS NO LINEALES.......................................................4
1.7. ESTRUCTURAS DE DATOS ESTÁTICAS...............................................................4
1.7.1. ARREGLOS................................................................................................... 4
1.7.2. ARREGLOS UNIDIMENSIONALES (VECTORES)...............................................5
1.7.3. Declaración 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
 DECLARACIÓN DE UNA MATRÍZ..................................................................................19
 OPERACIONES CON ARREGLOS BIDIMENSIONALES...........................................................20
1.9. REGISTROS (ESTRUCTURAS)..........................................................................21
1.9.1. DEFINICIÓN DE REGISTRO Y DECLARACIÓN 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. DEFINICIÓN DE CONJUNTOS...................................................................26
1.11. MATRICES POCO DENSAS...............................................................................27
1.12. ARCHIVOS...................................................................................................... 30
2. CAPÍTULO II........................................................................................35
PILAS....................................................................................................... 35
2.1. INTRODUCCIÓN.............................................................................................. 35
2.2. REPRESENTACIÓN DE LAS PILAS....................................................................36
2.3. ESTRUCTURA DE UNA PILA UTILIZANDO ARREGLOS.......................................37
2.4. OPERACIONES CON PILAS..............................................................................38
2.5. IMPLEMENTACIÓN DEL TAD PILA EN LENGUAJE JAVA.......................................38
2.6. APLICACIONES................................................................................................ 42
2.6.1. LLAMADAS A SUBPROGRAMAS...................................................................43
........................................................................................................................ 44
2.6.2. RECURSIÓN................................................................................................44
2.6.3. TRATAMIENTO DE EXPRESIONES ARITMÉTICAS..........................................44
3. CAPÍTULO III COLAS.........................................................................47
3.1. INTRODUCCIÓN.............................................................................................. 47
[Estructura de Datos] Page 2

Lic. Katya Perez Martinez
3.2. CARACTERÍSTICAS.......................................................................................... 48
3.3. REPRESENTACIÓN 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. COLAS CIRCULARES.......................................................................................53
3.7. OPERACIONES CON COLAS CIRCULARES..................................................................54
3.8. EJERCICIOS CON COLAS CIRCULARES.............................................................56
3.9. COLAS DE PRIORIDADES................................................................................57
3.10. APLICACIÓN DE PILAS Y COLAS......................................................................58
4. CAPÍTULO RECURSIVIDAD....................................................................60
4.1. INTRODUCCIÓN.............................................................................................. 60
4.2. AMBITO DE APLICACIÓN:................................................................................60
4.3. RAZONES DE USO:......................................................................................... 60
4.4. ¿EN QUÉ CONSISTE LA RECURSIVIDAD?.........................................................61
4.5. FORMA DE ENFRENTAR PROBLEMAS RECURSIVOS.........................................61
4.6. TIPOS DE RECURSIVIDAD...............................................................................63
4.7. LA PILA DE RECURSION..................................................................................64
4.8. LA LLAMADA A UNA FUNCIÓN........................................................................65
5. CAPITULO IV LISTAS ENLAZADAS.........................................................67
5.1. INTRODUCCIÓN A LAS ESTRUCTURAS DE DATOS DINÁMICA..........................67
5.2. MECANISMOS PARA ENLAZAR INFORMACIÓN.................................................68
5.3. LISTAS ENLAZADAS........................................................................................68
5.4. TIPO DE DATO ABSTRACTO NODO..................................................................70
5.5. CONSTRUCCIÓN DE UN TAD LISTA ENLAZADA LINEAL SIMPLE.......................70
5.6. OPERACIONES BÁSICAS SOBRE LISTAS ENLAZADAS.......................................71
Creación de una lista vacía...................................................................................71
a) Inserción al Final de la lista............................................................................71
b) Inserción 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. IPLEMENTACIÓN 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. DEFINICIÓN ÁRBOL......................................................................................... 84
6.2. CONCEPTOS BÁSICOS....................................................................................84
6.3. CARACTERÍSTICAS DE LOS ARBOLES BINARIOS..............................................86
6.4. TRANSFORMACIÓN DE UN ARBOL GRAL. EN UN ARBOL BINARIO...................87
6.5. REPRESENTACIÓN DE UN ÁRBOL EN MEMORIA..............................................87
6.6. CLASIFICACIÓN DE ARBOLES BINARIOS..........................................................88
A. B. DISTINTO....................................................................................................... 89
A. B. SIMILARES..................................................................................................... 89
A. B. EQUIVALENTES..............................................................................................89
A. B. COMPLETOS.................................................................................................. 89
6.7. RECORRIDO DE UN ARBOL BINARIO...............................................................90
6.8. ARBOLES ENHEBRADOS.................................................................................91
6.9. ARBOLES BINARIOS DE BÚSQUEDA................................................................91

6.10. GRAFOS.......................................................................................................... 92
6.11. DEFINICIONES BÁSICAS..................................................................................92
6.12. REPRESENTACIÓN EN MEMORIA SECUENCIAL................................................94
6.13. REPRESENTACIÓN EN MEMORIA ENLAZADA...................................................94
6.14. OPERACIONES SOBRE GRAFOS.......................................................................96
6.15. CAMINO MÍNIMO............................................................................................. 98

1. Capítulo I Introducción a las Estructuras De Datos
“Escribir en C o C++ es como utilizar un sierra eléctrica sin ningún tipo de protección.”
“Escribir en C o C++ es como utilizar un sierra eléctrica sin ningún tipo de protección.”
— Bob Gray
— Bob Gray
1.1. INTRODUCCIÓN
Para procesar información en un computador es necesario hacer una

abstracción de los datos que tomamos del mundo real, abstracción en el
sentido de que se ignoran algunas propiedades de los objetos reales, es
decir, se simplifican. Se hace una selección de los datos más
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 números enteros, caracteres, números reales. En realidad
suministra un subconjunto de éstos, pues la memoria del ordenador es
finita. Los punteros (si los tiene) son también un tipo de datos. El
tamaño de todos los tipos de datos depende de la máquina 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 sólo 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 a 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  Identificador
int A;
25
A = 25;
Dato Estructurado
Declaramos un dato compuesto o estructurado A que tendrá 5 elementos de

tipo entero.
int A[5] ; 20 30 40 50 60
A = {20,30,40,50,60}; A =
Identificador
1.3. ABSTRACCIÓN
Una abstracción es un proceso mental donde se extraen rasgos

esenciales de algo para representarlos por medio de un lenguaje gráfico
o escrito.
1.4. DEFINICIÓN DE ESTRUCTURAS DE DATOS

Una estructura de datos es cualquier colección 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 diseñar una estructura de datos con la técnica de abstracción pasa a

ser un TDA, que:
 Puede implementarse en cualquier lenguaje

 Puede aplicarse en cualquier concepto
Ejemplo: Abstraemos el concepto Estudiante
Nombre del TAD ESTUDIANTE
Ru: entero
Elementos Nombre: Cadena
Sexo: carácter
Direccion: Cadena
LeerDatosEstudiante ()
ImprimirDatosEstudian
Operaciones te ()
o métodos ModificarDireccion()
CalcularNotaFinal()
Como se puede notar existe una operación 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
operación.
Recuerda en todo momento que sólo deben incluirse las

operaciones que puedan trabajar con los elementos que
contiene el TAD.
1.6. CLASIFICACIÓN DE LAS ESTRUCTURAS DE DATOS
Las estructuras de datos desde el punto de vista de asignación de

memoria, se clasifican en:
 Estructuras de datos estáticas

 Estructuras de datos dinámicas
También pueden ser clasificadas en:

 Estructuras Lineales
 Estructuras No Lineales
1.6.1. ESTRUCTURAS DE DATOS ESTÁTICAS
Son aquellas en las que el tamaño ocupado en memoria se define antes

de que el programa se ejecute y no puede modificarse dicho tamaño
durante la ejecución del programa. Por ejemplo tenemos a los Arreglos,
Registros y Conjuntos.
1.6.2. ESTRUCTURAS DE DATOS DINÁMICAS
Las estructuras dinámicas de datos son estructuras que cuya dimensión

puede crecer o disminuir durante la ejecución 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 relación de predecesor y sucesor. Los
diferentes TADs basados en este concepto se diferenciaran por las
operaciones de acceso a los elementos y manipulación de la estructura.
Desde el punto de vista de la informática, 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 ESTÁTICAS

1.7.1. ARREGLOS

Definición: Colección finita, homogénea y ordenada de elementos.
Finita: Porque todo arreglo tiene un límite. Homogénea: Porque todos los
elementos son del mismo tipo. Ordenada: Porque se puede determinar
cuál es el enésimo elemento.
Un arreglo tiene dos partes: Componentes e índices
Componentes
C1 C2 … Cn
i0 i1 … 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 más simples y constan de un solo índice, también se

llaman vectores.
Notación: Podría ser de diferentes maneras. Por ejemplo:

Array [0...9] de enteros: Vector
Vector: C
elemento
C= 30 50 70 60
0 1 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. Declaración 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:

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:
public static void main (String arg []) Array.java
{
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 máximo de 10 elementos enteros.
Implementación del TAD Vector
Este es el diseño del TAD vector que maneja números enteros.
VECTOR
V[15]: Entero
N: Entero
Lic. Katya Perez Martinez leedim()
leervector()
mostrarvector()
Ejercicios
A continuación se muestra la implementación 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 ();
[Estructura de Datos]
leervector(); Page 7
mostrarvector();
}
}
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 continuación:
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
6 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 número de alumnos que

ingresaron en sus 5 diferentes carreras (Ingeniería de
Sistemas, Psicomotricidad, Derecho, Contaduría Pública y
Educación), en los últimos 4 años. Diseñe un TAD y luego
implementarlo para que suministre la siguiente información:
a. Total de alumnos por año
b. Porcentaje de alumnos ingresados en el año X de la carrera Y
c. Año en el cual la carrera Y tuvo el mayor ingreso de
alumnos.
4. Diseñe el TAD necesario para formar una matriz de orden

NxM y la llene de datos enteros, (toda esta información la
proporciona el usuario), a continuación 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 año 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 información se almacena en un
arreglo como se muestra en el siguiente ejemplo.
Naranjas
Naranjas
para comer
para jugo

A= 10 50 60 0 80 30 … 50 35
0 0 0 0 0 0 0
1 2 3 4 5 6 … n
Parcela 1 Parcela 2 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 información de una misma parcela

ocupa posiciones consecutivas en el arreglo.
Se pide:
a. Leer la información y las toneladas por tipo de naranja de cada

una de las parcelas
b. Calcular e imprimir el total de la producción por parcela
c. Imprimir las parcelas que tuvieron una producción 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 Se repite
o
4 3
2 1
7 2
1.7.4. Cadenas de Caracteres

Los arreglos de caracteres tienen varias características únicas.
Un arreglo de caracteres puede inicializarse de la siguiente forma:
char CADENA1[ ] = "rosa";

 El tamaño de CADENA1 está determinado por el compilador, y
generalmente es de 256 caracteres máximo.
 La cadena "rosa" contiene cuatro caracteres, más un caracter
especial de terminación denominado caracter nulo (' \0 ').
 Los arreglos de caracteres pueden inicializarse también con
constantes individuales dentro de una lista.
char CADENA1[ ]= {' r ', ' o ', ' s ', ' a ', ' \0 ' };
 También 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 número de posición que
inicia en CERO y termina en n-1, donde n es la longitud de la
cadena.
• Los siguientes son algunos de los métodos más 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 mayúsculas, false de otra
manera.

• cadena1.compareTo(cadena2) regresa un valor entero 0 si son
iguales, un valor menor que 0 si cadena1 es menor
lexicográficamente que cadena2 y un valor mayor que 0 si
cadena1 es mayor lexicográficamente 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 minúsculas.
• cadena1.toUpperCase(); regresa otra cadena convirtiendo
todas las letras a mayúsculas.
• cadena1.trim(); regresa otra cadena sin espacios en blanco,
caracteres de nueva línea 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 carácter de la cadena.
• cadena1.indexOf(subcadena,indiceInicial); regresa un entero
que indica la posición 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
representación String del arreglo de caracteres. Esta conversión

también 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.
•
CONVERSIÓN DE TIPOS PRIMITIVOS NUMÉRICOS 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
numérico entero correspondiente al valor representado en la
cadena.
Double.parseDouble(“cadenaNumerica”); regresa el valor
numérico doble correspondiente al valor representado en la
cadena.
De manera semejante se convierten los otros tipos primitivos de cadena

a valores numéricos.
Integer.parseInt(“cadenaNumerica”, base); regresa el valor

entero de la cadena representado en la base numérica 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
1. Contar el numero de palabras que hay en una cadena, las
palabras están separadas por un espacio en blanco.
Diseñamos el TAD 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
}
}

2. Escribir un programa para reemplazar todas las
ocurrencias de un carácter c en la cadena cad por un
asterisco. El resultado queda en otra cadena. No usar la
función replace.
Diseñamos 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

{
{
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
}
}
3. programa que pretende suprimir todos los espacios en
blanco de una cadena cad. El resultado queda en otra
cadena.
Diseñamos 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
{
{
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;
}
}

Katya Perez Martinez
Lic.
4. Programa que sirve para contar cuántas vocales tiene una
palabra o frase.
Diseñamos el TAD
Guia34
Contar()
main()
// Programa que sirve para contar cuántas vocales tiene una palabra o
frase.
class Guia34
{
{
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 aplicación para generar un código a partir del

nombre, paterno, materno, dia, mes y anio de los datos del
usuario. Guia35
Nombre: cadena
Paterno: cadena
Materno:cadena
dia: entero
[Estructura de Datos] mes: entero Page 17
Lic. Katya Perez Martinez anio:entero
Generar(): cadena
main()
Diseñamos 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;
}

{
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...");
mes = Lectura.Entero ();
Page 18
}
while (mes > 13 || mes < 1);
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);
}
}
1. Crear una clase donde dado un string que representa un nombre

en mayúsculas o minúsculas devolver un string formado por las
iniciales en mayúsculas 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 parámetro el nombre de una

persona, con el apellido seguido de una coma, un espacio y
después el nombre de pila. El procedimiento debe imprimir el
nombre de pila de la persona seguido de su apellido.
1.8. ARREGLOS MULTIDIMENSIONALES

Existe en la mayoría de los lenguajes una estructura de arreglos
multidimensionales. El número 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 posición como renglón y columna). Aunque no se
justificará aquí, es conveniente mencionar que la representación
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 analizarán 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 renglón 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

declaración. 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.
 Declaración de una Matríz
La sintaxis en el lenguaje C++ es el siguiente:
tipo nombre_de_variable [rango1][rango2];

donde:
 tipo puede ser cualquier tipo de dato (int, float, char, etc.).
 nombre_de_variable es el nombre del arreglo.
 rango 1 corresponde al número de renglones que conforman el
arreglo.
 rango 2 corresponde al número 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
 Asignación
 Actualización:
//programa para manejo Inserción
de matrices de numeros enteros.
import java.io.*;
class matriz
 Eliminación
{  Modificación
static int M[] [] = new int [20] [20];
 static
Ordenación
int f, c;
 static
Búsqueda
void leerMatriz ()
{
En general los arreglos bidimensionales son una generalización de los
System.out.println ("******REGISTRO DE MATRIZ ******");
unidimensionales, por lo que
System.out.print se realizará
("Ingrese un ejemplo
el numero de filascon
de algunas de
la matriz......");
f = Leer.Entero ();
estas operaciones a continuación.
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++)
[Estructura de { Datos] Page 21
Lic. Katya Perez Martinez System.out.print (M [i] [j] + " ");
}
}
}
{
leerMatriz ();
imprimir ();
}
}
1.9. REGISTROS (ESTRUCTURAS)
Cuando se habló de los arreglos se mencionó que se trataba de una

colección de datos, todos del mismo tipo, que era un tipo estructurado
de datos, y que son ellos se podía solucionar un gran número de
problemas. Sin embargo, en la práctica a veces se necesitan estructuras
que permitan almacenar distintos tipos de datos (característica con la
cual no cuentan los arreglos).
Ejemplo
Una compañía tiene por cada empleado los siguientes datos:

 Nombre (cadena de caracteres)
 Dirección (cadena de caracteres)
 Edad (entero)
 Sexo (carácter)
 Antigüedad (entero)
Si lo vemos gráficamente estos datos tenemos;
Nombre Direccion
Nom Pat Mat Calle Nro Zona Edad Sexo Antig
Juan Rodrígu Salas Av. Arce 123 Centr 25 M 2
Maria ez Varga Calle 12 134 al 29 F 3
Alvarez s 5 Obraj
es
Si se quisiera almacenar estos datos no sería posible usar un arreglo, ya

que sus componentes deben ser todos del mismo tipo.
1.9.1.DEFINICIÓN DE REGISTRO Y DECLARACIÓN 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 también podrán 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 mayoría de los lenguajes se sigue la siguiente sintaxis:
Variable_registro.campo
Ejemplo:

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;
[Estructura elsede Datos] Page 24
return false;
}
}
A continuación 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 combinación de las estructuras con los arrays proporciona una

potente herramienta para el almacenamiento y manipulación de datos.
1.9.4. ESTRUCTURAS ANIDADAS:
También está permitido anidar estructuras, con lo cual se pueden

conseguir superestructuras muy elaboradas.

En general, no es una práctica 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 más 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
empleado.java,
static empleadopara
e[] =implementar ahora mediante un arreglo que
new empleado [10];
static int n;
almacena a NLeerEmpleados
static int empleados. El(empleado
programa es elint
ve[], siguiente
n) regemp.java.
{
System.out.print ("Cuantos empleados desea registrar...");
n = Lectura.Entero ();
for (int i = 1 ; i <= n ; i++)

{
System.out.println ("EMPLEADO : " + i);
ve [i] = new empleado ();
ve [i].leeDatos ();
}
return n;
}
static void ImprimirEmpleados (empleado ve[], int n)

{
System.out.println (".....IMPRIMIENDO DATOS DE LOS EMPLEADOS....");
for (int i = 1 ; i <= n ; i++)
{
System.out.println ("EMPLEADO: " + i);
ve [i].ImprimeDatos ();
}
}
static void ListaConSueldoMenorX (empleado ve[], int n)

{
float sx;
System.out.println (".....EMPLEADOS CON SUELDOS MENOR A X....");
System.out.println ("Menores a cual sueldo desea listar...");

sx = Lectura.Real ();
for (int i = 1 ; i <= n ; i++)

{
System.out.println ("EMPLEADO: " + i);
if (ve [i].VerificaSueldo (sx) == true)
ve [i].ImprimeDatos ();
}
}
{
n = LeerEmpleados (e, n);

ImprimirEmpleados (e, n);
ListaConSueldoMenorX (e,n);
}
}
1.10. CONJUNTOS
El conjunto es también un tipo de dato estructurado. Puede definirse un

conjunto como una colección de objetos del mismo tipo base. El tipo
base puede ser solamente un tipo ordinal (enteros, caracteres,
enumerados y subrangos).
1.10.1. DEFINICIÓN DE CONJUNTOS
Los conjuntos serán definidos de la siguiente manera:

Ident_conjunto = CONJUNTO DE tipo_base
Donde:
Tipo_base es cualquier tipo ordinal de dato.
Ejemplo:
Se definen los conjuntos NUMEROS, MAYUSCULAS y ALUMNOS.
NUMEROS es el tipo conjunto formado por todos los números enteros
comprendidos entre el 1 y el 50 inclusive. MAYUSCULAS es el tipo
conjunto formado por las letras mayúsculas, 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 término matemático utilizado para definir un conjunto de

elementos organizados por medio de renglones y columnas, equivalente
al término arreglo bidimensional utilizado en computación.
Poco Densa indica una proporción muy alta de ceros entre los
elementos de la matríz. 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 A= 1 1 0
0 0 1 0
0 1 0 0
0 1 0 0
Existen diversos métodos para almacenar los valores diferentes de cero
de una matríz poco densa. A continuación presentamos uno de ellos.

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;
} 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....");
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++)

{
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] else Page 30
Lic. Katya Perez Martinez System.out.print (" 0 ");
}
}
}
{
MatrizPocoDensa A[] = new MatrizPocoDensa [20];
A = LeerMatrizPocoDensa ();
ImprimirMatrizPocoDensa (A);
}
}
1.12. ARCHIVOS
Ejercicios Propuestos
ARREGLOS DE UNA DIMENSIÓN
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, . . . . .)

2. Escriba un programa que almacene en un vector los N primeros
números 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
números de Fibonacci. Una vez calculados, el programa pedirá al
usuario que introduzca un número y dirá si es o no es uno de los N
primeros números de Fibonacci.
4. Modifica el programa del ejercicio anterior para que muestre,
además, cuántas edades hay entre 0 y 9 años, 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á (además de la media, desviación estándar,
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: *

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 - 19: *****
20 - 29: ****
30 - 39: *
40 - 49:
50 - 59: *
60 - 69:
70 - 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 Diseñe un programa que pida el valor de N números enteros

distintos y los almacene en un vector. Si se da el caso, el programa
advertirá al usuario, tan pronto sea posible, si introduce un
número repetido y solicitará nuevamente el número hasta que sea
diferente de todos los anteriores. A continuación, el programa
mostrará los N números por pantalla
8 Diseñe un programa que lea y almacene en un vector N números

enteros asegurándose de que sean positivos. A continuación, el
programa pedirá que se introduzca una serie de números enteros
y nos dirá si cada uno de ellos está o no en el vector. El programa
finaliza cuando el usuario introduce un número negativo. Luego
ordenar el vector, por el método de la burbuja.
9 En un arreglo se ha almacenado el número total de toneladas de

cereales cosechadas durante cada mes del año anterior. Se desea
la siguiente información:
i. El promedio anual de toneladas cosechadas

ii. ¿Cuántos meses tuvieron una cosecha superior al
promedio anual?
iii. ¿Cuántos meses tuvieron una cosecha inferior al
promedio anual?Escriba un programa que proporcione
estos datos.
ARREGLOS MULTIDIMENSIONALES
20. Escriba un programa que intercambie por renglón los

elementos de un arreglo bidimensional. Los elementos del renglón
1 deben intercambiarse con los del renglón N, los del renglón 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) si i <= j
v. Aij = 0 si i >j

22. Diseñe el TAD necesario para formar una matriz de orden
NxM y la llene de datos enteros, (toda esta información la
proporciona el usuario), a continuación 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 posición
23. Una agencia automotriz distribuye 6 modelos diferentes de

coches y tiene 5 vendedores. Se desea un programa que escriba
un informe mensual del número de automóviles vendidos por cada
vendedor y por modelo y el número total de cada modelo vendido
por cada uno de los vendedores. Asimismo, para entregar el
premio al mejor vendedor, necesita saber cuál es el vendedor que
más coches ha vendido.
Vendedores
Modelos Juan Pedro Maria Rosa Luis Rosa
M1 4 0 2 1 5 vendió 2
M2 2 3 1 1 2 autos del
M3 0 3 0 2 1 modelo
M4 3 5 7 3 1 M3
M5 4 1 2 2 0
M6 0 0 3 2 5
24. La Tabla contiene gastos que registra una ama de casa

correspondiente a los 12 meses del año anterior.
Meses/Gas Agua Luz Telefon Mercad

tos o o
Enero 23 57 840 250
Febrero 28 60 560 280
Marzo 34 55 400 275
Abril 24 87 700 340
Mayo 29 80 450 310
Junio 34 65 670 320
Julio 45 67 560 325
Agosto 48 78 570 323
Septiembre 32 54 540 290

Octubre 33 50 250 300
Noviembre 35 70 330 350
Diciembre 38 62 300 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 compañía distribuye N productos a distintos comercios

de la ciudad. Para ellos almacena en un arreglo toda la
información relacionada con su mercancía:
 Clave
 Descripción
 Existencia
 Mínimo 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 mínimo. (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. Capítulo II
Pilas

“SiJava
Javadispusiera
dispusierade
deun
unmecanismo
mecanismoreal
realde
derecolección
recoleccióndedebasura, la
basura, lamayoría
mayoría
“Si
de los programas deberían autoeliminarse al ser ejecutados.”
de los programas deberían autoeliminarse al ser ejecutados.”
— Robert Sewell
— Robert Sewell
2.1. INTRODUCCIÓN
La pila es una lista de elementos caracterizada porque las operaciones de inserción y

eliminación 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 más inaccesible de la pila,
está en el fondo de la pila (bottom) y que k, por el contrario, el más accesible, está en el
Tope.
Las restricciones definidas para la pila implican que si una serie de elementos A, B, C, D,
E se añaden, 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 razón, 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 típico de pila lo constituye un montón de platos, cuando se quiere introducir un

nuevo plato, éste se pone en la posición más accesible, encima del último plato. Cuando
se coge un nuevo plato, éste se extrae, igualmente, del punto más accesible, el último que
se ha introducido. Ejemplos: Una pila de papeles, una pirámide humana
Otro ejemplo natural de la aplicación de la estructura pila aparece

durante la ejecución de un programa de ordenador, en la forma en que
la máquina procesa las llamadas a los procedimientos. Cada llamada a
un procedimiento (o función) hace que el sistema almacene toda la

información asociada con ese procedimiento (parámetros, variables,
constantes, dirección 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 información almacenada
pueda ser recuperada convenientemente cuando corresponda.
Como en un procesador sólo se puede estar ejecutando un

procedimiento, esto quiere decir que sólo 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 manipulación, éstas
son:
a. Crear la pila.
b. Comprobar si la pila está vacía. Es necesaria para saber si es
posible eliminar elementos.
c. Acceder al elemento situado en la cima.
d. Añadir elementos a la cima.
e. Eliminar elementos de la cima.
La especificación correcta de todas estas operaciones permitirá definir
adecuadamente una pila.
2.2. REPRESENTACIÓN DE LAS PILAS
Las pilas no son estructuras fundamentales de datos, es decir, no están

definidas como tales en los lenguajes de programación (como lo están
por ejemplo los arreglos). Las pilas pueden representarse mediante el
uso de:
 Arreglos
 Listas Enlazadas
Aquí se utilizarán arreglos. En consecuencia deberá definirse cuál será el
tamaño máximo de la pila, y además una variable auxiliar a la que se

denominará TOPE, que será un apuntador al último elemento insertado
en la pila.
En la figura siguiente se presentan dos alternativas de representación de

una pila, utilizando arreglos.
MAX
PILA =
TOPE 4 1555 2434 3222 44444 … MAX
TOPE 3 TOPE
2
1
PILA
2.3. ESTRUCTURA DE UNA PILA UTILIZANDO

444
ARREGLOS
222
Nombre del TAD 434 PILA

elementos 555
V[MAX]:
tipo_dato
Tope: entero
operaciones Poner(e)
Quitar()
Imprimir()
Vacia()
Donde los elementos son:
V[MAX]:es el vector que representa a la pila y es de tamaño de la pila.
Tope: es la varible que indica la posición del ultimo elemento de la pila.
Y las operaciones como se describen a continuación.
2.4. OPERACIONES CON PILAS

La definición 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)
{
 Vacia() verifica
if (llena ()) si la pila esta vacia, si es asi, reotrna el valor
System.out.println ("PILA LLENA...");
verdad,
else caso contrario falso.
{
tope++;
 Imprime() Permite
v [tope] imprimir todos los elementos de la pila
= elem;
desde
} el tope hasta el fondo de la pila.
}
2.5. IMPLEMENTACIÓN
int quitar () DEL TAD PILA EN LENGUAJE
{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
return (false);
for (int i = 1 ; i <= n ; i++)
}
{
System.out.print ("elemento?...... ");
[Estructura dee Datos] = Lectura.Entero (); Page 40
poner (e);
}
}
}
Ejercicios con pilas

a. Sumar dos pilas del mismo tamaño.
//sumar dos pilas del mismo tamaño
class EjPila1
{
static Pila P1 = 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
publicPila P = void
static new Pila
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
b. Eliminar void
elementos main (String
negativos args[])
de una pila.
{
P.llenarPila ();
[Estructura de P.imprimir
Datos] (); Page 42
EliminaNegativos
Lic. Katya Perez Martinez (P);
P.imprimir ();
}
}
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 5 B = 1 23 11
2 344 433 5
TOPE TOPE
C= 89 33 77 44 4 11 3 23
1 2 3 4 5 6 7 8

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 ();
}

{
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 solución de diversos tipos de
problemas. Ahora se verán algunos de los casos más representativos de aplicación de
pilas:
 Llamadas a subprogramas
 Recursión
 Tratamiento de expresiones aritméticas
 Ordenación
2.6.1. LLAMADAS A SUBPROGRAMAS

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 ejecución del subprograma, los valores almacenados
en la pila pueden recuperarse para continuar con la ejecución del programa en el punto
en el cual fue interrumpido. Además de las variables debe guardarse la dirección del
programa en la que se hizo la llamada, porque es a esa posición 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
ejecución 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 posición en la que se

hizo la llamada. Al terminar UNO, el control se regresa a PP recuperando previamente
la dirección de la pila. Al llamar a DOS, nuevamente se guarda la dirección de PP en la
pila. Cuando DOS llama a TRES, se pone en la pila la dirección de DOS. Después de
procesar TRES, se recupera la posición de DOS para continuar con su ejecución. Al
terminar DOS se regresa el control a PP, obteniendo previamente la dirección guardada
en la pila.
…
UNO
….
DOS
….
… PP …
….
… TRES
…. ….
….
…
UNO DOS ….
….
TRES

5 5 5
4 4 4
3 3 3
2 2 2
TOPE TOPE
1 PP TOPE 1 1 PP
0
5 5 5
4 4 4
3 3 3
2 DOS 2 2
TOPE 1 PP TOPE 1 PP 1 PP
TOPE 0
Finalmente podemos concluir que las pilas son necesarias en esta área
de aplicaciones por lo siguiente:
 Permiten guardar la dirección del programa (subprograma) desde

donde se hizo la llamada a otros subprogramas, para poder
regresar y seguir ejecutándolo a partir de la instrucción inmediata
a la llamada.
 Permiten guardar el estado de las variables en el momento que se
hace la llamada, para poder seguir ocupándolas al regresar del
subprograma.
2.6.2. RECURSIÓN
Se Tratará en el tema 5 el tema de recursión. Se dejará para entonces la

aplicación de pilas en procesos recursivos.
2.6.3. TRATAMIENTO DE EXPRESIONES ARITMÉTICAS
Un problema interesante en computación es poder convertir expresiones

en notación infija a su equivalente en notación postfija.(o prefija).
Revisaremos algunos conceptos:

 Dada la expresión A+B se dice que está en notación infija, y su
nombre se debe a que el operador (+) está entre los operandos ( A
y B).
 Dada la expresión AB+ se dice que está en notación postfija, y su
nombre se debe a que el operador (+) está después de los
operandos (A y B).
 Dada la expresión +AB se dice que está en notación prefija, y su
nombre se debe a que el operador (+) está antes que los
operando (A y B).
 La ventaja de usar expresiones en notación polaca postfija o
prefija radica en que no son necesarios los paréntesis para indicar
orden de operación, ya que éste queda establecido por la
ubicación de los operadores con respecto a los operandos.
 Para convertir una expresión dada en notación infija a una
notación postfija (o prefija) deberán establecerse previamente
ciertas condiciones:
 Solamente se manejarán los siguientes operadores (están dados
ordenadamente de mayor a menor según su prioridad de
ejecución):
^ (potencia)
*/ (multiplicación y división)
+- (suma y resta)
 Los operadores de más alta prioridad se ejecutan primero.
 Si hubiera en una expresión dos o más operadores de igual
prioridad, entonces se procesarán de izquierda a derecha.
 La subexpresiones patentizadas tendrán más prioridad que
cualquier operador.
 Presentaremos, paso a paso, algunos ejemplos de conversión de
expresiones infijas a notación polaca postfija.
EJEMPLO

En este ejemplo se presentan dos casos de traducción de notación infija
a postfija. El primero de ellos es una expresión simple, mientras que el
segundo presenta un mayor grado de complejidad.
a) expresión infija: X+Z*W

X + [ZW*]
Expresión postfija XZW*+
b) transformamos a notación prefija la misma expresión anterior

X+Z*W
X + [* Z W]
Notación prefija + X*ZW
1. Traduzca las siguietes expresiones a notación postfija utilizando el algoritmo de
evaluación.
1.1. X*(Z+W)/(T-V)
1.2. Z-W*Y+XˆK
1.3. W*(Z/(K-T))
2. Realizar un programa para hallar el mayor elemento de una pila P.
3. Realizar un procedimiento para intercambiar el último elemento de la pila por el
primer elemento.
4. Escriba un programa que elimine los elementos repetidos de una pila. Los elementos
repetidos ocupan posiciones sucesivas.
5. Escriba un subprograma que invierta los elementos de una pila.
6. Insertar n elementos después al fondo de una pila que ya tiene datos.
7. Eliminar los elementos divisores de X de la pila
8. Intercambiar cada elemento de la pila con su adyacente.
9. Eliminar el primer elemento par de la pila
10. Hallar la frecuencia de repetición de cada elemento de la pila
11. Apilar los elementos de la pila B sobre la pila A.
12. 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
13. Escriba un programa que lea una expresión en notación infija, y la traduzca anotación
postfija.

3. Capítulo III Colas
ElElcamino
caminodel
delTigre
Tigre
Un hombre caminaba por el bosque cuando vió una zorra lisiada. "¿Cómo hará para alimentarse?", pensó.
Un hombre caminaba por el bosque cuando vió una zorra lisiada. "¿Cómo 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 había
Ensobrado.
ese momento, se ayuda
"Si Dios acercóaun
la tigre,
zorra,con un animal
también me vaentre los dientes.
a ayudar", Sació su apetito, y le dejó a la zorra lo que había
reflexionó.
sobrado. "Si Dios ayuda a la zorra, también 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ó
ya se aestaba
su casa, se encerró
quedando en ella, débil
demasiado y se quedó esperando
para salir que los
a trabajar, se Cielos le proveyeran
le apareció un ángel. de alimento. Nada pasó. Cuando
ya se estaba quedando demasiado débil 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.
- ¡Levántate, toma tus herramientas, y sigue el camino del tigre! de Paulo Coelho
- ¡Levántate, toma tus herramientas, y sigue el camino del tigre! de Paulo Coelho
3.1. INTRODUCCIÓN
La estructura de datos "cola" también 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 característica, las colas
también reciben el nombre de estructuras FIFO (First In, First Out:
Primero en entrar, primero en salir).
Las colas en computación son muy similares a las colas de la vida real.
Ejemplos:

a. cola de clientes esperando pagar en una caja de supermercado
b. cola de clientes esperando ser atendidos por algún 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 dinámica, pero
puede ser representado en forma estática (arreglos).
3.2. CARACTERÍSTICAS
 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 están ordenados por su valor sino por orden de
introducción en la cola.
 Existen dos extremos en la estructura lineal cola, el frente y el
final de la cola.
 Sólo se puede acceder y eliminar al dato que está en el frente de
la cola.
 Sólo se puede añadir información al final de la cola.
3.3. REPRESENTACIÓN DE LAS COLAS
Al igual que las pilas, las colas no existen como estructuras de datos
estándares en los lenguajes de programación. Las colas pueden
representarse mediante el uso de:
Arreglos
Listas Enlazadas.
Como en el caso de las pilas, utilizaremos arreglos. Debe definirse el

tamaño máximo para la cola y dos variables auxiliares. Una de ellas para
que guarde la posición del primer elemento de la cola (FRENTE) y otra
para que guarde la posición del último elemento de la cola (FINAL). En el
ejemplo siguiente se muestra una representación de una cola en la cual
se ha insertado cuatro elementos: 11, 22, 33 y 44, en ese orden.

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 números enteros:
Q=
11 22 33 44
1 2 3 4 5 6
Frente Final
3.4. ESTRUCTURA DE UNA COLA IMPLEMENTADO

MEDIANTE ARREGLOS
A continuación diseñamos 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 tamaño MAX.
Frente: es la variable que indica la posición del elemento del frente de

la cola.
Fin: es la variable que indica la posición del último elemento de la cola.
Y las operaciones, como se describen a continuación.

3.5. OPERACIONES CON COLAS
Análogamente a las pilas, es necesario definir el conjunto de

operaciones básicas para especificar adecuadamente una estructura
cola. Estas operaciones serían:
 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 vacía, 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 implementación estática 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
Eliminar DE NUMEROS
un elemento deENTEROS
la cola:Y SUS OPERACIONES
class Cola
{
Comofinal
veraint
la MAX
eliminación
= 20; no borra nada 'físicamente', sólo se encarga
de actualizar el puntero 'frente' en una posición y devolver el valor x
private int v[] = new int [MAX];
como private
mucho,intaunque
fin; esto último no sea estrictamente necesario.
private int frente;
Aunque esa posición aun contenga datos será considerada como vacía a
efectos del()otro puntero 'fin'.
Cola
{
frente = 0;
fin = 0; COLAS LINEALES
System.out.println ("COLA CREADA....");
A continuación
} implementamos el código correspondiente al programa
boolean
de manejo devacia
colas ()
lineales en java:
{
if (frente == 0)
return (true);
else
return (false);
}
boolean llena ()
{
Lic. Katya Perezif (fin == MAX)
Martinez
return (true);
else
return (false);
}
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++)
}
int FINAL () Page 53
Lic. Katya
{ Perez Martinez
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....");
e = Lectura.Entero ();
insertar (e);
}
}
}
EJERCICIOS CON COLAS LINEALES
a. Eliminar los divisores de x de una cola

// 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 ();
}

{
Q.llenarCola ();
Q.imprimir ();
EliminarDivisoresX (Q);
}
}
3.6. COLAS CIRCULARES
Para hacer un uso más 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 representación
de una cola circular.
9
Ejemplo
8
33
1 45
22
85 7 Frente
Final 2 67
6
3
4 5
Para el siguiente ejemplo (a), en el cual ya no es posible adicionar

elementos siguiendo la anterior estructura, se propone la alternativa
(b):
D E
1 2 3 4 5
Frente Final
(a)
F D E
1 2 3 4 5
Final Frente
FinalCIRCULARFinal
//COLA DE NUMEROS ENTEROS Y SUS OPERACIONES
(b)
class ColaCircular
{
Final Frente
final int MAX = 20;
El diseño de la estructura de datos de una cola circular no varia en
relación
private (a) v[]
a int
una estructura
= new intde datos lineal, por tanto a continuación
[MAX];
private int fin;
mostramos las operaciones
private int frente; que sufren cambios en este tipo de colas.
ColaCircular ()
3.7.
{ Operaciones Con Colas Circulares
frente = 0;
fin = 0; básicas con colas circulares son: insertar, eliminar y
Las operaciones
System.out.println ("COLA CREADA....");
mostrar
} una cola circular. A continuación mostramos la implementación
en Java de una Cola Circular.
boolean vacia ()
{
if (frente == 0)
return (true);
else
return (false); Page 56
Lic. Katya
} Perez Martinez
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] Page 57
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++)
}
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....");
[Estructura ede= Datos] Lectura.Entero (); Page 58
insertar
Lic. Katya Perez Martinez (e);
}
}
}
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 ();
}

{
[EstructuraQ.llenarCola
de Datos] (); Page 59
Q.imprimir
Lic. Katya Perez Martinez ();
EliminarNegativos(Q);
}
}
3.9. COLAS DE PRIORIDADES
Una cola de prioridad es una estructura característica, donde se pude

retirar e insertar un ítem teniendo en cuenta la clave más grande o más
chica (según la implementación) 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 representación

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 informáticos, 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 operación inmediata, pero la
inserción tomaría un tiempo proporcional al número de elementos que
se encuentren en la cola, hay que tener en cuenta que dicha operación
se debe realizar en forma tal que la cola quede ordenada. Otra forma de
representación es a través de una lista desordenada, en la cual el
proceso de inserción es inmediato, pero el de extracción es muy lento,
ya que debo recorrer toda la cola para encontrar el ítem que debo
retirar.
3.10. APLICACIÓN DE PILAS Y COLAS

Hasta ahora se ha tratado solamente con la representación en memoria
y manipulación de una única pila o 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 sólo hay que representar
dos pilas sobre un mismo array A[1..n], la solución 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 más de dos pilas sobre ese mismo array A, no

es posible seguir la misma estrategia, ya que un array unidimensional
sólo tiene dos puntos fijos, A[1] y A[n], y cada pila requiere un punto fijo
para representar el elemento más profundo.
Cuando se requiere representar secuencialmente más 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
división inicial de A[1..n] en segmentos se puede hacer en base al
tamaño esperado de cada una de las estructuras. Si no es posible
conocer esa información, el array A se puede dividir en segmentos de
igual tamaño. 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 dónde está su tope. En
general, se hace que f(i) esté una posición por debajo del fondo real de
la pila, de forma que se cumpla la condición f(i)=c(i) si y solamente si la
pila i está vacía.

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 después 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 múltiplos de X de la cola circular
12. Utilizando colas circulares resuelva el problema de Josefo.
13. Utilice 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. CAPÍTULO RECURSIVIDAD
Aprende a nacer desde el dolor y a ser más grande

Aprende a nacer desde el dolor y a ser más grande
que el más grande de los obstáculos,
que el más grande de los obstáculos,
mírate en el espejo de ti mismo y serás libre y fuerte
mírate en el espejo de ti mismo y serás libre y fuerte
y dejarás de ser un títere de las circunstancias,
y dejarás de ser un títere de las circunstancias,
[Estructura deporque tu mismo eres tu destino.
Datos] Page 62
porque tu mismo eres tu destino.
Lic. Katya Perez Martinez Pablo Neruda
Pablo Neruda
4.1. INTRODUCCIÓN
Definición de Recursividad: Técnica de programación muy potente

que puede ser usada en lugar de la iteración.
Se dice que un objeto es recursivo, si en parte está formado por sí

mismo o se define en función de sí mismo
El concepto de recursividad va ligado al de repetición. Son recursivos

aquellos algoritmos que, estando encapsulados dentro de una función,
son llamados desde ella misma una y otra vez, en contraposición a los
algoritmos iterativos, que hacen uso de bucles while, do-while, for, etc.
4.2. AMBITO DE APLICACIÓN:
– General
– Problemas cuya solución se puede hallar solucionando el mismo
problema pero con un caso de menor tamaño.
4.3. RAZONES DE USO:
– Problemas “casi” irresolubles con las estructuras iterativas.

– Soluciones elegantes.
– Soluciones más simples.
• Condición necesaria: ASIGNACIÓN DINÁMICA DE MEMORIA
4.4. ¿EN QUÉ CONSISTE LA RECURSIVIDAD?

En el cuerpo de sentencias del subalgoritmo se invoca al propio
subalgoritmo para resolver “una versión más pequeña” del problema
original.
Habrá un caso (o varios) tan simple que pueda resolverse directamente

sin necesidad de hacer otra llamada recursiva.
• Aspecto de un subalgoritmo recursivo.
ALGORITMO Recursivo(...)
INICIO
...
Recursivo(...);
...
FIN
“... Como el costo de la programación aumenta con regularidad y el

costo de la computación disminuye, hemos llegado al punto en donde la
mayoría de los casos no vale la pena que un programador desarrolle
laboriosamente una solución no recursiva para un problema que se
resuelve con mayor naturalidad en forma recursiva”.
La recursividad desde el punto de vista de la programación es una

poderosa herramienta que facilita la implementación de algunos
algoritmos que de otro modo se harían muy complejos. El ejemplo
clásico de esto último es el recorrido de arboles.
4.5. FORMA DE ENFRENTAR PROBLEMAS RECURSIVOS.
a) Debe existir un caso BASE o Fin de recursión
ete debe ser un caso en que la función se puede computar en forma

simple (sin llamar a ninguna "copia" de ella). Este es el caso en que
se DETIENE la recursión
b) b) Parte puramente recursiva

Se debe confiar en que, al llamar a una COPIA de la función, ESA
función VA A RESOLVER EL PROBLEMA QUE LE ENTREGAMOS. No
importa cuan difícil sea ese problema, debemos creer que lo
soluciona.
Hay que verificar que el problema "más pequeño" sea efectivamente

MÁS PEQUEÑO, es decir, que el problema esté más cerca de

solucionarse. La idea es que sepamos que en cada llamada recursiva
estamos mas cerca del caso BASE
PROBLEMA PEQUEÑO PROBLEMA

DE TAMAÑO CALCULO DE TAMAÑO
N + N-1
Ejemplo definición de nº natural:

El N º 0 es natural
El Nº n es natural si n-1 lo es
El factorial de un número 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 tamaño (n-1)
| Calculo
Problema de tamaño n
//ITERATIVO: //RECURSIVO:
int Factorial( int n ) int Factorial ( int n )
{ int i, res=1; { if (n == 0)
for (i=1; i <= n; i++ ) return (1); return (n * Factorial
res = res * i;
(n-1) );
return ( res );
} }
En la siguiente figura vemos el proceso de la recursividad

Es necesario llevar un registro de todas las operaciones que se dejan
pendientes hasta que se llega al caso base.
El patrón que sigue este registro es el de una pila, en donde la
operación original se deja en el fondo y en el tope aparecería el caso
base.
Una vez que se llenó la pila, se efectúa la operación de vaciar la pila
efectuando todos los cálculos que previamente se habían dejado
pendientes
Por lo general, los lenguajes de alto nivel como el C, enmascaran todos

los detalles de la implementación. 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 máquina a la hora de ponerla a
funcionar.
4.6. TIPOS DE RECURSIVIDAD
 Recursividad simple: Aquella en cuya definición sólo aparece

una llamada recursiva. Se puede transformar con facilidad en
algoritmos iterativos.
 Recursividad múltiple: Se da cuando hay más de una llamada a

sí misma dentro del cuerpo de la función, resultando más dificil de
hacer de forma iterativa.

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 función provoca una llamada a sí misma de
forma indirecta, a través de otras funciones.
Ejemplo: Par o Impar:
int par ( int nump ) int impar ( int numi )

{ if ( nump == 0 ) { if ( numi == 0 )
return(1); return(0);
return (impar (nump-1) ); return( par ( numi -1) );
} }
4.7. LA PILA DE RECURSION

La memoria del ordenador se divide (de manera lógica, no física) en
varios segmentos (4):
Segmento de código: Parte de la memoria donde se guardan las

instrucciones del programa en cod. Máquina.
Segmento de datos: Parte de la memoria destinada a almacenar las
variables estáticas.
Montículo: Parte de la memoria destinada a las variables dinámicas.
Pila del programa: Parte destinada a las variables locales y
parámetros de la función que está siendo ejecutada.
4.8. LA LLAMADA A UNA FUNCIÓN

Se reserva espacio en la pila para los parámetros de la función y sus
variables locales.
Se guarda en la pila la dirección de la línea de código desde donde se
ha llamado a la función.
Se almacenan los parámetros de la función y sus valores en la pila.
Al terminar la función, se libera la memoria asignada en la pila y se
vuelve a la instrucción actual.
En el caso recursivo, cada llamada genera un nuevo ejemplar de la
función con sus correspondientes objetos locales:
La función se ejecutará normalmente hasta la llamada a sí misma. En
ese momento se crean en la pila nuevos parámetros y variables locales.
El nuevo ejemplar de función comieza a ejecutarse.
Se crean más 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);
Lic. Katya Perezreturn(
Martinez base * xelevn (base , exp-
1));
}
b). Multiplicar 2 nºs 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 función de Stirling

d) implementar en forma recursiva la función de ackerman
e) implementar en forma recursiva el problema de las torres
de Hanoi

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. INTRODUCCIÓN A LAS ESTRUCTURAS DE DATOS

DINÁMICA
Hasta ahora, todos los tipos de datos que se han visto, ya sean simples o
estructurados, tienen una propiedad común: son estáticos. Esto significa
que las variables que se declaran en un programa de alguno de estos
tipos mantendrán la misma estructura durante la ejecución del mismo.
Son variables estáticas y se definen en tiempo de compilación.
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 tamaño de las
estructuras usadas.
La técnica usada para manejar estas situaciones es la asignación
dinámica de memoria. Con este tipo de asignación se tendrán variables
dinámicas o referenciadas, que pueden crearse y destruirse en tiempo
de ejecución.
Ejemplo 2:

Si se pide diseñar un programa para gestionar una agenda de teléfonos
con los datos de personas (nombre, apellidos, dirección, cumpleaños,
teléfono, 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 dimensión MAX, pueden surgir los siguientes
problemas:
¿Qué pasa si se quieren insertar más personas de MAX en la agenda?
Hay que recompilar el programa para ampliar MAX
Si el número de personas de la agenda es mucho menor que MAX se
está desperdiciando memoria que podría 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 tamaño depende del dibujo
trazado
5.2. MECANISMOS PARA ENLAZAR INFORMACIÓN
1. LISTAS
o Listas simplemente enlazadas
 Solo hay un enlace por nodo
 Solo se puede recorrer en una dirección
o Listas doblemente enlazadas
o Lista circular simplemente enlazada
o Lista circular doblemente enlazada
2. ÁRBOLES Y GRAFOS

5.3. LISTAS ENLAZADAS
Las listas enlazadas son estructura de datos naturales

donde el número 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

están 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 dinámico.
 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á vacía o no existe la lista
Toda lista cuenta con una cabecera y

nodos.
Gráficamente una lista simplemente enlazada se representa de la

siguiente forma:
Dirección de memoria
Cabeza de la Ultimo elemento de
Lista la Lista
Nodo
23 12 4
P Info enlace
NOTA Las listas almacenadas en arreglos están sujetos al tamaño del

arreglo para su crecimiento. Si estos están vacíos se esta ocupando

memoria sin uso. Además las listas reflejan el orden lógico y el orden
físico de los elementos en el arreglo.
 Características:
 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 básicamente de dos partes:

 Un campo de información, en cual se almacenan datos o
estructuras
 Un campo de dirección, en el cual se almacena la dirección
del nodo siguiente.
La implementación de un nodo podría ser de la siguiente forma:
5.5. CONSTRUCCIÓN DE UN TAD LISTA ENLAZADA

LINEAL SIMPLE
Nodo ListaLineal
Info: tipo_dato P: Nodo

Dirsgte: Nodo
InsertarInicio(e)
Nodo() InsertarFinal()
EliminarInicio()
EliminarFinal()
[Estructura de Datos] 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 información del nodo.
dirsgte: almacena la dirección del siguiente nodo de la lista, en
caso de ser el último nodo entonces apunta a nulo.
5.6. OPERACIONES BÁSICAS SOBRE LISTAS

ENLAZADAS
Existen cinco operaciones básicas que se pueden hacer sobre listas

enlazadas:
 Creación: de una lista vacía

 Vacía: Retorna verdadero si la lista L está vacía y falso en caso
contrario.
 Inserción: 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 vacía
 Imprime Lista: Imprime los elementos de la lista L

Creación de una lista vacía
A continuación implementamos la sentencia para crear una lista

vacía en java.
nodo p = null;
Inserción
a) Inserción al Final de la lista
En el siguiente segmento de código 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 implementación 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) Inserción al Inicio de la lista
En el siguiente segmento de código se implementa el caso en el que el nuevo nodo

se inserta en la cabeza de la lista, a continuación se muestra la implementación en
public void insertarInicio (double elem)
java:
{
//Aniadir un elemento al principio de la lista
q.info = elem;
q.dirsgte = p;
p = q;
}
Para el siguiente ejemplo se ilustra el proceso de adición 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] q = q.dirsgte; Page 76
}
}
d) Eliminar el nodo del inicio de la Lista
La siguiente función recibe una lista y devuelve esa misma lista, sin el
nodo que ocupaba inicialmente la posición de la cabeza.
La función 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] Page 77
Lic. Katya Perez
} Martinez
5.7. IPLEMENTACIÓN EN EL LENGUAJE JAVA DE LA
CLASE LISTAS LINEALES
//LISTAS LINEALES
import java.io.*;
A continuación realizamos la implementación 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
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 t = p;
q.info = elem;
q.dirsgte = null;
if (p == null)
[Estructura de p =Datos]
q; Page 78
else
{
while (t.dirsgte != null)
t = t.dirsgte;
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 Page 79
isr = new InputStreamReader (System.in);
Lic. KatyaBufferedReader
Perez Martinez br = new BufferedReader (isr);
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
Escribir una aplicación L para
en java = new listaLineal
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 ();
}
}
5.8. LISTAS DOBLEMENTE ENLAZADAS
Una lista doble, ó doblemente enlazada es una colección 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 través de la lista, según 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.

Debido a que las listas dobles circulares son más eficientes, los
algoritmos que en esta sección se traten serán sobre listas dobles
circulares.
En la figura siguiente se muestra un ejemplo de una lista doblemente

ligada lineal que almacena números:
En la figura siguiente se muestra un ejemplo de una lista doblemente

ligada circular que almacena números:
A continuación mostraremos algunos algoritmos sobre listas enlazadas.

Como ya se mencionó, llamaremos li al puntero izquierdo y ld al puntero
derecho, también usaremos el apuntador top para hacer referencia al
primer nodo en la lista, y p para referenciar al nodo presente.
Algoritmo de creación
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

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' información

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' información

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

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 característica de que el último elemento de

la misma apunta al primero
La siguiente figura es una representación gráfica de una lista circular.
Enseguida se mostrarán los algoritmos más comunes en listas circulares.

Al igual que en las secciones anteriores, utilizaremos el apuntador top
para hacer referencia al primer nodo en la lista.

Algoritmo de creación
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' información

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 después de 'X' información

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

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 después 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.

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 información
sea X. X dado por el usuario
8. Insertar N nodos nuevos después del nodo K-esimo.
9. Eliminar N nodos desde la posición 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.
"examínate.. Y no te dejes vencer"
"examínate.. Y no te dejes vencer"
6.1. DEFINICIÓN ÁRBOL

Un árbol es una estructura no lineal en la que cada nodo puede
apuntar a uno o
varios nodos.
6.2. CONCEPTOS BÁSICOS
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 característica
importante: cada nodo sólo puede ser apuntado por otro nodo, es decir,
cada nodo sólo tendrá un padre. Esto hace que estos árboles estén
fuertemente jerarquizados, y es lo que en realidad les da la apariencia
de árboles.
En cuanto a la posición dentro del árbol:
c. Nodo raíz: 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'.
e. Nodo rama: aunque esta definición apenas la usaremos, estos
son los nodos que no pertenecen a ninguna de las dos categorías
anteriores. En el ejemplo: 'B', 'C', 'D', 'E', 'F' y 'J'.
Existen otros conceptos que definen las características del árbol, con
relación a su tamaño:
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 número de hijos que tiene el elemento con más 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
más de tres hijos.
h. Nivel: se define para cada elemento del árbol como la distancia a
la raíz, medida en nodos. El nivel de la raíz 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 raíz de un árbol, también 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. CARACTERÍSTICAS 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á más 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 representación gráfica de un árbol binario es la siguiente:

Los arboles representan las estructuras no lineales y dinámicas de datos
más importantes en computación . Dinámicas porque las estructuras de
árbol pueden cambiar durante la ejecución de un programa. No lineales,
puesto que a cada elemento del árbol pueden seguirle varios elementos.
Los arboles pueden ser construidos con estructuras estáticas y

dinámicas. Las estáticas son arreglos, registros y conjuntos, mientras
que las dinámicas están representadas por listas.
La definición de árbol es la siguiente: es una estructura jerárquica

aplicada sobre una colección de elementos u objetos llamados nodos;
uno de los cuales es conocido como raíz. además se crea una relación o
parentesco entre los nodos dando lugar a términos como padre, hijo,
hermano, antecesor, sucesor, ansestro, etc.. Formalmente se define un
árbol de tipo T como una estructura homogénea que es la concatenación
de un elemento de tipo T junto con un número finito de arboles
disjuntos, llamados subarboles. Una forma particular de árbol puede ser
la estructura vacía.
La figura siguiente representa a un árbol general.
Se utiliza la recursión para definir un árbol porque representa la forma

más apropiada y porque además es una característica inherente de los
mismos.

Los arboles tienen una gran variedad de aplicaciones. Por ejemplo, se
pueden utilizar para representar fórmulas matemáticas, para organizar
adecuadamente la información, para construir un árbol genealógico,
para el análisis de circuitos eléctricos y para numerar los capítulos y
secciones de un libro.
6.4. TRANSFORMACIÓN 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 continuación:
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 más a la izquierda. Además, debe eliminarse el vínculo 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. REPRESENTACIÓN DE UN ÁRBOL EN MEMORIA
Hay dos formas tradicionales de representar un árbol binario en

memoria:
Por medio de datos tipo punteros también conocidos como variables

dinámicas o listas.
Por medio de arreglos.
Sin embargo la más utilizada es la primera, puesto que es la más natural

para tratar este tipo de estructuras.
Los nodos del árbol binario serán representados como registros que
contendrán como mínimo tres campos. En un campo se almacenará la

información del nodo. Los dos restantes se utilizarán para apuntar al
subarbol izquierdo y derecho del subarbol en cuestión.
Cada nodo se representa gráficamente de la siguiente manera:
El algoritmo de creación 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. CLASIFICACIÓN DE ARBOLES BINARIOS
Existen cuatro tipos de árbol binario:.

 A. B. Distinto.
 A. B. Similares.
 A. B. Equivalentes.
 A. B. Completos.

A continuación se hará una breve descripción 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 idénticas,
pero la información que contienen sus nodos es diferente. Ejemplo:
A. B. EQUIVALENTES
Son aquellos arboles que son similares y que además los nodos
contienen la misma información. 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

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 continuación:
1. INORDEN
o Recorrer el subarbol izquierdo en inorden.
o Examinar la raíz.
o Recorrer el subarbol derecho en inorden.
2. PREORDEN
o Recorrer el subarbol izquierdo en preorden.
o recorrer el subarbol derecho en preorden.
3. POSTORDEN
o Recorrer el subarbol izquierdo en postorden.
o Recorrer el subarbol derecho en postorden.
A continuación se muestra un ejemplo de los diferentes recorridos en un
árbol binario.
Inorden: GDBHEIACJKF
Preorden: ABDGEHICFJK
Postorden: GDHIEBKJFCA
6.8. ARBOLES ENHEBRADOS

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 BÚSQUEDA
Un árbol de búsqueda 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 búsqueda.
Un árbol binario de búsqueda es aquel en el que el hijo de la izquierda

(si existe) de cualquier nodo contiene un valor más pequeño que el nodo
padre, y el hijo de la derecha (si existe) contiene un valor más grande
que el nodo padre.
Un ejemplo de arbol binario de búsqueda es el siguiente:

6.10. GRAFOS
Un grafo dirigido G consiste en un conjunto de vértices V y un conjunto

de arcos o aristas A. Los vertice se denominan también nodos o puntos.
Un arco, es un par ordenado de vértices(V,W) donde V es el vértice
inicial y W es el vértice terminal del arco. Un arco se expresa como: V--
>W y se representa de la siguiente manera:
Los vértice de un grafo pueden usarse para representar objetos. Los

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

 Rutas entre ciudades.
 Determinar tiempos máximos y mínimos en un proceso.
 Flujo y control en un programa.
6.11. DEFINICIONES BÁSICAS
La terminología que manejaremos regularmente para el uso de grafos es

la siguiente:
 CAMINO.Es una secuencia de vértices V1, V2, V3, ... , Vn, tal que
cada uno de estos V1-&gtV2, V2-&gtV3, V1-&gtV3.
 LONGITUD DE CAMINO. Es el número de arcos en ese camino.
 CAMINO SIMPLE. Es cuando todos sus vértices, 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 vértice.

 ARISTAS PARALELAS. Es cuando hay más de una arista con un
vértice inicial y uno terminal dados.
 GRAFO CICLICO. Se dice que un grafo es cíclico cuando contiene
por lo menos un ciclo.
 GRAFO ACICLICO. Se dice que un grafo es aciclíco 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 tendrán que cumplirse ambas
condiciones), es decir que cada nodo G es adyacente a todos los
demás nodos de G.
 GRAFO UNILATERALMENTE CONEXO.Un grafo G 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. También a este
grafo se le denomina red de actividades, y el número asociado al
arco se le denomina factor de peso.
 VERTICE ADYACENTE. Un nodo o vértice 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 número 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 número 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.

 NODO SUMIDERO.Se le llama sumidero al nodo que tiene grado
de salida nulo y un grado de entrada positivo.
6.12. REPRESENTACIÓN EN MEMORIA SECUENCIAL
Los grafos se representan en memoria secuencial mediante matrices de

adyacencia.
Una matríz de adyacencia, es una matríz de dimensión n*n, en donde n

es el número de vértices que almacena valores booleanos, donde matríz
M[i,j] es verdadero si y solo si existe un arco que vaya del vértice y al
vértice j.
Veamos el siguiente grafo dirigido:
La matríz de adyacencia, que se obtuvo a partir del grafo anterior es la

siguiente:

6.13. REPRESENTACIÓN 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
vértice i es una lista en cierto orden formada por todos los vértices

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 vértice i.
Veamos el siguiente grafo dirigido:
La lista de adyacencia, que se obtuvo a partir del grafo anterior es la

siguiente:
Otros ejemplos de Representación de grafo son los siguientes

6.14. OPERACIONES SOBRE GRAFOS
En esta sección analizaremos algunas de las operaciones sobre grafos,

como :
 Creación.
 Inserción.
 Búsqueda.
 Eliminación.
En esta sección, 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 vértices adyacentes p(dato) ?)
lee(respuesta)
si respueta=si entonces
repite
new(q)
lee(q(dato))
q(ld)<--p(ld)
p(ld)<--q
mensaje(otro vértice ?)
lee(respuesta2)
hasta respuesta2=no

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 vértices adyacentes?)
lee(respuesta)
si respuesta=si entonces
mensaje(Cuantos vértices?)
lee(número_vértices)
desde i=1 hasta número_vértices haz
new(p)
lee(p(dato))
q(ld)<--p
q<--q(ld)
en caso contrario
mensaje(no existe lista)
ALGORITMO DE BUSQUEDA
mensaje(vértice a buscar)
lee(vértice_a_buscar)
p<--top
repite
si p(dato)=vértice_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(vértice a borrar ?)
lee(vértice_a_borrar)
p&Lt--top
r<--p
q<--p
sw<--falso
repite
si p(dato)=vértice_a_borrar entonces
si p=top entonces
top<--top(la)
r<--top
sw<--verdadero
en caso contrario
r(la)<--p(la)
repite

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)=vértice_a_borrar entonces
p(ld)<--q(ld)
dispose(q)
q<--p
en caso contrario
p<--p(ld)
hasta p=NIL
6.15. CAMINO MÍNIMO
Se denomina camino mínimo entre dos vértices V y W, al camino óptimo

entre ambos vértices.Para determinar el camino mínimo entre dos
vértices se utiliza el siguiente algoritmo:

desde j=1 hasta número_vértices haz
si w[i,j]=0 entonces
q[[i,j]<--infinito
en caso contrario
q[i,j]<--w[i,j]
desde k=1 hasta número_vértices haz
desde j=1 hasta número_vértices haz
q[i,j]<--min(q[i,j], q[i,k] + q[k,j])

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 números enteros .

Se pide :
- Hacer un procedimiento que reciba como parámetros: el
puntero a raiz del arbol , y un número entero . El procedimiento
debe buscar el elemento NUM y una vez encontrado visualizar
todos sus antecesores (los anteriores).

GLOSARIO
ALGORITMO. Es una descripción de los pasos de una tarea.

ASCII. American Standard Code for Information Interchange. Es un
código muy utilizado para el intercambio de datos. Como los
ordenadores solo procesan dígitos binarios, cada letra, dígito o carácter
especial tiene su correspondiente código binario.
ASIGNACIÓN. Usado en programación. Es la acción de poner en una
variable un valor, él contenido de otra variable o el resultado de evaluar
una expresión. En la mayoría 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 raíz), tienen un antecedente. Todos pueden
tener otros elementos asociados llamados consecuentes.
BIFURCACIÓN. En programación: transferencia de la secuencia de
ejecución a otra parte del programa. Puede ser condicional o
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 condición.
BYTE. Conjunto de bits que contiene el código para un carácter. El byte
de 8 bits, llamado octeto, es el más usado actualmente. Las capacidades
de almacenamiento se miden en bytes o en sus múltiples. 1 K (kilobyte)
= 1024 bytes. 1 Mb (megabyte) = 1024K. 1Gb (Gigabyte) = 1024 Mb.
C. Lenguaje de programación de alto nivel que posee características 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. También recibe este nombre un
conjunto de programas relacionados lógicamente para realizar una
tarea.

CARÁCTER. Dígito, letra o símbolo que puede ser tratado por un
ordenador. Es la unidad elemental de información desde el punto de
vista externo.
CODIFICAR. Es la parte de la programación consistente en escribir en
un lenguaje informático el algoritmo que resuelve un problema.
CÓDIGO. Tabla de traducción entre todos los posibles símbolos de dos
alfabetos. El más conocido es el código ASCII (American Standard Code
for Information Interchange).
COLA. Estructura de información consistente en una lista lineal en la
que la nueva información 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 impresión 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 específicas.
CONTADOR. Usado en programación. Variable que contiene el número
de acciones realizadas.
COMPILADOR. Programa que traduce un programa escrito en un
lenguaje de alto nivel a lenguaje de máquina. Además de traducir se
detectan posibles errores de sintaxis.
DIRECCIÓN. Etiqueta, nombre o número que identifica la posición 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 instrucción en código máquina o bien hacer
que se realicen las instrucciones de un programa.
ESTRUCTURA DE DATOS. Conjunto de datos en que sus componentes
están relacionados entre sí de una forma particular y sobre los que se
pueden realizar ciertas operaciones según sea el tipo de relación que
hay entre ellos.
EXPRESIÓN. Conjunto de variables, constantes, funciones y símbolos
de operación que expresan un cálculo a realizar. Proporcionan un valor
que será del tipo (aritmético, alfanumérico o lógico) de las variables y
constantes que contiene.

FICHERO. Conjunto organizado de información almacenado en un
soporte. Está formado por registros que contienen la información de
cada elemento del fichero. Los registros a su vez están divididos en
campos, siendo cada campo uno de los datos del registro. Por ejemplo
en un fichero de clientes, cada cliente sería un registro y tendríamos los
campos: nombre, apellidos, dirección, teléfono, etc.
I/O. Símbolo de Input/Output. Entrada/Salida desde o hacia un
ordenador.
IMPLEMENTAR. Instalar y hacer funcionar
INSTRUCCIÓN. Se llama instrucción a cada una de las líneas que
componen un programa de ordenador.
Lenguaje de programación. Conjunto de símbolos e instrucciones que
pueden ser reconocidos y procesados por un ordenador.
LIBRERÍA. Conjunto de programas o módulos almacenados
generalmente sobre un dispositivo magnético.
LISTA. Conjunto de elementos de datos organizados de modo que se
conoce la posición relativa de cada elemento.
MENU. Es un conjunto de opciones presentado por un programa. La
elección se efectúa tecleando un código, con los cursores o señalándolo
con algún dispositivo como el ratón o el lápiz óptico.
MÓDULO. En programación, cada uno de los bloques lógicos 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 programación de
permitir que un programa solicite su propia ejecución en el curso de su
desarrollo.
SUBPROGRAMA. Conjunto de instrucciones que efectúan una tarea
específica dentro de un programa y al que es posible referirse.
USUARIO. Es la persona que hace uso de un sistema de ordenadores.
VARIABLE. En programación es una entidad dedicada a contener
valores que pueden cambiar durante la ejecución de un programa.
VENTANA. Una parte de la pantalla dedicada a representar un
subconjunto de datos particulares.

LECTURAS COMPLEMENTARIAS
1. Estructuras de Datos
http://cuhwww.upr.clu.edu/~jse/cursos/4097/notas/
2. versión electrónica y en línea de uno de los libros sobre estructuras de datos

de mayor interés (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 arbóreas
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

8. Metodología de la Programacion II


Katia Perez Programacion en Java

Cargado por

Copyright:

Formatos disponibles

Katia Perez Programacion en Java

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Katia Perez Programacion en Java

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD SALESIANA

Lic. Katya Maricela Pérez Martínez

[Estructura de Datos] Page 2

[Estructura de Datos] Page 3

[Estructura de Datos] Page 4

Para procesar información en un computador es necesario hacer una

1.2. ESTRUCTURAS FUNDAMENTALES

Los datos a procesar por una computadora se clasifican en:

Declaramos un dato compuesto o estructurado A que tendrá 5 elementos de

Una abstracción es un proceso mental donde se extraen rasgos

1.4. DEFINICIÓN DE ESTRUCTURAS DE DATOS

[Estructura de Datos] Page 2

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

Al diseñar una estructura de datos con la técnica de abstracción pasa a

 Puede implementarse en cualquier lenguaje

Nombre del TAD ESTUDIANTE

Como se puede notar existe una operación No Permitida denominada:

Recuerda en todo momento que sólo deben incluirse las

1.6. CLASIFICACIÓN DE LAS ESTRUCTURAS DE DATOS

Las estructuras de datos desde el punto de vista de asignación de

[Estructura de Datos] Page 3

También pueden ser clasificadas en:

Son aquellas en las que el tamaño ocupado en memoria se define antes

1.6.2. ESTRUCTURAS DE DATOS DINÁMICAS

Las estructuras dinámicas de datos son estructuras que cuya dimensión

1.6.3. ESTRUCTURAS DE DATOS LINEALES

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

1.6.4. ESTRUCTURAS DE DATOS NO LINEALES

Se denominan estructuras de datos No Lineales porque a cada elemento

1.7. ESTRUCTURAS DE DATOS ESTÁTICAS

[Estructura de Datos] Page 4

Un arreglo tiene dos partes: Componentes e índices

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

1.7.2. ARREGLOS UNIDIMENSIONALES (VECTORES)

Son los arreglos más simples y constan de un solo índice, también se

Notación: Podría ser de diferentes maneras. Por ejemplo:

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

1.7.3. Declaración de vectores

[Estructura de Datos] Page 5

Luego, se debe crear el Array con el operador new, de la siguiente

Identificador = new tipo [ cantidad_de_elementos ];

public class Array

Implementación del TAD Vector

Este es el diseño del TAD vector que maneja números enteros.

public class Vector

static InputStreamReader Caracteres;

static void leedim () throws IOException

static void leervector () throws IOException

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

static void mostrarvector () throws IOException

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

public static void main (String [] args) throws IOException

1. Se almacena en un vector las cosechas de lechugas durante 6

C es el vector que tiene en cada mes una cantidad de

La salida como la siguiente:

b. Sabiendo que cada planta de lechuga cuesta 4Bs, se pide

La salida como la siguiente:

2. Realice un programa que elimine elementos duplicados de un