Libro de Estructura de Datos en Java de Katy Version Ii PDF

Estructuras de Datos en Java
Katya Maricela Pérez Martínez

Lic Katya Perez Martinez 1 Estructura de Datos
Contenido
....................................................................................................... 6
INTRODUCCIÓN. ........................................................................................................................................ 6
CARACTERÍSTICAS DE JAVA: ...................................................................................................................... 6
EL KIT DE DESARROLLO JAVA (JDK) ............................................................................................................ 6
PROGRAMANDO EN JAVA ......................................................................................................................... 6
HERRAMIENTAS DE PROGRAMACIÓN: ...................................................................................................... 7
ENTORNO DE DESARROLLO ....................................................................................................................... 7
EMPEZANDO A PROGRAMAR EN JAVA UTILIZANDO ECLIPSE. ................................................................... 8
ENTORNO DE ECLIPSE .............................................................................................................................. 12
CREACION DE PROYECTOS EN JAVA ECLIPSE ............................................................................................ 12
CREAR PAQUETE ...................................................................................................................................... 15
CREAR CLASE ........................................................................................................................................... 16
AGREGAMOS CODIGO AL PROGRAMA PRINCIPAL .................................................................................. 18
COMO EJECUTAR EL PROGRAMA ............................................................................................................. 19
EJERCICIOS RESUELTOS ............................................................................................................................ 25
EJERCICIOS PROPUESTOS ...................................................................................................................... 33
.................................................... 34
INTRODUCCIÓN ....................................................................................................................................... 34
ESTRUCTURAS FUNDAMENTALES............................................................................................................ 34
ABSTRACCIÓN ......................................................................................................................................... 35
DEFINICIÓN DE ESTRUCTURAS DE DATOS ................................................................................................ 35
T.D.A. (TIPO DE DATO ABSTRACTO) ......................................................................................................... 35
CLASIFICACIÓN DE LAS ESTRUCTURAS DE DATOS .................................................................................... 36
- ESTRUCTURAS DE DATOS ESTÁTICAS ............................................................................................. 36
- ESTRUCTURAS DE DATOS DINÁMICAS............................................................................................ 37
- ESTRUCTURAS DE DATOS LINEALES ................................................................................................ 37
- ESTRUCTURAS DE DATOS NO LINEALES .......................................................................................... 37
ESTRUCTURAS DE DATOS ESTÁTICAS ....................................................................................................... 37
ARREGLOS ........................................................................................................................................... 37
ARREGLOS UNIDIMENSIONALES (VECTORES) .......................................................................................... 37
Declaración de vectores en Java ......................................................................................................... 38
IMPLEMENTACIÓN DEL TIPO DE DATO ABSTRACTO VECTOR ................................................................... 39
EJERCICIOS RESUELTOS .................................................................................................................................. 41
EJERCICIOS PROPUESTOS ........................................................................................................................ 50
CADENAS EN JAVA ................................................................................................................................... 52
LOS METODOS DE LA CLASE STRING ........................................................................................................ 52
ARREGLOS MULTIDIMENSIONALES ......................................................................................................... 68
ARREGLOS BIDIMENSIONALES (MATRICES) ............................................................................................ 68
DECLARACION Y CREACION DE UNA MATRIZ EN JAVA ............................................................................. 68
INICIALIZACION DE UNA MATRIZ ............................................................................................................. 69
OPERACIONES CON ARREGLOS BIDIMENSIONALES ................................................................................. 69
EJERCICIOS PROPUESTOS DE MATRICES .................................................................................................. 75
REGISTROS (ESTRUCTURAS) .................................................................................................................... 76
DEFINICIÓN DE REGISTRO Y DECLARACIÓN DE LA VARIABLE DE REGISTRO.............................................. 76
COMO CREAR UNA VARIABLE DE REGISTRO ....................................................................................... 77
COMO ACCEDER A LAS OPERACIONES DE UN REGISTRO .................................................................... 77

REGISTROS ANIDADOS ............................................................................................................................ 79
VECTORES CON REGISTROS ..................................................................................................................... 83
MATRICES POCO DENSAS ........................................................................................................................ 87
IMPLEMENTACIÓN DE UNA MATRIZ POCO DENSA ................................................................................................. 87
........................................................................................................................... 92
RECURSION ............................................................................................................................................. 92
RECURSIÓN VS ITERACIÓN....................................................................................................................... 92
RECURSIÓN ............................................................................................................................................. 92
Factorial Iterativo ............................................................................................................................... 93
FACTORIAL RECURSIVO .................................................................................................................................. 93
¿CÓMO FUNCIONA? ................................................................................................................................ 94
Fibonacci ............................................................................................................................................. 95
Fibonacci recursivo ............................................................................................................................. 96
¿ES EFICIENTE ESTA IMPLEMENTACIÓN? ................................................................................................. 96
TIPOS DE RECURSIVIDAD ......................................................................................................................... 96
LA PILA DE RECURSION ............................................................................................................................ 97
LA LLAMADA A UNA FUNCIÓN ................................................................................................................. 98
................................................................................................................. 102
INTRODUCCIÓN A LAS ESTRUCTURAS DE DATOS DINÁMICAS ............................................................... 102
MECANISMOS PARA ENLAZAR INFORMACIÓN ...................................................................................... 103
LISTAS ENLAZADAS ................................................................................................................................ 103
TIPO DE DATO ABSTRACTO NODO ......................................................................................................... 104
OPERACIONES BÁSICAS SOBRE LISTAS ENLAZADAS ............................................................................... 105
DISEÑO DE LA ESTRUCTURA DE DATOS LISTA ENLAZADA LINEAL SIMPLE .............................................. 105
CREACIÓN DE UNA LISTA VACÍA ..................................................................................................................... 106
INSERCIÓN AL FINAL DE LA LISTA ...................................................................................................... 106
INSERCIÓN AL INICIO DE LA LISTA ..................................................................................................... 107
RECORRIDO DE UNA LISTA: ............................................................................................................... 107
ELIMINAR EL NODO DEL INICIO DE LA LISTA ...................................................................................................... 108
ELIMINAR EL NODO DEL FINAL DE LA LISTA ..................................................................................... 108
VACIA ................................................................................................................................................ 109
BUSCAR ............................................................................................................................................. 109
IPLEMENTACIÓN EN EL LENGUAJE JAVA DE LA CLASE LISTAS LINEALES ................................................. 110
LISTAS DOBLEMENTE ENLAZADAS ......................................................................................................... 114
LISTA ENLAZADA CIRCULAR SIMPLE ...................................................................................................... 115
LISTA ENLAZADA DOBLE LINEAL ............................................................................................................ 118
LISTAS DOBLES CIRCULARES .................................................................................................................. 121
.............................................................................................................................................. 125
INTRODUCCIÓN ..................................................................................................................................... 125
REPRESENTACIÓN DE LAS PILAS ............................................................................................................ 126
ESTRUCTURA DE UNA PILA UTILIZANDO ARREGLOS .............................................................................. 127
OPERACIONES CON PILAS ...................................................................................................................... 127
IMPLEMENTACIÓN DE LA ESTRUCTURA DE DATOS PILA EN LENGUAJE JAVA ......................................... 128
APLICACIONES CON PILAS...................................................................................................................... 133
LLAMADAS A SUBPROGRAMAS ........................................................................................................ 133
RECURSIÓN ........................................................................................................................................... 135
TRATAMIENTO DE EXPRESIONES ARITMÉTICAS .................................................................................... 135
PILAS DINÁMICAS .................................................................................................................................. 136
EJERCICIOS RESUELTOS CON PILAS DINAMICAS ..................................................................................... 138
............................................................................................................................................ 141
INTRODUCCIÓN ..................................................................................................................................... 141
CARACTERÍSTICAS ................................................................................................................................. 142
REPRESENTACIÓN DE LAS COLAS ........................................................................................................... 142
ESTRUCTURA DE UNA COLA IMPLEMENTADO MEDIANTE ARREGLOS ................................................... 142
OPERACIONES CON COLAS .................................................................................................................... 143
INSERTAR UN ELEMENTO EN LA COLA: ............................................................................................................. 143
ELIMINAR UN ELEMENTO DE LA COLA: ............................................................................................................. 144
COLAS LINEALES .................................................................................................................................... 144
COLAS CIRCULARES................................................................................................................................ 147
OPERACIONES CON COLAS CIRCULARES ........................................................................................... 148
EJERCICIOS CON COLAS CIRCULARES ..................................................................................................... 151
COLAS DE PRIORIDADES ........................................................................................................................ 152
APLICACIÓN DE PILAS Y COLAS .............................................................................................................. 153
COLAS DINAMICAS ................................................................................................................................ 153
....................................................................................................................................... 159
.............................................................................................................................................................. 159
DEFINICIÓN ÁRBOL ................................................................................................................................ 159
CONCEPTOS BÁSICOS ............................................................................................................................ 159
CARACTERÍSTICAS DE LOS ARBOLES BINARIOS ...................................................................................... 161
TRANSFORMACIÓN DE UN ARBOL GRAL. EN UN ARBOL BINARIO.......................................................... 162
REPRESENTACIÓN DE UN ÁRBOL EN MEMORIA ..................................................................................... 162
CLASIFICACIÓN DE ARBOLES BINARIOS ................................................................................................. 163
A. B. DISTINTO .................................................................................................................................. 164
A. B. SIMILARES ................................................................................................................................ 164
A. B. EQUIVALENTES ......................................................................................................................... 164
A. B. COMPLETOS .............................................................................................................................. 164
RECORRIDO DE UN ARBOL BINARIO ...................................................................................................... 164
ARBOLES ENHEBRADOS ......................................................................................................................... 166
ARBOLES BINARIOS DE BÚSQUEDA ....................................................................................................... 166
IMPLEMENTACION DE UN ARBOL BINARIO ........................................................................................... 167
EJERCICIOS DE ARBOLES ........................................................................................................................ 172
........................................................................................................................................ 173
GRAFOS ................................................................................................................................................. 173
DEFINICIONES BÁSICAS ......................................................................................................................... 173
REPRESENTACIÓN EN MEMORIA SECUENCIAL....................................................................................... 174
REPRESENTACIÓN EN MEMORIA ENLAZADA ......................................................................................... 175
OPERACIONES SOBRE GRAFOS .............................................................................................................. 176
ALGORITMO DE CREACION .................................................................................................................... 176
ALGORITMO DE INSERCION ................................................................................................................... 177
ALGORITMO DE BUSQUEDA .................................................................................................................. 178
ALGORITMO DE BORRADO .................................................................................................................... 178
CAMINO MÍNIMO .................................................................................................................................. 179
ALGORITMO DE DIJKSTRA ..................................................................................................................... 179
EJERCICIOS RESUELTOS DE GRAFOS ....................................................................................................... 183
¿QUÉ ES ECLIPSE? ...................................................................................................................................... 189
1. INSTALACION DE JAVA ................................................................................................................. 189
2. INSTALACION DE ECLIPSE ............................................................................................................. 192
3. INGRESAR A ECLIPSE ..................................................................................................................... 193

 ESTRUCTURA SELECTIVA SIMPLE. ................................................................................................. 205
 ESTRUCTURA CONDICIONAL COMPUESTA. .................................................................................. 207
 ESTRUCTURA CONDICIONAL COMPUESTA IF-ELSE-IF................................................................... 210
 ESTRUCTURA SELECTIVA MULTIPLE (SWITCH-CASE)..................................................................... 213
PROBLEMAS PROPUESTOS .................................................................................................................... 215

INTRODUCCIÓN.
Java es un lenguaje de programación orientado a objetos.
Todo programa en java está conformado por una o más clases.
Cada clase debe tener un nombre único.
El archivo en el que se define una clase (también llamado unidad de compilación) debe tener el
mismo nombre de la clase más la extensión .java.
En un programa java, absolutamente todo es un objeto. Así desde el programa principal, las librerías
que usemos, y archivos extras que integremos serán clases para crear objetos
CARACTERÍSTICAS DE JAVA:
 Multiplataforma
 Orientado a Objetos
 Integrable a la red
 Seguro
 Con una sintaxis similar a C++
 Desarrollado por Sun Microsystems.
 Adquirido por Oracle.
EL KIT DE DESARROLLO JAVA (JDK)

Para escribir en Java, hacen falta los programas que realizan el precompilado y la interpretación del
código. Hay entornos que permiten la creación de los bytecodes y que incluyen herramientas con
capacidad de ejecutar aplicaciones de todo tipo. El más famoso (que además es gratuito) es el Java
Developer Kit (JDK) de Sun, que se encuentra disponible en la dirección http://java.sun.com.
Actualmente ya no se le llama así sino que se le llama SDK y en la página se referencia la plataforma
en concreto.
PROGRAMANDO EN JAVA
La principal característica de Java es la de ser un lenguaje compilado e interpretado. Todo programa
en Java ha de compilarse y el código que se genera bytecodes es interpretado por una máquina
virtual. De este modo se consigue la independencia de la máquina, el código compilado se ejecuta
en máquinas virtuales que si son dependientes de la plataforma, como se ve en la figura 1.

Figura 1. SECUENCIA DE PASOS DE UN PROGRAMA EN JAVA
Se encarga de
traducir el programa Se encarga de
Archivo fuente de Java a su forma ejecutar el
de java binaria (byte code) programa binario.
Compilador
De Java Máquina
virtual de
java
Archivo de byte
code (.class)
HERRAMIENTAS DE PROGRAMACIÓN:
Hay dos esquemas para desarrollar programas en Java:
 Usar directamente las herramientas de línea de comando del JDK (JSE Development Kit).
 Usar un Ambiente de Desarrollo Integrado o IDE (Integrated Development Environment). Un
IDE facilita las labores comunes al momento de programar: edición, compilación, ejecución
y depuración. Algunos IDEs populares para Java son: Eclipse, NetBeans, JBuilder, JCreator,
BlueJ.
En este texto se utiliza el Eclipse.
ENTORNO DE DESARROLLO
El JDK incluye un conjunto de herramientas de línea de comandos para compilar y ejecutar el código
Java, que incluye una copia completa del JRE. Aunque se utilizan estas herramientas para desarrollar
aplicaciones, la mayoría de los desarrolladores valoran la funcionalidad adicional, la gestión de
tareas y la interfaz visual de un IDE.
Eclipse es un IDE de código abierto popular para el desarrollo Java. Maneja las tareas básicas, tales
como la compilación de códigos y la configuración de un entorno de depuración, para que pueda
centrase en escribir y probar códigos.
Eclipse se puede usar para organizar archivos de códigos de origen en proyectos, compilar y probar
esos proyectos y almacenar archivos de proyectos en cualquier cantidad de repositorios de origen.
Se necesita tener instalado un JDK para usar Eclipse para el desarrollo Java.

EMPEZANDO A PROGRAMAR EN JAVA UTILIZANDO ECLIPSE.
A finalizar el capítulo 1, se presentan una Práctica de Laboratorio, para descargar eclipse en su
versión kepler, se recomienda desarrollar esta práctica.
Si es que ud. ya tiene la aplicación de eclipse, copiar la carpeta sobre el escritorio y desde allí lo
ejecutaremos.
Ingresar al entorno integrado de Eclipse de la siguiente manera:
Para ingresar a eclipse debe hacer 2 clics en la carpeta eclipse-standard-kepler-SR2-win32, que

debe estar en el escritorio, luego ingresar a la carpeta eclipse, como se ve a continuación:
Ejecutar la aplicación eclipse.

2 clic
Se iniciara eclipse
La primera vez que se inicia el eclipse, este pide que se le confirme en que directorio debe conservar
los proyectos que se creen. Por defecto, esto es una carpeta bajo el directorio mismo en el que se
encuentra el programa.

Elija alguna carpeta en la unidad donde desarrollara sus prácticas, crearemos para nuestras prácticas
EjerciciosED sobre el escritorio. Por defecto el eclipse crea una carpeta “workspace” en su mismo
directorio.
Seleccionamos la carpeta de EjerciciosED que se encuentra sobre el escritorio.
Luego de aceptar nos muestra la siguiente pantalla:

Una vez concluido nos deberá salir el siguiente entorno:

ENTORNO DE ECLIPSE
Tras cerrar el tab de bienvenida, se nos presenta el ambiente de desarrollo, el cual tiene un aspecto
como el mostrado en la siguiente figura:
CREACION DE PROYECTOS EN JAVA ECLIPSE

Hay que tener en cuenta que el entorno de programación "Eclipse" no ha sido desarrollado
pensando en un principiante de la programación. Lo mismo ocurre con el propio lenguaje Java, es
decir su origen no tiene como principio el aprendizaje de la programación.
Antes de poder empezar a trabajar, necesitamos crear un proyecto. Para esto nos vamos al:
Menú / File / New / Project
Tal como se ve en la figura siguiente:

1
2
3
Con esto se nos presenta un cuadro que nos muestra la siguiente pantalla:
Ahora aparece el diálogo donde debemos definir el nombre de nuestro proyecto, en nuestro caso
escribiremos: EjemploProyecto, luego presionamos el botón finish.

1
Al terminar los pasos anteriores, vemos que en la vista “Package Explorer” aparece nuestro
proyecto tal como puede verse en la siguiente figura. Al expandirlo haciendo clic en el signo “+” que
aparece al lado del nombre vemos que ya hay algo adentro. En este caso, están las librerías de
sistema, que no necesitamos conocer en detalle por ahora, por lo que simplemente las ignoraremos.
Además está la carpeta “src” que es la carpeta que contendrá todo el código fuente (todas las
clases). Pero este proyecto, así tal cual, está vacío. No hace nada. Para que haga algo, necesitamos
agregar el código apropiado.

A continuación desarrollaremos una aplicación básica que imprima un mensaje en pantalla.
CREAR PAQUETE
Todo proyecto en java, trabaja con paquetes. Un proyecto puede tener varios paquetes.
Un paquete es un conjunto de clases. Crearemos en este primer ejemplo el paquete Ejercicios

dentro del proyecto EjemploProyecto.
Seleccionar desde Package Explorer / EjemploProyecto / botón derecho / New / Package
2
1
Luego escribimos el nombre del proyecto como se ve a continuación:

1
Luego de esto vemos el paquete:
CREAR CLASE
En java, todo código está contenido al interior de alguna clase. Por lo anterior, si deseamos agregar
alguna funcionalidad o código, primero debemos crear una nueva clase.
Seleccionar EjemploProyecto / paquete ejercicios / botón derecho / new / class

2
1
A continuación le daremos el nombre de la clase Mensajes y habilitamos la cabecera del programa

principal main.
Vemos los cambios que han ocurrido en el Package Explorer

Y el editor de código como siguen:
Un último cambio observable es que la vista “Outline”, que se encuentra a la derecha, se ha

actualizado para mostrarnos el esquema de clases actual. Esta vista será útil cuando tengamos más
clases
AGREGAMOS CODIGO AL PROGRAMA PRINCIPAL

Cambiemos la definición del método main para que muestre un mensaje a través de la ventana de
resultados. Para esto realice estos cambios al programa principal:
Escribimos el siguiente código:

COMO EJECUTAR EL PROGRAMA
Para ejecutar ir al Menu / Run / Run
Otra forma de
ejecutar 1
2
2
2
Nos saldrá el siguiente mensaje al que daremos ok.

1
2
La aplicación será compilada y cualquier error será reportado. Si todo ha salido bien, en la inferior
de la pantalla debiera observar como sigue:
Salida:
COMO ABRIR UN PROYECTO EXISTENTE

Para abrir un proyecto que tenemos en otra unidad o simplemente tenemos que importar de la
siguiente manera:
Ejemplo.- Abriremos un proyecto que se llama SumaDosNumeros.

MENU / FILE / IMPORT /

1
2
2
2
Seleccionar la carpeta General y luego Existing Projects into WorkSpace, como se ve a continuacion:

1
2
2 2clic
2
Luego nos pedirá que busquemos la localización del proyecto:

1
2
En este caso seleccionamos el proyecto que anteriormente se realizo, y este proyecto es

SumaDosNumeros
1
2
2
2

1
2
Luego tenemos el proyecto abierto:

EJERCICIOS RESUELTOS
EJERCICIO 1
Escribir un programa que permita leer dos números y sumar los mismos.
Donde:
A=número entero
B= número entero
C= número entero, es la suma de A y B
Para empezar, una vez iniciado eclipse, debe ir al menú / seleccionar new / luego
seleccionar Project, como se ve en la siguiente pantalla:
Seleccionamos Java Project y luego next como se ve a continuación:

1
2
2
2
CREAR UN PAQUETE
Crearemos el paquete ejersuma.
Seleccionar del explorador de proyecto SumaDosNumeros/ botón derecho/ New /

Package
1
2
2
2
3
2
Escribimos el nombre del paquete ejersuma.

1
2
2
2
CREAR UNA CLASE DENTRO DEL PAQUETE

Como segundo paso veremos que todo programa en Java requiere como mínimo una clase. Para
crear una clase debemos seleccionar desde el menú de opciones:
Seleccionar el paquete ejersuma / botón derecho / new / class
1
2
2
2
3
2
Escribir el nombre de la clase suma y habilitamos la cabecera del programa principal

1
2
2
2
3
2
Luego de presionar el botón "Finish" tenemos el archivo donde podemos codificar nuestro primer
programa:

Todo programa en Java debe definir la función main. Esta función la debemos codificar dentro de la
clase: "Suma".
Procedemos a escribir el siguiente código:
El código del programa anterior es:

package ejersuma;
import java.util.Scanner;
public class Suma
{
public static void main(String[] args)

{
int a,b,c; //declaracion de variables locales
Scanner x=new Scanner(System.in);
System.out.print("Ingrese el primer numero...");

a=x.nextInt();
System.out.print("Ingrese el segundo numero...");
b=x.nextInt();
c=a+b;
System.out.println("La suma es "+c);
EJECUTAR EL PROGRAMA:
Para ejecutar cualquier programa realizar de la siguiente manera:
Menu / Run / Run
1
2
2
2
Si no hay errores de codificación debemos ver el resultado de la ejecución en una ventana del
Eclipse llamada "Console" que aparece en la parte inferior (puede aparecer un diálogo pidiendo
que grabemos el archivo, el cual confirmamos.

Salida:
EJERCICIO 2.
Escribir un programa para calcular el área de un círculo, dado el radio por el usuario.
𝐴 = 𝜋 ∗ 𝑟2
Donde:
A= Área del circulo y es de tipo doublé
r= radio del círculo, también es de tipo doublé.
CREAR LA CLASE AREACIRCULO EN EL PAQUETE EJERSUMA

Seleccionar el paquete ejersuma / botón derecho/ new / class

Escribimos el nombre de la clase: AreaCirculo, como vemos a continuación:

El código del programa es el siguiente:
package ejersuma;
public class AreaCirculo {
public static void main(String[] args) {

double r,A;
Scanner x=new Scanner (System.in);
System.out.println("ingrese el radio...");
r=x.nextDouble();
A=Math.PI *r*r;
System.out.printf("el area del circulo es %.2f",A);
}
}
EJECUTAMOS EL PROGRAMA
Ejercicios propuestos
1. Realizar la carga del lado de un cuadrado, mostrar por pantalla el perímetro del mismo (El
perímetro de un cuadrado se calcula multiplicando el valor del lado por cuatro)
2. Escribir un programa en el cual se ingresen cuatro números, calcular e informar la suma de
los dos primeros y el producto del tercero y el cuarto.
3. Realizar un programa que lea cuatro valores numéricos e informar su suma y promedio.
4. Se debe desarrollar un programa que pida el ingreso del precio de un artículo y la cantidad
que lleva el cliente. Mostrar lo que debe abonar el comprador.

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.
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
programas y representar las diferentes estructuras de datos el Lenguaje 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] ; A= 20 30 40 50 60
A = {20,30,40,50,60};
Identificador
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.
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.
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

ESTUDIANTE
Nombre del TAD
Ru: entero
Nombre: Cadena
Sexo: carácter
Elementos Direccion: Cadena
LeerDatosEstudiante ()
Operaciones
ImprimirDatosEstudiante ()
ModificarDireccion()
o métodos
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.
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
- 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.

- 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.
- 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.
- 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
ESTRUCTURAS DE DATOS ESTÁTICAS
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
Indices
i0 i1 … iN
Componentes: Hacen referencia a los elementos que forman el arreglo.
Índices: Permiten referirse a los componentes del arreglo en forma individual.
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.
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
{
public static void main (String arg [])
{
int losValores [];
losValores = new int [10];
losValores [0] = 100;
System.out.println (losValores [0]);
}
}
El programa: Array, trabaja con el vector losValores, que almacena un máximo de 10 elementos
enteros.
IMPLEMENTACIÓN DEL TIPO DE DATO ABSTRACTO VECTOR
En este ejemplo se diseña el tipo de dato abstracto vector que maneja números enteros.
Vector
V[15]: Entero
N: Entero
leedim():void
leervector():void
mostrarvector(): void
main():void
A continuación se muestra la implementación de este TAD en Java.
package tema1;
public class Vector

{
static int v[]; //declara vector de enteros
static int n; // tamaño del vector
static Scanner sc=new Scanner(System.in);

//procedimiento para leer la dimension del vector
static void leedim ()
{
System.out.print ("Cuantos elementos insertara en el Vector? ");
n = sc.nextInt();
v=new int[n]; // crea el vector de tamaño n
}
//Procedimiento para leer los elementos en el vector

static void leervector ()
{ int i;
for(i=0; i < n; i++)

{ System.out.print("Ingrese elemento "+ i + " = ");
v[i] = sc.nextInt();
}
}
//Procedimiento para imprimir el vector

static void mostrarvector ()
{ int i;
System.out.println();
for(i=0; i < n; i++)
{ System.out.print(v[i] + " ");
}
}
//programa principal
public static void main (String [] args)
{
leedim (); // llama al procedimiento para leer la dimensión del vector
leervector(); //llamada a LeerVector para llenar los datos en el vector
mostrarvector(); //llamada a mostrarvector para imprimir el
vector
}
Salida:

Ejercicios Resueltos
1. Escribir un programa para leer tres vectores de la misma dimensión y crear un nuevo arreglo
con la suma de los elementos de cada vector.
2 3 6 2
7 2 1 1
3 1 2 3
La suma de los elementos del:

Primer vector es: 2 + 3 + 6 + 2 = 13
Segundo vector es: 7 + 2 + 1 + 1 = 11
Tercer vector es: 3 + 1 + 2 + 3 = 9
Diseñamos la estructura de datos, para resolver el ejercicio.

SumaVectores
V1[]:int
V2[]:int
V3[]:int
vecNuevo[]:int
d:int
LeerE():void
ImprimirE():void
EsVaron():boolean
package tema1;
/*Se deben crear tres vectores v1, v2,v3 y vecNuevo de m elementos cada uno;
se debe crear otro arreglo vecNuevo donde cada elemento sea la suma de los
elementos de cada arreglo. */
public class SumaVectores

{
static int[] v1, v2, v3, vecNuevo;
static int d; /* DIMENSION DE LOS VECTORES*/
public static void main (String arg[])
{
System.out.print ("Qué dimension tendran los vectores?.... ");

d = sc.nextInt();
v1 = new int [d];

v2 = new int [d];
v3 = new int [d];
vecNuevo = new int [3];
llenarVector (v1);
llenarVector (v2);
llenarVector (v3);
vecNuevo [0] = sumaVector (v1);

mostrarVector (vecNuevo, 3);
}
/* FUNCION QUE SUMA LOS ELEMENTOS DE UN VECTOR, COMO TODOS LOS VECTORES
QUE SE VA SUMAR TIENEN LA MISMA DIMENSION, NO SE NECESITA TENERLA COMO PARAMETRO
*/
static int sumaVector (int v[])

{
int acum = 0;
for (int i = 0 ; i < d ; i++)
{
acum = acum + v [i];
}
return acum;
}
/* FUNCION QUE ASIGNA VALORES A UN VECTOR DE DIMENSION D */
static void llenarVector (int v[])

{
System.out.println ("\n\n*********LLENAR EL VECTOR********\n");
for (int i = 0 ; i < d ; i++)
{
System.out.print ("Introduzca el numero de la posicion " + i + "
");
v [i] = sc.nextInt();
}
}
/* PROCEDIMIENTO QUE MUESTRA LOS ELEMENTOS DE UN VECTOR CUALQUIERA

CON DIMENSION CUALQUIERA,EL VECTOR ES EL PARAMETRO V Y LA DIMENSION
DEL VECTOR X , SE PENSÓ ASI PARA PODER UTILIZARLO EN EL VECTOR RESULTADO
*/
static void mostrarVector (int v[], int x)

{
System.out.println ("\n Imprimiendo el vector de SUMA de elementos de
los vectores....\n");

for (int i = 0 ; i < x ; i++)
{
System.out.print (v [i] + " ");
}
}
}
Salida:
2. Escribir un programa para registrar en un vector los carnets de los estudiantes que
aprobaron Calculo I y en otro vector registrar los carnets de los estudiantes que aprobaron
Etica, y en un tercer vector los carnets de los que aprobaron ambas materias.
Diseñamos la estructura de datos, para resolver el ejercicio.

CompararVectores
vCalculo[]:int
vEtica[]:int
vambas[]:int
d:int
llenarNuevo():void
cuantosComunes():int
buscaNum():boolean
llenarVector():void
mostrarVector():void
main()
package tema1;
public class comparaVectores {
static int[] vCalculo, vEtica, vComun;


{
int nCal, nEt, comunes;
System.out.print ("Cuantos alumnos aprobaron CALCULO I?... ");

nCal = sc.nextInt();
System.out.print ("Cuantos alumnos aprobaron ETICA ?... ");
nEt = sc.nextInt();
vCalculo = new int [nCal];

vEtica = new int [nEt];
System.out.println ("\n Carnets de los alumnos que aprobaron CALCULO I \n ");

llenarVector (vCalculo, nCal);
System.out.println ("\n Carnets de los alumnos que aprobaron ETICA \n ");
llenarVector (vEtica, nEt);
comunes = (cuantosComunes (nCal, nEt));
vComun = new int [comunes];
llenarNuevo (nCal, nEt);
System.out.println ("\nCarnets de los alumnos que aprobaron ETICA Y CALCULO I \n
");
mostrarVector (vComun, comunes);
}
static void llenarNuevo (int d, int d2)
{
int pos = 0;
for (int i = 0 ; i < d ; i++)
{
if (buscaNum (vCalculo [i], d2) == true)
{
vComun [pos] = vCalculo [i];
pos++;
}
}
}
/* ME DICE CUANTOS CARNETS ESTAN EN AMBOS VECTORES.
TIENE 2 PARAMETROS: d: ES LA DIMENSION DE vCalculo,
d2: DIMENSION DE vEtica. BUSCA CADA ELEMENTO DE vCalculo en vEtica */
static int cuantosComunes (int d, int d2)

{
int acum = 0;
for (int i = 0 ; i < d ; i++)
{
if (buscaNum (vCalculo [i], d2) == true)
acum++;
}
return acum;
}
/* ESTE METODO INDICA SI UN NUMERO n ESTA EN EL VECTOR vEtica.

ADEMAS DE n, TIENE UN PARAMETRO d, QUE ES LA DIMENSION DE vEtica,
NECESARIA PARA CONTROLAR EL FOR */
static boolean buscaNum (int n, int d)

{
for (int i = 0 ; i < d ; i++)
{
if (vEtica [i] == n)
return true;
}
return false;
}
/* METODO QUE ASIGNA VALORES A UN VECTOR DE DIMENSION D */

static void llenarVector (int v[], int d)
{
for (int i = 0 ; i < d ; i++)
{
System.out.print ("Introduzca el CI del alumno " + i + " ....");
v [i] = sc.nextInt ();
}
}

/* ESTE METODO MUESTRA LOS ELEMENTOS DE UN VECTOR CUALQUIERA CON DIMENSION
CUALQUIERA,EL VECTOR ES EL PARAMETRO V Y LA DIMENSION DEL VECTOR X , SE PENSÓ
ASI PARA PODER UTILIZARLO EN EL VECTOR RESULTADO */
static void mostrarVector (int v[], int x)

{
for (int i = 0 ; i < x ; i++)
{
}
}
}
Salida
3. El siguiente programa es una prueba del uso de vectores con parámetros.
VectoresConParametros
V1[]:int
Imprime():void
Suma1():int
main()
Implementando en java tenemos:

package tema1;
public class vectoresConParametros {

static int[] v1 = new int [10];
public static void main (String[] args)

{
int[] v2, v3;
for (int i = 0 ; i < 10 ; i++)

v1 [i] = 1;
v2 = v1;
Imprime (v2);
v3 = Suma1 (v2);
Imprime (v1);
Imprime (v3);
}
static void Imprime (int[] elV)

{
for (int i = 0 ; i < 10 ; i++)
System.out.print (elV [i]);
System.out.println ();
}
static int[] Suma1 (int[] elV)

{
for (int i = 0 ; i < 10 ; i++)
elV [i]++;
return elV;
}
}
Salida:
4. Programa para leer dos vectores ordenados de diferentes dimensiones y crear un tercer
vector con los elementos ordenados de ambos vectores.
Diseñamos la estructura de datos
VectoresOrdenados
V1[]:int
llenarVector():void
ordenaVector():int
mostrarVector():void
main()
Implementando en java tenemos:
package tema1;
public class VectoresOrdenados {
public static void main (String args[])

{
int vec1[], vec2[], vecR[];
int n, m, nm;
System.out.print ("Cuantos elementos tiene el vector 1? ");
n = sc.nextInt();
System.out.print ("Cuantos elementos tiene el vector 2? ");
m = sc.nextInt();
nm = n + m;
// crear los vectores

vec1 = new int [n];
vec2 = new int [m];
vecR = new int [nm];
// LLenar los vectores 1 y 2
System.out.println ("****Lectura Primer vector ordenado****");

llenarVector (vec1, n);
System.out.println ("****Lectura Segundo vector ordenado****");
llenarVector (vec2, m);
// Crear vector resultante ordenado
vecR = ordenaVector (vec1, vec2, n, m);
// Mostrar vector resultante
System.out.println ("**** vector resultante ordenado****");
mostrarVector (vecR, nm);
}
/**Metodo que permite llenar un vector conociendo su dimension**/

static void llenarVector (int v[], int dim)
{
for (int i = 0 ; i < dim ; i++)
{
System.out.print ("v[" + i + "]= ");
v [i] = sc.nextInt ();
}
}
/**crea un vector ordenado a partir de dos vectores ordenados
* recibidos como parámetro **/
static int[] ordenaVector (int v1[], int v2[], int dim1, int dim2)
{
int vr[];
vr = new int [dim1 + dim2];
int i = 0; // variable para controlar el indice del primer vector
int j = 0; // variable para controlar el indice del segundo vector
int k = 0; // variable para controlar el indice del vector resultante
while ((i < dim1) && (j < dim2))
{
if (v1 [i] < v2 [j])
{
vr [k] = v1 [i];
k++;
i++;
}
else
{
if (v2 [j] < v1 [i])
{
vr [k] = v2 [j];
k++;
j++;
}
else
{
vr [k] = v1 [i];
k++;
i++;
j++;
}
}
} // fin del while
if (i == dim1)
{
for (int p = j ; p < dim2 ; p++)
{
vr [k] = v2 [p];
k++;
}
}
else
{
for (int p = i ; p < dim1 ; p++)
{
vr [k] = v1 [p];
k++;
}
}
return vr;
}

static void mostrarVector (int v[], int dim)
{
for (int i = 0 ; i < dim ; i++)
{
System.out.println ("v[" + i + "]= " + v [i]);
}
}
} // fin de la clase
Salida:
EJERCICIOS PROPUESTOS
1. Realizar un programa que permita leer en un vector N números enteros y luego, contar cuantos
elementos positivos y negativos existen.
2. Eliminar el primer elemento x, dado por el usuario que se encuentre en el vector de números
enteros de tamaño N.
3. 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 COSECHA
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 COSECHA COSTO BS
1 15 60
2 75 300
3 23 92
4 55 220
5 85 340
6 13 52
TOTAL GANADO 1064 BS
4. Realice un programa que elimine elementos duplicados de un vector.
A= 4 2 4 4 7 7
1 2 3 4 5 6
Eliminando los duplicados queda:
A= 4 2 7
1 2 3
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 jugo
para comer
A= 100 500 600 0 800 300 … 500 350
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.
CADENAS EN JAVA
La clase String tiene varios métodos muy útiles como saber su longitud, trocear la cadena, etc.
Recuerda que para invocar un método debemos escribir el nombre del String, un punto y el nombre
del método, más sus parámetros. Es importante que si necesitas almacenar el valor devuelto, uses
una variable para ello.
Por ejemplo:
String cadena=”americano”;
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
1. Contar el número de palabras que hay en una cadena, las palabras están separadas por
un espacio en blanco.
Diseñamos la estructura de la aplicacion
ContarPalabras
contar(): entero
main()
Implementando el programa en java:
package cadenas;
public class ContarPalabras {

{
String cad = new String ("");
char blanco = ' ';
int cuantos = 0;
System.out.print ("deme la cadena ");
cad = sc.nextLine();
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
}
}
Salida:
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
Reemplazar
reemplazar():String
main()

package cadenas;
public class Reemplazar {


{
String cad = new String (""); // cadena a revisar
char c; // caracter a buscar
String nueva = new String ("");
System.out.print ("deme la cadena….. ");
System.out.print ("Deme el caracter ….");
c = sc.next().charAt(0);
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
}
}
Salida
3. programa que pretende suprimir todos los espacios en blanco de una cadena cad. El resultado
queda en otra cadena.
Diseñamos el TAD:
suprimir
suprime():String
main()
Implementando en java:
package cadenas;
public class SuprimirEspacios

{
{
String cad = new String ("");
char blanco = ' ';
String nueva = new String ("");
System.out.print ("dame la 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;
}
}

Salida:
4. Programa que sirve para contar cuántas vocales tiene una palabra o frase.
Diseñamos el TAD
ContarVocales
contar():void
main()
package cadenas;
public class ContarVocales {
{
String palabra;
System.out.print("Dame una palabra o una frase ");
palabra = sc.next();
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");
}
}

Salida:
5. Escribir una aplicación para generar un código a partir del nombre, paterno, materno, dia,
mes y año de los datos del usuario.
Diseñamos el TAD
GenerarCodigo
Nombre: String
Paterno:String
Materno:String
Dia:
Generar():String
main()
package cadenas;
public class GenerarCodigo {

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 = sc.next();
System.out.print ("Cual es tu Apellido paterno....");
paterno = sc.next();
System.out.print ("Cual es tu Apellido Materno....");

materno = sc.next();
do
{ System.out.print ("Dia de nacimiento....");
dia = sc.nextInt();
}
while (dia > 31 || dia < 1);
do
{
System.out.print ("Mes de nacimiento...");
mes = sc.nextInt();
}
while (mes > 13 || mes < 1);
System.out.print ("Año de nacimiento...");
anio = sc.nextInt();
Micodigo=Generar(Nombre,paterno,materno,dia,mes,anio);
System.out.println("El codigo es...."+Micodigo);
}
}
Salida:
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.
5. Escribe una clase en Java llamado Oraciones.java que contenga varias operaciones
para crear/manipular cadenas de caracteres.
 Genere números aleatorios para crear oraciones.
static void imprimeOraciones(int totalOraciones)
 Sustituya una palabra por otra dentro de una cadena de caracteres. Si no encuentra
la palabra a sustituir en la cadena original, ésta no cambiará.
static String cambiaCadena(String, String, String)
 Elimine todas las ocurrencias de una palabra dentro de una cadena de caracteres. Si
no encuentra la palabra a eliminar en la cadena original, ésta no cambiará.
static String eliminaPalabra(String, String)
 Encuentre una palabra y la convierta toda a MAYÚSCULAS.

static String cambiaCadenaMayusculas(String, String)
 Encuentre una palabra y, si es un número, imprima la palabra de ese número (Ej. 1 =

“uno”, 2 = “dos” y así, sucesivamente ).
static String cambiaANumeros(String)
Nota: el esqueleto de la clase (Oraciones.java) en la que vas a agregar los métodos estáticos que se
te solicitan, es la siguiente, además, debes completar el método main
import java.util.Random;
public class Oraciones

{
public static void imprimeOraciones(int total)
{
String[] articulo={"el","la","nungun","algun","un","una"};
String[] nombre={"hombre","perro","ninio","doctor","auto"};
String[] verbo={"manejo","solto","corrio","camino","brinco"};
String[] preposicion={"a","desde","sobre","con","en","de","hacia"};
Random rnd = new Random();
}
public static String cambiaCadena(String str, String pal1, String pal2)

{
return null;
}
public static String eliminaPalabra(String str, String pal)

{
return null;
}
public static String cambiaCadenaMayusculas(String str, String pal)

{
return null;
}
public static String cambiaANumeros(String str)

{
return null;
}
public static void main(String args[])

{
Scanner entrada = new Scanner(System.in);
String pal;
char letra;
// Probando la generación aleatoria de oraciones

// AGREGAR CÓDIGO FALTANTE PARA PROBAR imprimeOraciones
// Probando la sustitución de una palabra por otra
// ESTA PRUEBA YA ESTÁ COMPLETA
System.out.print("\nLa palabra a cambiar es: luna ");

System.out.println("\nLa cadena modificada es: " +
eliminaPalabra(str2, "luna"));
// Probando la sustitución de todas las ocurrencias de una palabra
por la palabra en MAYUSCULAS
System.out.println("\n\n*** Probando la sustitucion de TODAS las
ocurrencias de una palabra por mayusculas *** \n");
str2 = "Hola mundo como esta todo el mundo, como vemos el dia de
hoy en el mundo";
System.out.println("\nLa oracion es: " + str2);
System.out.print("\nLa palabra a sustituir es: mundo ");

cambiaCadenaMayusculas(str2, "mundo"));
System.out.println("\n\n*** Probando la sustitucion de TODAS las
ocurrencias de una palabra (que NO existe) por mayusculas ***
\n");
hoy en el mundo";

cambiaCadenaMayusculas(str2, "luna"));
// Probando la sustitución de todas las ocurrencias de digitos por
palabras
System.out.println("\n\n*** Probando la sustitucion de digitos

por palabras *** \n");
str2 = "Hola mundo 123 como esta 4 todo 5667 el mundo, 98 como
vemos el dia 053 de hoy en el mundo";

cambiaANumeros(str2));
System.out.println("\n\n*** Probando la sustitucion de una palabra
por otra *** \n");
String str2 = "Hola mundo como esta el mundo de bien o mal del mundo";
System.out.print("\nLa palabra a cambiar es: mundo ");
System.out.print("\nLa palabra por la cual va a cambiar es: auto");

cambiaCadena(str2, "mundo", "auto"));
System.out.println("\n\n*** Probando la sustitucion de una

palabra (que NO existe) por otra *** \n");
str2 = "Hola mundo como esta el mundo de bien o mal del mundo";
System.out.print("\nLa palabra por la cual va a cambiar es:

marte");

cambiaCadena(str2, "luna", "marte"));
// Probando la eliminación de todas las ocurrencias de una palabra

System.out.println("\n\n*** Probando la eliminacion de TODAS las

ocurrencias de una palabra *** \n");
hoy en el mundo";
System.out.print("\nLa palabra a eliminar es: mundo ");

eliminaPalabra(str2, "mundo"));
System.out.println("\n\n*** Probando la eliminacion de TODAS las

ocurrencias de una palabra (que NO existe) *** \n");
hoy en el mundo";
System.out.println("\n\n*** Probando la sustitucion de digitos

(que NO existen) por palabras *** \n");
hoy en el mundo";

cambiaANumeros(str2));
System.out.println("\n\n");
}
}
ESPECIFICACIÓN DETALLADA DE LAS OPERACIONES SOLICITADAS PREVIAMENTE
imprimeOraciones

En el método principal, main, se invoca a un método estático llamado imprimeOraciones que
reciba el total de oraciones a generar.
El total de oraciones a generar lo proporciona el usuario en el main. DEBES validar, dentro de un

try – catch que la petición de datos se continúe hasta que el usuario de un número menor o igual a
CERO.
Dentro del método imprimeOraciones deberás generar e imprimir las oraciones según se explica a
continuación:
 Deberás utilizar los cuatro arreglos locales de Strings llamados: Artículo, Sujeto, Verbo y
Preposición.
 El programa creará una oración seleccionando, aleatoriamente, una palabra de cada arreglo
en el siguiente orden: artículo, sujeto, verbo, preposición, artículo y sujeto.
 Las palabras deberán estar separadas por un espacio en blanco.
 Cuando se despliegue la oración formada, la primera letra deberá desplegarse en
mayúscula, y la última palabra deberá terminar con un punto.
Nota: Las oraciones no necesariamente deben tener un significado en español.
Ejemplo de salida

cambiaCadena
El método estático llamado cambiaCadena recibe una cadena y dos palabras. Dicho método
sustituye todas las ocurrencias de la primera palabra por la segunda palabra en la cadena. Regresa
la cadena resultante.
En caso de que no se encuentre la primera palabra NO deberá realizar ningún cambio en la cadena
y ésta quedará igual.
Puedes utilizar StringBuilder y “jugar” entre substring, indexOf y/o lastIndexOf, append o similares.
NO podrás utilizar los métodos, replace, replaceAll, replaceFirst, delete, split o similares de la clase
String.
CambiaCadena
Suponiendo que probamos este método primero cambiando “mundo” por “auto” y luego, en otra
corrida, cambiamos “luna” por “marte” se deberá obtener una salida IDÉNTICA a la siguiente:
EliminaPalabra
 El método estático llamado eliminaPalabra recibe una cadena y una palabra. Dicho
método elimina todas las ocurrencias de la palabra que se encuentran dentro de la
cadena. Regresa la cadena resultante.
 En caso de que no se encuentre la palabra a eliminar en la cadena, NO deberá realizar

ningún cambio y la cadena quedará igual.

 NO podrás utilizar los métodos, replace, replaceAll, replaceFirst, delete, split o
similares de la clase String.
eliminaPalabra
Suponiendo que la palabra a eliminar es “mundo” y, en una segunda corrida “luna”, el método
eliminaPalabra deberá obtener una salida IDÉNTICA a la siguiente:
cambiaCadenaMayusculas
El método estático llamado cambiaCadenaMayusculas recibe una cadena y una palabra. Dicho
método sustituye todas las ocurrencias de la palabra por la misma palabra en MAYÚSCULAS.
Regresa la cadena resultante.
En caso de que no se encuentre la palabra NO deberá realizar ningún cambio en la cadena y ésta
quedará igual.
String.
cambiaANumeros
El método estático llamado cambiaANumeros recibe una cadena. Dicho método sustituye todos los
dígitos de la cadena por su correspondiente palabra. Regresa la cadena resultante.
En caso de que no se encuentre algún dígito NO deberá realizar ningún cambio en la cadena y ésta
quedará igual.

String.
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.
ARREGLOS BIDIMENSIONALES (MATRICES)
La matriz es una estructura de datos básica dentro de los lenguajes de programación y

conceptualmente son idénticas a sus homónimas matemáticas. Por tanto una matriz es un conjunto
de datos de un tamaño definido que se encuentran consecutivos en memoria y en la que es posible
el acceso al elemento que deseemos simplemente con indicar su posición.
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.
columnas
0 1
0 3 5
filas 1 8 2
2 6 1
DECLARACION Y CREACION DE UNA MATRIZ EN JAVA
La sintaxis para declarar una matriz es la siguiente:
tipo nombre_de_Matriz [][];

Donde:
 Tipo: puede ser cualquier tipo de dato (int, float, char, etc.) incluyendo un tipo de dato
definido por el usuario.
 nombre_de_Matriz es el nombre de la matriz.

La sintaxis para crear la matriz es la siguiente:
nombre_de_Matriz = new tipo [nro_filas][nro_columnas];
INICIALIZACION DE UNA MATRIZ
Java permite inicializar matrices en el momento de su declaración.
Ejemplo:
Declaramos e inicializamos una matriz con los siguientes datos:
3 6 0
( )
2 5 9
int A[][]={{3,6,0},{2,5,9}};
Cabe aclarar que el primer elemento de la matriz siempre ocupa la fila 0 y la columna 0.
OPERACIONES CON ARREGLOS BIDIMENSIONALES
Las operaciones que pueden realizarse con arreglos bidimensionales son las siguientes:
 Lectura/escritura
 Asignación
 Actualización: Inserción
 Eliminación
 Modificación
 Ordenación
 Búsqueda
En general los arreglos bidimensionales son una generalización de los unidimensionales, por lo que
se realizará un ejemplo con algunas de estas operaciones a continuación.
Ejemplo:
Escribir un programa para leer una matriz de elementos enteros, de f filas y c columnas. Por
ejemplo la siguiente matriz es de 3 filas y 2 columnas.
𝟎 𝟑 𝟏
𝟏 (𝟕 𝟔)
𝟐 𝟒 𝟗
Diseñamos la estructura de datos de la aplicación:

LeerImprimirMatriz
A[M][N] : int
M: int
N: int
i: int
j: int
leerMatriz():void
imprimirMatriz():void
main()
Donde:
A[][]: es la matriz de M filas y N columnas, sus elementos son enteros.
M: número de filas de la matriz
N: número de columnas de la matriz.
i: subíndice de filas 0..M-1
j: subíndice de columnas 0..N-1
package matrices;
public class LeerImprimirMatriz {

static int A[] [] ;
static int M, N;
static Scanner sc=new Scanner(System.in) ;
static void leerMatriz ()

{
System.out.println ("******REGISTRO DE MATRIZ ******");
System.out.print ("Ingrese el numero de filas de la matriz......");
M = sc.nextInt();
System.out.print ("Ingrese el numero de columnas de la matriz....");
N = sc.nextInt();
A=new int[M][N] ;
for (int i = 0 ; i < M ; i++)
for (int j = 0 ; j < N ; j++)
{
System.out.print ("Ingrese elemento (" + i + "," + j + ")....");

A [i] [j] = sc.nextInt();
}
}
static void imprimir ()

{
System.out.println (".......IMPRIMIENDO LA MATRIZ.....");
for (int i = 0 ; i < M ; i++)
{
for (int j = 0 ; j < N ; j++)
{
System.out.print (A [i] [j] + " ");
}
}
}

{
leerMatriz ();
imprimir ();
}
}
Salida:
1. Leer una matriz cuadrada e imprimirla; también mostrar la suma de las filas, la suma de las
columnas, de la diagonal principal y de la diagonal secundaria.

Ejemplo: sea una matriz cuadras de 3 filas y 3 columnas
𝟓 𝟔 𝟏 Diagonal principal
Diagonal secundaria (𝟗 𝟎 𝟑)
𝟕 𝟒 𝟓
La suma de la fila 0 : 5 + 6 + 1 = 12
La suma de la fila 1: 9 + 0 + 3 = 12
La suma de la fila 2: 7 + 4 + 5 = 16
La suma de la columna 0: 5 + 9 + 7 = 21
La suma de la diagonal principal: 5 + 0 + 5 = 10

La suma de la diagonal secundaria: 1 + 0 + 7 = 8
El programa en java será el siguiente:
package matrices;
public class SumaFilCol {

{ int tam, sumd,sumars;
int m[][];
System.out.println ("Dame el tamaño de la matriz ");
tam = sc.nextInt ();
m= new int [tam][tam];
Llenar (m, tam);

Imprimirmat (m, tam);
Sumarf (m, tam);
Sumarc (m, tam);
sumd = Sumarp (m, tam);
sumars = Sumards (m, tam);
System.out.println ("La suma de las diagonales son " + sumd + " de la
diagonal principal ");
System.out.println ("de la diagonal secundaria " + sumars);
}
static void Llenar (int ma[] [], int t)

{
System.out.println ("Dame los valores de la matriz");

for (int i = 0 ; i < t ; i++)
for (int j = 0 ; j < t ; j++)
{
ma [i] [j] = sc.nextInt ();
}
}
static void Imprimirmat (int m[] [], int t)

{
System.out.println ("La matriz queda");
for (int i = 0 ; i < t ; i++)
{
for (int j = 0 ; j < t ; j++)

{
System.out.print (m [i] [j] + " ");
}
}
}
static void Sumarf (int ma[] [], int t) //Sumar por filas
{
int acum = 0;
int v[] = new int [t];
for (int i = 0 ; i < t ; i++)

{
for (int j = 0 ; j < t ; j++)
{
acum += ma [i] [j];
}
v [i] = acum;
acum = 0;
}
System.out.println ("El resultado de sumar las filas es ");
Imprimir (v, t);
}
static void Sumarc (int ma[] [], int t) // Sumar por columnas
{
int acum = 0;
int v[] = new int [t];
for (int j = 0 ; j < t ; j++)

{
for (int i = 0 ; i < t ; i++)
{
acum += ma [i] [j];
}
v [j] = acum;
acum = 0;

}
System.out.println ("El resultado de sumar las columnas es ");
Imprimir (v, t);
}
static int Sumarp (int m[] [], int t) // Suma de la diagonal principal
{
int acum = 0;
for (int i = 0 ; i < t ; i++)
{
acum += m [i] [i];
}
return acum;
}
static int Sumards (int m[] [], int t) //Suma de la diagonal secundaria
{
int acum = 0;
int h = t;
for (int i = 0 ; i < t ; i++)
{
--h;
acum += m [i] [h];
}
return acum;
}
static void Imprimir (int v[], int t)

{
for (int i = 0 ; i < t ; i++)
{
}
}
}
Salida:

EJERCICIOS PROPUESTOS DE MATRICES
1. Llenar una matriz triangular superior.
Ej.
2 3 4 4
0 3 7 2
0 0 8 9
0 0 0 3
2. Crear una aplicación que imprima la siguiente matriz para m filas y n columnas
11 12 13 14 15
21 22 23 24 25
31 32 33 34 35
3. 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.
4. Escriba un programa que asigne valores a A, a partir de B teniendo en cuenta los

siguientes criterios:
i. Aij = (bi) si i <= j
ii. Aij = 0 si i >j
5. 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 pares e impares
b. Hallar la suma de los elementos de la diagonal secundaria
c. Dado la fila y la columna por el usuario, devuelva el elemento que corresponda a
esa posición
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 Edad Sexo Atiguedad

Rosa Flores Vargas Sopocachi 19 F 3
Maria Quispe Michel Miraflores 20 F 5
Ariel Candia Martinez Miraflores 19 M 2
Si se quisiera almacenar estos datos no sería posible usar un arreglo, ya que sus componentes deben
ser todos del mismo tipo.
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.
DECLARACION DE VARIABLE DE REGISTRO
En java la sintaxis es:
Registro VariableRegistro;
COMO CREAR UNA VARIABLE DE REGISTRO

Para crear, la sintaxis en java es la siguiente:
VariableRegistro = new Registro();
COMO ACCEDER A LAS OPERACIONES DE UN REGISTRO

Para acceder a las operaciones del registro utilizamos la siguiente sintaxis en java:
VariableRegistro.Operacion();
Ejemplo de Registro:
Representamos gráficamente el registro de un empleado, con sus cinco campos que son: CI,
Nombre, género y sueldo.
CI Nombre Genero Cargo sueldo
Registro: EMPLEADO
Se pide como operaciones (funciones) de la estructura del registro de empleado:
 Leer los datos del empleado……………………………………... LeerE()

 Imprimir en una fila los datos del empleado ………………ImprimirE()
 Verificar si el empleado es del sexo masculino……………EsVaron()
Diseñamos ahora la estructura del registro, mediante la siguiente notación, que contiene
los datos y sus operaciones:

EMPLEADO
CI: int
Nombre: String
Genero: char
Cargo: String
sueldo: float
LeerE():void
ImprimirE():void
EsVaron():boolean
Implementamos en java esta estructura de datos para el empleado, como se ve a

continuación:
package registros;
public class Empleado {
private long ci;

private String Nombre;
private char genero;
private String cargo;
private float sueldo;
Scanner sc=new Scanner(System.in);

void leerE()
{
System.out.print("Ingrese ci..");
ci=sc.nextLong();
System.out.print("Ingrese Nombre..");
Nombre=sc.next();
System.out.print("Ingrese genero..");
genero=sc.next().charAt(0);
System.out.print("Ingrese cargo..");
cargo=sc.next();
System.out.print("Ingrese sueldo..");
sueldo=sc.nextFloat();
void imprimirE()
{
System.out.print(+ci+", "+Nombre+", "+genero+", "+cargo+",
"+sueldo);
boolean EsVaron()

{
if (genero=='m')
return true;
else
return false;
}
}
Escribimos una aplicación en java para utilizar este registro, almacenamos e imprimimos a un
empleado y también verificamos si es varón:
package registros;
public class AppEmpleado {

{
Empleado E;
E = new Empleado ();
E.leerE ();
E.imprimirE ();
if (E.EsVaron())
System.out.println("Empleado es varon");
else
System.out.println("Empleado es mujer");
}
Salida:
REGISTROS ANIDADOS
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:
A los datos del empleado, del ejemplo anterior, añadir dos campos: fecha de nacimiento y fecha de
ingreso a la empresa. Pero ambas fechas tienen: día, mes año.
Entonces el campo fecha, será un registro con tres campos: día, mes y año, luego tendremos lo
siguiente:
Dia Mes anio
Registro: Fecha
Escribimos el programa para el registro Fecha en java, como se presenta a continuación:
FECHA
Dia: int
Mes:int
Anio:int
leerFecha():void
imprimirFecha():void
Escribimos el programa del Registro Fecha:
package registros;
public class Fecha {

private int dia,mes, anio;
void leerFecha()
{
System.out.print("ingrese dia...");
dia=sc.nextInt();
System.out.print("ingrese mes...");
mes=sc.nextInt();
System.out.print("ingrese año...");
anio=sc.nextInt();
}
void imprimirFecha()
{
System.out.print(", "+dia+", "+mes+", "+anio+" ");
}

Luego este registro los incluimos en el registro del empleado, como se ve a continuación: Registro
anidado
CI Nombre Genero Cargo Sueldo fechaNac FechaIng
dia mes anio Dia Mes anio
Registro: Empleado
Ahora modificamos la estructura del registro del empleado añadiendo los dos campos de fecha de
ingreso y fecha de nacimiento del empleado:
EMPLEADO
CI: int
Nombre: String
Genero: char
Cargo: String
sueldo: float
fechaNac:Fecha
fechaIng:Fecha
LeerE():void
ImprimirE():void
EsVaron():boolean
El programa modificado del Registro del Empleado es el siguiente:

package registros;
public class Empleado {
private long ci;

private String Nombre;
Se hace referencia al registro Fecha, es un
private char genero;
registro anidado
private String cargo;
private float sueldo;
private Fecha fechaNac;
private Fecha fecha Ing;

void leerE()
{
System.out.print("Ingrese ci..");
ci=sc.nextLong();
System.out.print("Ingrese Nombre..");
Nombre=sc.next();
System.out.print("Ingrese genero..");
genero=sc.next().charAt(0);
System.out.print("Ingrese cargo..");
cargo=sc.next();
System.out.print("Ingrese sueldo..");
sueldo=sc.nextFloat();
System.out.println("Ingrese Fecha de Naciemiento:");
fechaNac=new Fecha();
fechaNac.leerFecha();
System.out.println("Ingrese Fecha de Ingreso:");
fechaIng=new Fecha();
fechaIng.leerFecha();
}
void imprimirE()
{
System.out.print(+ci+", "+Nombre+", "+genero+", "+cargo+",
"+sueldo);
fechaIng.imprimirFecha();
fechaNac.imprimirFecha();
boolean EsVaron()
{
if (genero=='m')
return true;
else
return false;
}
}
Ejecutamos nuevamente la aplicación AppEmpleado y nos mostrara el siguiente resultado:

VECTORES CON REGISTROS
La combinación de las estructuras con los arrays proporciona una potente herramienta para el
almacenamiento y manipulación de datos.
Ejemplo:
Utilizaremos el registro del empleado, que se escribió anteriormente, ahora implementaremos
mediante un arreglo que almacena a N empleados.
Realizamos el Diseño de la estructura de datos del vector de registros de empleados como sigue:
VectorEmpleado
VE[N]: Empleado
N:int
i: int
LeerVE():void
ImprimirVE():void
ListarVarones():void
El programa es el siguiente de VectorEmpleado:
package registros;

public class VectorEmpleado {
private Empleado ve[];
private int N, i;
void LeerVectorEmpleado ()
{
System.out.print ("Cuantos empleados desea registrar...");
N = sc.nextInt();
ve=new Empleado[N];
for (i = 0 ; i < N; i++)

{
System.out.println ("EMPLEADO : " + i);
ve [i] = new Empleado ();
ve [i].leerE();
}
}
void ImprimirVectorEmpleado ()
{
System.out.println (".....IMPRIMIENDO DATOS DE LOS EMPLEADOS....");
for ( i = 0 ; i <N ; i++)
{
ve[i].imprimirE();
}
}
La aplicación para utilizar el vector de registros de empleados es el siguiente:
AppVectorEmpleado
T: VectorEmpleado
main()
package registros;
public class AppVectorEmpleado {
static VectorEmpleado almacen;

almacen=new VectorEmpleado();
almacen.LeerVectorEmpleado();
almacen.ImprimirVectorEmpleado();
Salida:

EJERCICIOS PROPUESTOS DE REGISTROS
1. Implementar las siguientes estructuras de datos utilizando registros, sobre información de
artículos, que se cómo se ve a continuación:
Articulo VectorArticulo
codigo: int VA[N] : Articulo
NombreArt: String N: int
precio: float i: int
stock: int LeerVA():void
fechaVencimiento: Fecha ImprimirVA():void
LeerA():void ModificarPrecios: void
ImprimirA():void
CambiarPrecio(int x):float
AppVectorArticulo
Tienda1: VectorArticulo
Tienda2 : VectorArticulo
main()
1. Implementar las siguientes estructuras de datos utilizando registros, sobre información de

padres e hijos, y finalmente se almacenara en un vector las familias, se realizara una
apliacion que permita almacenar las familias de la ciudad de La Paz y de Santa Cruz, en dos
vectores de familias cómo se ve a continuación:
Padres Hijo Familia

CI: long Nombre: String Papa: Padres
Nombre: String FechaNac: String Mama:Padres Cantidad de hijos
Paterno: String Genero: char ch: int Vector de
Materno: String Hijos[ch]: Hijo registros de
leerP():void leerH():void hijos, una flia.
ImprimirP(): void ImprimirH(): void leerF():void Puede tener
ImprimirF(): void más de un hijo
VectorFamilias AppVectorFamilias
VF[N]: Familia LP: VectorFamilias
N: int STC: VectorFamilias
I:int main()
leerVF():void
ImprimirVF(): void

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 1 1 0
A=
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.
Implementación de una matriz poco densa
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.
La estructura del registro de la matriz poco densa, será el siguiente:

RegMPD
Fila: int
Col: int
Valor: int
RegMPD():void
obtenerFila():int
obtenerColumna():int
El siguiente programa nos permite crear la estructura para una matriz poco densa, se lo ha
denominado MatrizPocoDensa.java:

package matricesPocoDensas;
public class RegMPD {

private int fila;
private int col;
private int valor;
RegMPD (int f, int c, int v)

{
fila = f;
col = c;
valor = v;
}
public int obtenerFila ()

{
return fila;
}
public int obtenerCol ()

{
return col;
}
public int obtenerValor ()

{
return valor;
}
Luego diseñamos el Vector de Registros para leer la matriz por filas y luego imprimir la Matriz Poco
Densa:
MatrizPocoDensa
V[k]: RegMPD
K:int
LeerMatriz():void
ImprimirMatriz():void
Implementamos el programa en java.

public class MatrizPocoDensa {
private RegMPD A[]=new RegMPD[20];

void leerMatriz()
{
int M, N, i,j,k, e;
k = 0;
System.out.print ("INGRESE EL NUMERO DE FILAS DE LA
MATRIZ....");
M = sc.nextInt ();
System.out.print ("INGRESE EL NUMERO DE COLUMNAS DE LA
MATRIZ....");
N = sc.nextInt();
k = 1;
for (i = 1 ; i <= M ; i++)
{
for (j = 1 ; j <= N ; j++)
{
System.out.print ("Ingrese el valor de la posicion (" + i
+ "," + j + ") =");
e = sc.nextInt();
if (e != 0)
{
A [k] = new RegMPD (i, j, e);
k = k + 1;
}
}
}
A [0]= new RegMPD (M, N, (k - 1));
}
void ImprimirMatrizPocoDensa()
{
int i, j, k;
k = 1;
System.out.println ("IMPRIMIENDO LA MATRIZ POCO DENSA....");
for (i = 1 ; i <= A[0].obtenerFila(); i++)

{

for (j = 1 ; j <= A [0].obtenerCol() ; j++)
{
if ((A [k].obtenerFila() == i) && (A [k].obtenerCol() == j))
{
System.out.print (" " + A [k].obtenerValor() + " ");
if (A [0].obtenerValor() > k)
k = k + 1;
}
else
System.out.print (" 0 ");
}
}
}
}
La aplicación para llenar e imprimir una matriz poco densa es la siguiente:
AppMatrizPocoDensa
R: MatrizPocoDensa
main()
public class AppMatrizPocoDensa {
static MatrizPocoDensa R=new MatrizPocoDensa();

{
R.leerMatriz();
R.imprimirMatriz();
Salida:

EJERCICIOS PROPUESTOS DE MATRICES POCO DENSAS
1. Escribir las estructuras de datos necesarias para generar la matriz identidad, para una
matriz cuadrada.
1 0 0
0 1 0
0 0 1
2. Generar una matriz para que solo se lea los datos de la diagonal secundaria y la diagonal
principal.
4 0 1
0 3 0
8 0 7
3. Generar la matriz borde.

1 1 1
1 0 1
1 1 1
4. Leer datos en una matriz triangular superior.
5. Leer los datos de una matriz triangular inferior

Se dice que un objeto es recursivo, si en parte está formado por sí mismo o se define en función
de sí mismo.
RECURSION
“... 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”.
RECURSIÓN VS ITERACIÓN
¿Cuándo debemos utilizar la iteración y cuándo la recursión? Hay por lo menos estos tres factores
a considerar:
1. Las funciones iterativas son usualmente más rápidas que sus contrapartes recursivas. Si la
velocidad es importante, normalmente usaríamos la iteración.
2. Si la memoria de pila es un limitante, se preferirá la iteración sobre la recursión.
3. Algunos procedimientos se programan de manera recursiva de forma muy natural, y resultan

prácticamente inabordables iterativamente. Aquí la elección es clara.
RECURSIÓN
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 árboles.
FORMA DE ENFRENTAR PROBLEMAS RECURSIVOS

Debe existir un caso BASE.
Este 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.
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 cuán 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 más cerca del caso BASE.
Ejemplo
La función factorial, se define en matemática como:
n! = 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
Factorial Iterativo
A continuacion se muestra la función sin recursividad de la función factorial.
public static int factorial (int n)

{
int fact = 1;
while (n >= 1)
{
fact *= n;
n--;
}
return fact;
}
Factorial Recursivo
La function factorial en forma recursive, se define:
1 𝑠𝑖 𝑁 = 0
N! =
𝑁 ∗ (𝑁 − 1)! 𝑠𝑖 𝑁 > 0

public static int factorial (int n)
{
if (n==0)
return 1;
else
return n * factorial (n-1);
}
¿CÓMO FUNCIONA?
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.

En la gráfica anterior se observa claramente el comportamiento de pila de la implementación
recursiva, en esta versión simplificada se omiten los detalles del funcionamiento al nivel de la
máquina.
Para ser realistas, la recursión no solo pasa una copia de los parámetros (operandos de los cálculos
pendientes), sino que también debe pasar una copia de las direcciones de llamada de función en
cada paso para regresar al punto original del programa donde se inició el proceso de recursión.
Por lo general, los lenguajes de alto nivel como el C, C++ o Java, 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.
Fibonacci
Fibonacci (n) =
Fibonacci (n-1) + Fibonacci (n-2)
Fibonacci(n) = 0 si n = 0
1 si n = 1
Fibonacci (n-1) + Fibonacci (n-2) si n>=2

Fibonacci recursivo
public static int fibonacci (int n)
{
if (n <= 1)
return n;
else
return fibonacci(n-1) + fibonacci(n-2);
}
¿ES EFICIENTE ESTA IMPLEMENTACIÓN?
Existen muchas llamadas redundantes en la implementación recursiva de Fibonacci
Para calcular
◦ fibonacci (5) requiere de 15 llamadas recursivas
◦ fibonacci(35) requiere de 29,860,703 llamadas recursivas (tiempo exponencial de ejecución)
Por lo tanto:
Utiliza recursión cuando se mejora el diseño del algoritmo y se ejecuta en un tiempo y espacio
razonable.
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) );
} }
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.
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 comienza 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)
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);
return( base * xelevn (base , exp-1));
}
2) Multiplicar 2 numero naturales, con sumas sucesivas recursivas:
3*2 = 6

int multi( int a, int b )
{ if ( b == 0 )
return(0);
return( a + multi(a, b-1) );
}
3) Crear el programa para la aplicación de recursividad, AppRecursividad, en la misma codificar

las siguientes funciones recursivas:
o Factorial de un numero
o Multiplicación de dos números naturales
o Calcular la potencia de un numero
o Hallar la sumatoria de N términos para 1+1/3+/1/5+1/7+…
package ejercicios;
public class AppRecursividad {

//hallar el factorial de un numero N
static int factorial(int N)

{
if (N==0)
return 1;
else
return N*factorial(N-1);
}
// hallar la potencia de la base elevado a exp

static float xelevn ( float base, int exp )
{ if (exp == 0 )
return(1);
return( base * xelevn (base , exp-1));
}
// halla la multiplicacion de dos numeros naturales a y b

static int multiplicar( int a, int b )
{
if ( b == 0 )
return(0);
return( a + multiplicar(a, b-1) );
}
//halla la sumatoria de N terminos 1+1/3+1/5+1/7+....
static float sumatoria(int N)
{
if (N==1)
return 1;
else
return sumatoria (N-1)+(float)1/(float)((N*2)-1);
}

{ int opcion, num, num2,R;
int e;
float b,P;
do{
System.out.print(" \n\n M E N U R E C U R S I V I D A D \n 1. Factorial \n

2. Potencia \n 3. multiplicar \n 4. sumatoria de N terminos 1+1/3+1/5+...");
System.out.print("\n 5. sumatoria de N terminos 3+6+9+12+...\n
6.Salir \n\n Elija su opcion...");
opcion=sc.nextInt();
switch(opcion)
{
case 1: System.out.println("\n\n Ingrese el numero para obtener su
factorial...");
num=sc.nextInt();
R=factorial(num);
System.out.println("El factorial de num es "+R);
break;
case 2: System.out.print("\n\n Ingrese la base ");
b=sc.nextInt();
System.out.print("Ingrese el exponente");
e=sc.nextInt();
P=xelevn(b,e);
System.out.print(b+ "elevado a "+e+" es "+P);
break;
case 3: System.out.println("\n\n Ingrese el primer numero...");
num=sc.nextInt();//lee un entero el nextInt()
para un real es nextFloat(), cadena se lee como next() una linea se lee con
nextLine()
System.out.println("Ingrese el segundo numero...");
num2=sc.nextInt();
R=multiplicar(num,num2);
System.out.println("la multiplicacion es "+R);
break;
case 4: System.out.println("Cuantos terminos desea sumar?? ");
num=sc.nextInt();
P=sumatoria(num);
System.out.println("la sumatoria de 1 + 1/3+ 1/5 + 1/7+...es
"+P); break;
default: System.out.println("fin del programa");

}
}while (opcion!=6);
}
}

Salida:
EJERCICIOS PROPUESTOS DE RECURSIVIDAD

1. Imprimir los N primeiros números naturales
2. Realizar en forma recursiva la función de Stirling
3. Implementar en forma recursiva la función de ackerman
4. Implementar en forma recursiva el problema de las torres de Hanoi

Muere lentamente, quien abandona un proyecto antes
de iniciarlo, no preguntando de un asunto que desconoce
o no respondiendo cuando le indagan sobre algo que sabe.
Evitemos la muerte en suaves cuotas, recordando

siempre que estar vivo exige un esfuerzo mucho mayor
que el simple hecho de respirar.
Pablo Neruda
INTRODUCCIÓN A LAS ESTRUCTURAS DE DATOS DINÁMICAS

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 número 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
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
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
Puntero
memoria
cabecera
9 3 7 5
p Ana 3 Juan 7 Rosa 5 Pedro
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 un puntero cabecera
 Todos los nodos de la lista son del mismo tipo.
 Los nodo pueden ser agregados o suprimidos en cualquier momento en la lista
TIPO DE DATO ABSTRACTO NODO

Un NODO es una estructura compuesta básicamente de dos partes:
La implementación del nodo para elementos de tipo String en java:
 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.
Donde:

private class nodo
{
private String info;
private nodo dirsgte;
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.
OPERACIONES BÁSICAS SOBRE LISTAS ENLAZADAS

Existen las siguientes operaciones básicas que se pueden hacer sobre listas enlazadas:
 Creación: de una lista vacía

 Vacía: Retorna verdadero si la lista está vacía y falso en caso contrario.
 Inserción: Agregar un elemento al final de la lista o al inicio de la lista
 Eliminar: Se puede quitar el primer elemento de la lista o el ultimo elemento de la lista
 Buscar: ver si la lista contiene un elemento determinado.
 Recorrido: Imprime los elementos de la lista
DISEÑO DE LA ESTRUCTURA DE DATOS LISTA ENLAZADA LINEAL SIMPLE
En general el diseño de las estructuras de datos son las siguientes:
ListaLineal
Nodo
Info: tipo_dato P: Nodo

Dirsgte: Nodo
InsertarInicio(e):void
InsertarFinal(e):void
EliminarInicio():tipo_dato
EliminarFinal():tipo_dato
Recorrido():void

Ejemplo:
Diseñamos una lista enlazada para elementos de tipo cadena, con un puntero cabecera p:
9 3 7 5
p Ana 3 Juan 7 Rosa 5 Maria
Nodo ListaLineal
Info:String
Dirsgte: Nodo P: Nodo
Vacia():boolean
InsertarInicio(e):void
InsertarFinal(e):void
EliminarInicio():String
EliminarFinal():String
Recorrido():void
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
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.
9 3 7 5

2
T
Mary
Q
La implementación en java es la siguiente:
void insertarFinal (String 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;
}
}
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 java:
9 3 7 5
Mary
Q
void insertarInicio (String elem)

{
//Aniadir un elemento al principio de la lista
q.info = elem;
q.dirsgte = p;
p = q;
}
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.
void recorrido ()
{
//Recorrer la lista
System.out.println (" \n....RECORRIDO DE LA LISTA....");
nodo q = p;
while (q != null)
{
System.out.print (q.info + ", ");
q = q.dirsgte;
}
}
Eliminar el nodo del inicio de la Lista
Permite eliminar el primer nodo de la lista.
9 3 7 5
La función será la siguiente:
String eliminaInicio ()
{
//elimina el nodo del inicio de la lista
String elem;
nodo q = p;
p = p.dirsgte;
elem=p.info;
q = null;
return elem;
}
ELIMINAR EL NODO DEL FINAL DE LA LISTA
Permite eliminar el último nodo de la lista.

9 3 7 5
T Q
String eliminaFinal ()
{
//elimina un nodo del final de la lista
nodo q = p;
String elem="";
if (p.dirsgte == null)
{ elem=p.info;
p = null;
}
else
{
nodo t = p;
while (q.dirsgte != null)
{
t = q;
q = q.dirsgte;
}
t.dirsgte = null;
elem=q.info;
q = null;
}
return elem;
}
VACIA
Permite verificar si una lista esta vacia.
boolean vacia()
{
if (p==null)
return true;
else
return false;
}
BUSCAR
Busca un elemento en la lista y devuelve verdad, si el elemento existe, caso contrario devuelve
falso.

boolean buscar(String e)
{
nodo Q;
Q=p;
boolean sw=false;
while (Q!=null && sw==false)
{
if (Q.info.equals(e) )
sw= true;
Q=Q.dirsgte;
}
return sw;
}
IPLEMENTACIÓN EN EL LENGUAJE JAVA DE LA CLASE LISTAS LINEALES

A continuación realizamos la implementación del programa completo de listas simples, para datos
de tipo Strign en java.
package listas;
public class ListaLineal {
//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
{
}
void insertarInicio (String elem)

{
q.info = elem;
q.dirsgte = p;
p = q;
}
void insertarFinal (String 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)
p = q;
else
{
while (t.dirsgte != null)
t = t.dirsgte;
t.dirsgte = q;
}
}
void recorrido ()
{
//Recorrer la lista
nodo q = p;
while (q != null)
{
q = q.dirsgte;
}
}
boolean vacia()
{
if (p==null)
return true;
else
return false;
}
String eliminaInicio ()
{
//elimina el nodo del inicio de la lista
String elem;
nodo q = p;
p = p.dirsgte;
elem=p.info;
q = null;
return elem;
}
String eliminaFinal ()
{
//elimina un nodo del final de la lista
nodo q = p;
String elem="";
if (p.dirsgte == null)
{ elem=p.info;
p = null;
}

else
{
nodo t = p;
while (q.dirsgte != null)
{
t = q;
q = q.dirsgte;
}
t.dirsgte = null;
elem=q.info;
q = null;
}
return elem;
}
{
nodo Q;
Q=p;
boolean sw=false;
while (Q!=null && sw==false)
{
sw= true;
Q=Q.dirsgte;
}
return sw;
}
public void llenarLista ()

{
//llena la lista enlazada con elementos de tipo real con N elementos
int N;
String elem;
System.out.println ("Cuantos elementos desea ingresar a la lista ?");
N = sc.nextInt();
for (int i = 1 ; i <= N ; i++)

{
System.out.print ("ingrese elemento ....");
elem =sc.next();
insertarFinal (elem);
}
}
}
EJERCICIO
Escribir una aplicación en java para llamar a todas las operaciones con listas.

package listas;
public class AppListaLineal {
public static void main(String arg[])

{
ListaLineal A;
A=new ListaLineal();
A.llenarLista();
A.recorrido();
if (A.buscar("maria"))
System.out.println("\n\n elemento encontrado...");
else
System.out.println("\n\n elemento no encontrado...");
System.out.println("\n\n Eliminando un elemento del final de la lista");
A.eliminaFinal();
A.recorrido();
A.eliminaInicio();
System.out.println("\n\n Eliminando un elemento del inicio de la
lista");
A.recorrido();
}
Salida:

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:

EnlaIz Info EnlaDer
Nodo
Donde:
EnlaIz : Enlace Izquierdo, es de tipo puntero y apunta al nodo de la izquierda del nodo actual, en
caso de ser el primer nodo apunta a null.
Info: Contiene la información del nodo.
EnlaDer: Enlace derecho, es de tipo puntero y apunta al nodo de la derecha del nodo actual, en caso
de ser el último nodo de la lista, apunta a null.

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 null.
 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.
LISTA ENLAZADA CIRCULAR SIMPLE

En una lista circular simple, el último nodo apunta al primer nodo, lo que hace que se pueda recorrer
toda la lista desde cualquier nodo.
Ejemplo: sea una lista de nombres:
9 3 7 5
p Ana 3 Juan 7 Rosa 5 Maria 9
La implementación de estas listas en java esta a continuacion:
package listas;
public class ListaCircularSimple {

//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
{
}
void insertar (String elem)

{
q.info = elem;
if (p==null)
{

q.dirsgte = q;
p=q;
}
else
{
q.dirsgte=p.dirsgte;
p.dirsgte = q;
}
}
void recorrido ()
{
//Recorrer la lista
nodo q = p;
while (q.dirsgte !=p )
{
q = q.dirsgte;
}
System.out.print (q.info );
}
boolean vacia()
{
if (p==null)
return true;
else
return false;
}
String eliminar ()
{
//elimina el segundo nodo de la lista circular
String elem="";
nodo q = p;
if (p.dirsgte==p)
{
elem=p.info;
p=null;
}
else
{
q=q.dirsgte;
elem=q.info;
p.dirsgte=q.dirsgte;
q=null;
}
return elem;
}
{
nodo Q;

Q=p;
boolean sw=false;
while (Q!=p && sw==false)
{
sw= true;
Q=Q.dirsgte;
}
sw= true;
return sw;
}

{
//llena la lista enlazada con elementos de tipo real con N elementos
int N;
String elem;
N = sc.nextInt();
for (int i = 1 ; i <= N ; i++)

{
elem =sc.next();
insertar (elem);
}
}
}
La aplicación para llenar una lista L y luego realizar el recorrido de la lista circular, para luego eliminar
un elemento es el siguiente:
package listas;
public class AppListaSimpleCircular {

{
ListaCircularSimple L=new ListaCircularSimple();
L.llenarLista();
L.recorrido();
System.out.println("\n\n ELIMINANDO UN ELEMENTO DE LA LISTA ");

L.eliminar();
L.recorrido();
}
}

Salida:
LISTA ENLAZADA DOBLE LINEAL
En la figura siguiente se muestra un ejemplo de una lista doblemente ligada lineal que almacena
nombres: 9 2
4 3 9 Ana null
3 Ana 2
p Null Ana 3 4 Ana 9
El programa para listas lineales dobles en java, para elementos de tipo cadena es el siguiente:
package listas;
public class ListaDoble {

class Nodo{
Nodo EnlaIz;
String Info;
Nodo EnlaDer;
}
Nodo p=null;
void InsertarInicio(String elem)

{
Nodo Q;
Q=new Nodo();
Q.Info=elem;
Q.EnlaIz=null;
if (p==null)
{
Q.EnlaDer=null;
p=Q;
}
else
{
Q.EnlaDer =p;
p.EnlaIz=Q;
p=Q;
}
}
void InsertarFinal(String elem)

{ Nodo T;
Nodo Q=new Nodo();
Q.Info=elem;
Q.EnlaDer=null;
if (p==null)
{
Q.EnlaIz=null;
p=Q;
}
else
{
T=p;
while (T.EnlaDer!=null)
{
T=T.EnlaDer;
}
T.EnlaDer=Q;
Q.EnlaIz=T;
}
}
String EliminarInicio()
{ String elem="";
Nodo Q=p;
elem=p.Info;
if(p.EnlaDer==null)
p=null;
else
{
p=p.EnlaDer;
p.EnlaIz=null;
Q=null;
}
return elem;
}
void recorrido ()
{
Nodo q = p;
while (q != null)

{
System.out.print (q.Info + ", ");
q = q.EnlaDer;
}
}
boolean vacia()
{
if (p==null)
return true;
else
return false;
}

{
int N;
String elem;
N = sc.nextInt();
for (int i = 1 ; i <= N ; i++)

{
elem =sc.next();
InsertarInicio (elem);
}
}
La aplicación para manejo de listas dobles es la siguiente:
package listas;
public class AppListaDoble {

{
ListaDoble A;
A=new ListaDoble();
A.llenarLista();
A.recorrido();
A.EliminarInicio();
System.out.println("\n\n Eliminando un elemento del inicio de la
lista");
A.recorrido();
}
}
Salida:
LISTAS DOBLES CIRCULARES

Debido a que las listas dobles circulares son más eficientes, en la figura siguiente se muestra
un ejemplo de una lista doblemente ligada circular que almacena números:
EJERCICIOS RESUELTOS DE LISTAS

1. Insertar um nuevo nodo despues del k-esimo nodo de la lista.
El procedimento en java es el siguiente, este procedimento adicionar al programa de ListaLineal.java

//INSERTAR UN NUEVO NODO DESPUES DEL K-ESIMO NODO DE LA LISTA
void InsertaKesimo(String e, int k)
{
nodo Q,T;
int c;
Q=new nodo();
Q.info=e;
T=p;
c=1;
while (T.dirsgte!=null && c!=k)

{
T=T.dirsgte;
c++;
}
Q.dirsgte=T.dirsgte;
T.dirsgte=Q;
}
La aplicacion para insertar el nombre de laura, despues del tercer nodo, sera el siguiente:
package listas;
public class AppListaLineal {

{
ListaLineal A;
A=new ListaLineal();
A.llenarLista();
A.recorrido();
System.out.println("\n\n ISERTANDO EL NOMBRE DE LUARA DESPUES DEL 3ER
NODO");
A.InsertaKesimo("Laura", 3);
A.recorrido();
}
Salida:

2. Llevar el primer nodo de la lista al final de la lista doble.
Codificamos el procedimento em el programa de ListaDoble
//LLEVAR EL PRIMER NODO AL FINAL DE LA LISTA DOBLE

void LlevarElPrimerAlUltimo()
{
Nodo Q,T;
Q=p;
p=p.EnlaDer;
T=p;
while(T.EnlaDer!=null)
{
T=T.EnlaDer;
}
T.EnlaDer=Q;
Q.EnlaIz=T;
Q.EnlaDer=null;
}
}
Escribimos uma aplicacion para llamar a este procedimento que lleva al final el primer nodo, como
se ve a continuacion:
package listas;
public class AppListaDoble {

{

ListaDoble A;
A=new ListaDoble();
A.llenarLista();
A.recorrido();
A.LlevarElPrimerAlUltimo();
System.out.println("\n\n LLEVANDO EL PRIMER NODO AL ULTIMO DE LA LISTA");
A.recorrido();
}
}
Salida:
EJERCICIOS PROPUESTOS DE LISTAS

1. Contar los nodos de uma lista simple lineal.
2. Eliminar el primer nodo cuyo elemento es X, donde X es dado por el usuário.
3. Imprimir solo los nombres que empiezan por uma vocal, em uma lista circular simple.
4. Implementar uma lista doble circular y realizar su aplicacion.
5. En uma lista doble lineal eliminar todos los elementos X, donde X es dado por el usuário.
6. Insertar N nodos antes del ultimo nodo de uma lista doble.
7. Eliminar el segundo nodo de uma lista doble lineal
8. Insertar un nodo al final de la lista circular simple.
9. Eliminar un nodo del final de uma lista circular simple
10. Intercambiar el primer nodo com el ultimo nodo de uma lista doble lineal.

“Si Java dispusiera de un mecanismo real de recolección de basura, la mayoría
de los programas deberían autoeliminarse al ser ejecutados.” — Robert Sewell
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.
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 = 555 434 222 4444
1 2 3 4 … MAX
444
TOPE 222 TOPE
434
555
PILA
4
ESTRUCTURA DE UNA PILA UTILIZANDO ARREGLOS
3
2 PILA
Nombre del TAD
1
V[MAX]: tipo_dato
Tope: entero
elementos
Poner(e)
Quitar()
Imprimir()
operaciones Vacia()
Llena()
Donde:
V[MAX]: es el vector que representa a la pila y es de tamaño de la pila.
Tope: es la variable que indica la posición del último elemento de la pila.
Y las operaciones como se describen a continuación.
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:
 Poner (e) un elemento en la pila (push)

 Quitar () un elemento de la pila (pop)
 Llena() verifica si la pila esta llena, si es asi, retorna el valor verdad, caso contrario
falso.

 Vacia() verifica si la pila esta vacia, si es asi, reotrna el valor verdad, caso contrario falso.
 Imprime() Permite imprimir todos los elementos de la pila desde el tope hasta el fondo
de la pila.
IMPLEMENTACIÓN DE LA ESTRUCTURA DE DATOS PILA EN LENGUAJE JAVA

A continuacion implementamos el programa para una pila de números enteros.
package estructurasEstaticas;
//Pila de numeros enteros

public class pila {

private final int MAX = 20;
private int v[] = new int [MAX];
private int tope;
pila ()
{
tope = 0;
}
boolean vacia ()
{
if (tope == 0)
return (true);
else
return (false);
}
boolean llena ()
{
if (tope == MAX)
return (true);
else
return (false);
}
void poner (int elem)

{
if (llena ())
System.out.println ("PILA LLENA...");
else
{
tope++;
v [tope] = elem;
}
}
int quitar ()

{
int elem = 0;
if (vacia ())
System.out.println ("PILA VACIA...");
else
{
elem = v [tope];
tope--;
}
return (elem);
}
void imprimir ()
{
System.out.println ("...IMPRIMIENDO LA PILA...");
for (int i = tope ; i >= 1 ; i--)
System.out.println (v [i]);
}
void llenarPila ()
{
int n, e;
System.out.println ("cuantos elementos ??...");
n = sc.nextInt();
for (int i = 1 ; i <= n ; i++)
{
System.out.print ("elemento?...... ");
e = sc.nextInt();
poner (e);
}
}
}
EJERCICIOS RESUELTOS DE PILAS

Escribir una aplicación que tenga los siguientes ejercicios con pilas, en una pila de números
enteros. Esta aplicación utilizara el anterior programa de pila.
 Sumar los elementos de la pila A y B en una nueva pila C.

 Intercambiar el elemento del tope con el elemento del fondo de la pila
El programa seria el siguiente:
public class EjerPilas {

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);
}
static void IntercambiaFondoTope(pila A)

{
pila aux;
int x, etope, efondo;
aux=new pila();
System.out.println("\n INTERCAMBIANDO ELEMENTO DEL FONDO CON
ELEMENTO DEL TOPE");
etope=A.quitar();
while(!A.vacia())
{
x=A.quitar();
aux.poner(x);
}
efondo=aux.quitar();
A.poner(etope);
while(!aux.vacia())
{
x=aux.quitar();
A.poner(x);
}
A.poner(efondo);

{
P1.llenarPila ();
P2.llenarPila ();
P1.imprimir ();
P2.imprimir ();
sumarPilas (P1, P2, P3);
System.out.println("\n\n SUMANDO LAS DOS PILAS \n\n");
P3.imprimir ();
IntercambiaFondoTope(P3);
P3.imprimir ();
}
}
Salida:
 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= 3 4 77 89 B= 23 11 44 33
TOPE TOPE
C= 89 33 77 44 4 11 3 23
TOPE

public class IntercalarPilas {

//intercalar los elementos de una pila A con los elementos de una pila B
//en una pila c
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);
}
}
Salida:

APLICACIONES CON PILAS
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
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
…… …
….
….
TRES
….
….
….
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.
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.
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
PILAS DINÁMICAS
Implementaremos las pilas mediantes listas enlazadas simples, a continuación
presentamos el código en java.
package estructurasDinamicas;
public class Pila {

class Nodo
{
int Info;
Nodo DirSgte;
}
private Nodo tope;//puntero cabecera

private int longitud;
public Pila()
{
tope=null;
longitud=0;
}
public int longitud()

{
return longitud;
}
public boolean esVacia()

{
if (tope==null)
return true;
else
return false;
}
public void Poner(int elem)
{
Nodo Q;
Q=new Nodo();
Q.Info=elem;
Q.DirSgte=tope;
tope=Q;
longitud++;
}
public int Quitar()
{
int aux;
if (esVacia())
{ System.out.println("pila vacia");
return Integer.MAX_VALUE;
}
else
{
aux=tope.Info;
tope=tope.DirSgte;
longitud--;
return aux;
}
}
public void Imprimir()
{
Nodo Q;
Q=tope;
while (Q!=null)
{
System.out.print(Q.Info+", ");
Q=Q.DirSgte;
}
}
public void LlenarPila()

{
int N;
int elem;
System.out.println("Cuantos elementos desea insertar a la pila ");
N=sc.nextInt();
for (int i=1; i<=N;i++)
{
System.out.println("Ingrese elemento...");
elem=sc.nextInt();
Poner(elem);
}
}
}

EJERCICIOS RESUELTOS CON PILAS DINAMICAS
Escribir una aplicación para utilizar las pilas dinámicas. Los ejercicios son:
a. Eliminar los elementos negativos de la pila

b. Intercambiar el elemento del fondo con el elemento del tope de la pila
public class AppPilas {
static void EliminarNegativos(Pila A)

{
int x;
Pila Aux=new Pila();
System.out.println("\n ELIMINANDO ELEMENTOS NEGATIVOS");
while (!A.esVacia())
{
x=A.Quitar();
if (x>0)
Aux.Poner(x);
}
while(!Aux.esVacia())
{
A.Poner(Aux.Quitar());
}
}
static void IntercambiaFondoTope(Pila A)

{
Pila aux;
int x, etope, efondo;
aux=new Pila();
System.out.println("\n INTERCAMBIANDO ELEMENTO DEL FONDO CON
ELEMENTO DEL TOPE");
etope=A.Quitar();
while(!A.esVacia())
{
x=A.Quitar();
aux.Poner(x);
}
efondo=aux.Quitar();
A.Poner(etope);
while(!aux.esVacia())
{
x=aux.Quitar();
A.Poner(x);
}
A.Poner(efondo);

{
Pila A=new Pila();
A.LlenarPila();
A.Imprimir();
EliminarNegativos(A);
A.Imprimir();
IntercambiaFondoTope(A);
A.Imprimir();
}
Salida:
EJERCICIOS PROPUESTOS CON PILAS
1. Escriba un programa que elimine los elementos repetidos de una pila. Los elementos
repetidos ocupan posiciones sucesivas.
2. Escriba un subprograma que invierta los elementos de una pila.

3. Insertar n elementos después al fondo de una pila que ya tiene datos.
4. Intercambiar cada elemento de la pila con su adyacente.
5. Eliminar el primer elemento par de la pila
6. Hallar la frecuencia de repetición de cada elemento de la pila
7. Apilar los elementos de la pila B sobre la pila A.
8. Insertar el elemento X en una pila cuyos elementos están ordenados en forma
ascendente desde el fondo hasta el tope. La pila debe quedar ordenada
9. Escriba un programa que lea una expresión en notación infija, y la traduzca anotación
postfija.
10. Traduzca las siguientes expresiones a notación postfija utilizando el algoritmo de
evaluación.
 X*(Z+W)/(T-V)
 Z-W*Y+XˆK
 W*(Z/(K-T))

El camino del Tigre
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
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 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.
- ¡Levántate, toma tus herramientas, y sigue el camino del tigre! de Paulo Coelho
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).

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.
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.
Ejemplo: sea una cola Q de números enteros: MAX=6
Q=
11 22 33 44
Frente Final
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
Insertar(e)
operaciones Eliminar()
Imprimir()
Vacia()
Llena()
FRENTE()
FINAL()
Donde los elementos son:
V[MAX]:es el vector que re presenta 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.
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.
Eliminar un elemento de la cola:

Como vera la eliminación no borra nada 'físicamente', sólo se encarga de actualizar el puntero
'frente' en una posición y devolver el valor x como mucho, aunque esto último no sea estrictamente
necesario. Aunque esa posición aun contenga datos será considerada como vacía a efectos del otro
puntero 'fin'.
COLAS LINEALES
A continuación implementamos el código correspondiente al programa de manejo de colas
lineales en java:
//COLA LINEAL DE NUMEROS ENTEROS Y SUS OPERACIONES

public class Cola {

final int MAX = 20;

private int fin;
private int frente;

Cola ()
{
frente = 0;
fin = 0;
System.out.println ("COLA CREADA....");
}
boolean vacia ()
{
if (frente == 0)
return (true);
else
return (false);
}
boolean llena ()
{
if (fin == MAX)
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 ()
{
return (fin);
}
int FRENTE ()
{
return (frente);

}
void llenarCola ()
{
int N;
int e;
System.out.println ("Cuantos elementos desea insertar a la cola ??");
N=sc.nextInt();
for (int i = 1 ; i <= N ; i++)
{
System.out.print ("Introduzca un elemento....");
e = sc.nextInt();
insertar (e);
}
}
}
EJERCICIOS CON COLAS LINEALES

a. Eliminar los divisores de x de una cola
public class EjerColaLineal {

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 = sc.nextInt();
while (A.FRENTE () != m + 1)
{
e = A.eliminar ();
if (x % e != 0)
A.insertar (e);
}
A.imprimir ();
}

{
Q.llenarCola ();
Q.imprimir ();
EliminarDivisoresX (Q);
}
}
Salida:
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.

Ejemplo Final
33
45
22
85 Frente
67
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
Final Final
(B)
El diseño de la estructura de datos de una cola circular no varia en relación a una estructura de datos
lineal, por tanto a continuación mostramos las operaciones que sufren cambios en este tipo de
colas.
OPERACIONES CON COLAS CIRCULARES

Las operaciones básicas con colas circulares son: insertar, eliminar y mostrar una cola circular. A
continuación mostramos la implementación en Java de una Cola Circular para elementos de tipo
entero.

public class ColaCircular {

final int MAX = 20;

private int fin;
private int frente;
ColaCircular ()
{
frente = 0;
fin = 0;
}
boolean vacia ()
{
if (frente == 0)
return (true);
else
return (false);
}
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;
}
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 = sc.nextInt();
for (int i = 1 ; i <= N ; i++)
{
System.out.print ("Introduzca un elemento....");
e = sc.nextInt();
insertar (e);
}
}
}
EJERCICIOS CON COLAS CIRCULARES
a. Eliminar los elementos negativos de la cola circular
// ELIMINAR LOS NEGATIVOS DE LA COLA CIRCULAR
public class EjerColaCircular {
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 ();
}

{

Q.llenarCola ();
Q.imprimir ();
EliminarNegativos(Q);
}
}
Salida:
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.
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.
COLAS DINAMICAS
public class Cola {

class Nodo
{
int Info;
Nodo DirSgte;
}
Nodo Frente, Fin;

Cola()
{
Frente=null;
Fin=null;
}
public boolean esVacia()

{
if (Frente==null)
return true;
else
return false;
}
public void Insertar(int elem)

{
Nodo Q;
Q = new Nodo ();
Q.Info = elem;
Q.DirSgte = null;
if (esVacia ())
{
Frente = Q;
Fin = Q;
}
else
{
Fin.DirSgte = Q;
Fin = Q;
}
}
public int Eliminar()

{
int elem;
Nodo Q;
if (!esVacia ())
{
elem = Frente.Info;
if (Frente == Fin)
{
Frente = null;
Fin = null;

}
else
{
Q=Frente;
Frente = Frente.DirSgte;
Q=null;
}
return elem;
}
else
return Integer.MAX_VALUE;
}
public int Contar()

{
int c=0;
Nodo Q=Frente;
while (Q!=null)
{ c++;
Q=Q.DirSgte;
}
return c;
}
public void Imprimir()

{
Nodo Q=Frente;
System.out.println("Listado de todos los elementos de la cola.");
while (Q!=null)
{
System.out.print(Q.Info+", ");
Q=Q.DirSgte;
}
}
public void LlenarCola()

{
int N;
int elem;
System.out.println("Cuantos elementos desea insertar a la
cola...");
N=sc.nextInt();
for(int i=1; i<=N; i++)
{
System.out.print("Ingrese un elemento...");
elem=sc.nextInt();
Insertar(elem);
}
}
}

EJERCICIOS RESUELTOS CON COLAS LINEALES DINAMICAS
Escribir un programa utilizando colas lineales dinámicas, para:
 Intercambiar el elemento del frente con el elemento del final de la cola.

 Eliminar el primer negativo
// COLAS LINEALES DINAMICAS
public class EjerColasDinamicas {
static void IntercambiarFrenteFin(Cola A)

{
int x,y,m,i;
System.out.println("Intercambiando el frente con el final");
x=A.Eliminar();
m=A.Contar();
i=1;
while(i<m)
{
y=A.Eliminar();
A.Insertar(y);
i++;
}
A.Insertar(x);
}
static void EliminarPrimerNeg(Cola Q)
{
int x,m,i;
boolean sw=true;
m=Q.Contar();
i=1;
System.out.println("ELIMINANDO EL PRIMER NEGATIVO");
while(i<=m && sw)
{
x=Q.Eliminar();
if(x>=0)
Q.Insertar(x);
else
sw=false;
i++;
}
while (i<=m)
{
Q.Insertar(Q.Eliminar());
i++;
}

{
Cola Q=new Cola();
Q.LlenarCola();
Q.Imprimir();
IntercambiarFrenteFin(Q);
Q.Imprimir();
EliminarPrimerNeg(Q);
Q.Imprimir();
}}
Salida:
EJERCICIOS PROPUESTOS DE COLAS
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. Sumar dos colas A y B en una Cola C.
6. Intercambiar el elemento del frente de la cola por el elemento del final de la cola.
7. Intercambiar cada elemento con su adyacente.
8. Llevar los elementos primos al frente de la cola

9. Utilizando colas circulares resuelva el problema de Josefo.
10. Utilice una estructura de cola para simular el movimiento de clientes en una cola
de espera de un banco..
11. Escriba un programa que invierta los elementos de una cola.
12. Escriba un procedimiento para insertar un elemento en una doble cola Escriba un
programa que cree una pila a partir de una cola.

Tu vida no cambia cuando cambia tu jefe,
Cuando tus amigos cambian,
Cuando tus padres cambian,
Cuando tu pareja cambia.
Tu vida cambia, cuando tu cambias,

Eres el único responsable por ella.
"examínate.. Y no te dejes vencer"
DEFINICIÓN ÁRBOL
Un árbol es una estructura no lineal en la que cada nodo puede apuntar a uno o varios nodos.
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.

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.
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.
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 del árbol binario se representa gráficamente de la siguiente manera:
Izq Dato Der
Nodo Arbol
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
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
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

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
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:

IMPLEMENTACION DE UN ARBOL BINARIO
Programamos el nodo del árbol binario en java:
public class NodoArbol {

//miembros de acceso
NodoArbol nodoizquierdo;
int datos;
NodoArbol nododerecho;
//iniciar dato y hacer de este nodo un nodo hoja

public NodoArbol(int datosNodo)
{
datos = datosNodo;
nodoizquierdo = nododerecho = null; //el nodo no tiene hijos
}
//buscar punto de insercion e inserter nodo nuevo

public synchronized void insertar(int valorInsertar)
{
//insertar en subarbol izquierdo
if(valorInsertar < datos)
{
//insertar en subarbol izquierdo
if(nodoizquierdo == null)
nodoizquierdo = new NodoArbol(valorInsertar);
else //continua recorriendo subarbol izquierdo
nodoizquierdo.insertar(valorInsertar);
}
//insertar nodo derecho

else if(valorInsertar > datos)
{
//insertar nuevo nodoArbol
if(nododerecho == null)
nododerecho = new NodoArbol(valorInsertar);
else
nododerecho.insertar(valorInsertar);
}
} // fin del metodo insertar
}
Ahora implementamos la estructura de datos del Arbol Binario, junto con sus recorridos.
public class Arbol {

private NodoArbol raiz;
//construir un arbol vacio

public Arbol()
{
raiz = null;
}
//insertar un nuevo ndo en el arbol de busqueda binaria

public synchronized void insertarNodo(int valorInsertar)
{
if(raiz == null)
raiz = new NodoArbol(valorInsertar); //crea nodo raiz
else
raiz.insertar(valorInsertar); //llama al metodo insertar
}
// EMPIEZA EL RECORRIDO EN PREORDEN

public synchronized void recorridoPreorden()
{
ayudantePreorden(raiz);
}
//meoto recursivo para recorrido en preorden
private void ayudantePreorden(NodoArbol nodo)

{
if(nodo == null)
return;
System.out.print(nodo.datos + " "); //mostrar datos del nodo

ayudantePreorden(nodo.nodoizquierdo); //recorre subarbol izquierdo
ayudantePreorden(nodo.nododerecho); //recorre subarbol derecho
}
//EMPEZAR RECORRIDO INORDEN

public synchronized void recorridoInorden()
{
ayudanteInorden(raiz);
}
//meoto recursivo para recorrido inorden

private void ayudanteInorden( NodoArbol nodo)
{
if(nodo == null)
return;

ayudanteInorden(nodo.nodoizquierdo);
System.out.print(nodo.datos + " ");
ayudanteInorden(nodo.nododerecho);
}
//EMPEZAR RECORRIDO PORORDEN

public synchronized void recorridoPosorden()
{
ayudantePosorden(raiz);
}
//meotod recursivo para recorrido posorden

private void ayudantePosorden(NodoArbol nodo)
{
if( nodo == null )
return;
ayudantePosorden(nodo.nodoizquierdo);
ayudantePosorden(nodo.nododerecho);
System.out.print(nodo.datos + " ");
}
}
Luego implementamos la aplicación de árboles binarios
import javax.swing.JOptionPane;
public class PruebaArbol {
public static void main(String args [])

{
Arbol arbol = new Arbol();
int valor;
String Dato;
System.out.println("Insertando los siguientes valores: ");
Dato = JOptionPane.showInputDialog("Inserta el numero de nodos que desea

ingresar");
int n = Integer.parseInt(Dato);
for(int i = 1; i <= n; i++ )

{
Dato = JOptionPane.showInputDialog("Dame el " + i + " valor para colocar en
el Arbol");
valor = Integer.parseInt(Dato);
System.out.print(valor + " ");
arbol.insertarNodo(valor);
}
System.out.println("\n\nRecorrido Preorden");
arbol.recorridoPreorden();
System.out.println("\n\nRecorrido Inorden");
arbol.recorridoInorden();
System.out.println("\n\nRecorrido Postorden");
arbol.recorridoPosorden();
}
}
Salida:
Luego llenamos

EJERCICIOS DE ARBOLES
1. 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.
2. 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).
3. Hacer una función que guarde en un archivo secuencial un árbol binario
simétrico. Definir las estructuras necesarias.
4. Hacer una función que genere un árbol binario simétrico leyendo los datos
desde un archivo secuencial. Definir las estructuras necesarias.
5. Hacer una función que informe si un determinado Empleado
(numero_de_legajo, nombre), se encuentra o no en un archivo secuencial.
Definir las estructuras necesarias.

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.
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.
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:

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

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 utilizaremos el puntero TOP para hacer referencia al primer nodo, LD para
indicar el enlace derecho y LA para indicar el enlace hacia abajo y 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

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])
ALGORITMO DE DIJKSTRA
El algoritmo de Dijkstra determina el camino más corto desde un vértice al resto de los
vértices del grafo. La idea del algoritmo es mantener un conjunto A de nodos "alcanzables"
desde el nodo origen e ir extendiendo este conjunto en cada iteración. Los nodos
alcanzables son aquellos para los cuales ya se ha encontrado su camino óptimo desde el
nodo origen. Para esos nodos su distancia óptima al origen es conocida. Inicialmente A={s}.
Para los nodos que no están en A se puede conocer el camino óptimo desde s que pasa sólo
por nodos de A. Esto es, caminos en que todos los nodos intermedios son nodos de A.
Llamemos a esto su camino óptimo tentativo.
En cada iteración, el algoritmo encuentra el nodo que no está en A y cuyo camino óptimo
tentativo tiene largo mínimo. Este nodo se agrega a A y su camino óptimo tentativo se
convierte en su camino óptimo. Luego se actualizan los caminos óptimos tentativos para los
demás nodos.

Representacion Grafica del algortimo de Dijkstra, como se ve en la figura 2.
Figura 2. Algoritmo de Dikstra
Fuente: Arnold Alejandro Mendoza Larios
A continuacion se implementa el programa en java:
package grafos;
import java.util.ArrayList;
import java.util.List;
import java.util.PriorityQueue;
public class Dijkstra {
static final int MAX = 50;

static final int INF = 1 << 20;
static class Node implements Comparable<Node> {
int first, second;
Node(int d, int p) {
this.first = d;
this.second = p;
}
public int compareTo(Node other) {

if (second > other.second) {
return 1;
}
if (second == other.second) {
return 0;
}
return -1;
}
};
static Scanner sc = new Scanner(System.in);

static List< List< Node>> ady = new ArrayList< List< Node>>();
static int distancia[] = new int[MAX];
static boolean visitado[] = new boolean[MAX];
static PriorityQueue< Node> Q = new PriorityQueue<Node>();
static int V;
static int previo[] = new int[MAX];
static void init() {

for (int i = 0; i <= V; ++i) {
distancia[i] = INF;
visitado[i] = false;
previo[i] = -1;
}
}
static void relajacion(int actual, int adyacente, int peso) {
if (distancia[actual] + peso < distancia[adyacente]) {

distancia[adyacente] = distancia[actual] + peso;
previo[adyacente] = actual;
Q.add(new Node(adyacente, distancia[adyacente]));
}
}
static void print(int destino) {

if (previo[destino] != -1) {
print(previo[destino]);
}
System.out.printf("%d ", destino);
}
static void dijkstra(int inicial) {
init();
Q.add(new Node(inicial, 0));
distancia[inicial] = 0;
int actual, adyacente, peso;
while (!Q.isEmpty()) {
actual = Q.element().first;
Q.remove();
if (visitado[actual]) {
continue;
}
visitado[actual] = true;
for (int i = 0; i < ady.get(actual).size(); ++i) {

adyacente = ady.get(actual).get(i).first;

peso = ady.get(actual).get(i).second;
if (!visitado[adyacente]) {
relajacion(actual, adyacente, peso);
}
}
System.out.println("\n**************Impresion de camino mas

corto**************");
System.out.printf("Ingrese vertice destino: ");
int destino;
destino = sc.nextInt();
print(destino);
System.out.printf("\n");
System.out.printf("Distancias mas cortas iniciando en vertice %d\n",

inicial);
for (int i = 1; i <= V; ++i) {
System.out.printf("Vertice %d , distancia mas corta = %d\n", i,
distancia[i]);
}

int E, origen, destino, peso, inicial;
System.out.println("Ingrese la cantidad de aristas");
V = sc.nextInt();
E = sc.nextInt();
for (int i = 0; i <= V; ++i) {
ady.add(new ArrayList<Node>());
}
for (int i = 0; i < E; ++i) {

origen = sc.nextInt();
destino = sc.nextInt();
peso = sc.nextInt();
ady.get(origen).add(new Node(destino, peso));
}
System.out.print("Ingrese el vertice inicial: ");
inicial = sc.nextInt();
dijkstra(inicial);
}
}
Salida:

EJERCICIOS RESUELTOS DE GRAFOS
1. Implementar un Grafo Dirigido implementado con matrices de adyacencia. Las aristas no
van a tener peso, por lo tanto la matriz sera binaria, un valor de 1 indica que existe una arista entre
dos vertices, y un valor de cero indica que no existe una arista entre los vertices.
package grafos;
import java.lang.ArrayIndexOutOfBoundsException;
import java.lang.UnsupportedOperationException;
import java.lang.RuntimeException;
public class Grafo {

private final int MAX_VERTICES;
private final int MAX_ARISTAS;
private int nroAristas;
private int grafo[][];
//Crea un grafo vacío, con un máximo numero de vertices y aristas

public Grafo(int nroVertices, int nroAristas){
MAX_VERTICES = nroVertices;
MAX_ARISTAS = nroAristas;
this.nroAristas = 0;
grafo = new int[MAX_VERTICES][MAX_VERTICES];

for(int i = 0; i < getMAX_VERTICES();i++){
for (int j = 0; j < getMAX_VERTICES(); j++){
grafo[i][j] = 0;
}
}
}
//Crea un grafo vacío, con un máximo número de vertices, y

//vertices al cuadrado como número máximo de aristas.
public Grafo(int nroVertices){
//Llamada al constructor con dos argumentos
this(nroVertices, nroVertices);
}
//Crea un grafo vacío con un máximo número de vertices = 5

//y máximo numero de aristas = 25.
public Grafo(){
//Llamada al constructor con dos argumentos
this(5,25);
}
public int getMAX_VERTICES()

{
return MAX_VERTICES;
}
public int getMAX_ARISTAS()

{
return MAX_ARISTAS;
}
//Inserta una arista entre dirigida del vertice v1 al vertice v2

public void insertaArista(int v1, int v2)
throws ArrayIndexOutOfBoundsException,
UnsupportedOperationException
{
if(v1 >= MAX_VERTICES || v2 >= MAX_VERTICES){
throw new ArrayIndexOutOfBoundsException("Vertices inválidos,
fuera de rango"+
"\nRango de vertices: 0 - " + (getMAX_VERTICES()
- 1));
}
else if(nroAristas == MAX_ARISTAS){
throw new UnsupportedOperationException("No se puede añadir
más aristas");
}
else{
grafo[v1][v2] = 1;
}
}
//Retorna verdadero si existe una arista dirigida entre los vertices v1 y

v2
public boolean existeArista(int v1, int v2){

fuera de rango"+
- 1));
}
else if(grafo[v1][v2] == 1){
return true;
}
return false;
}
//Elimina la arista entre los vertices v1 y v2

public void eliminaArista(int v1, int v2){
fuera de rango"+
- 1));
}
else if(grafo[v1][v2] == 0){
System.err.println("La arista NO existe");
}
else{
grafo[v1][v2] = 0;
}
}
//Elimina todas las aristas. Se llena toda la matriz de ceros

public void liberaGrafo(){
for(int i = 0; i < grafo.length; i++){
for(int j = 0; j < grafo[i].length; j++){
grafo[i][j] = 0;
}
}
}
public void mostrarGrafo(){

System.out.print(" ");
for(int i = 0; i < MAX_VERTICES; i++)
{
System.out.printf(" %3d", i);
}
for( int i = 0; i < MAX_VERTICES; i++){
System.out.printf(" %3d", i);
for(int j = 0; j < MAX_VERTICES; j++){
System.out.printf(" %3d" ,grafo[i][j]);
}
}
}
// ----- Operaciones para obtener Lista de Adyacencia ----- //

//Verifica si un grafo tiene vertices adyacentes o no
public boolean ListaAdyVacia(int v)
{
int aux = 0;
boolean listaVacia = true;
while(aux < MAX_VERTICES && listaVacia){

if(grafo[v][aux] == 1){
listaVacia = false;
}
else{
aux = aux + 1;
}
}
return listaVacia;
}
//Devuelve el primer vertice adyacente al vertice v

public int primeroListaAdy(int v)
throws RuntimeException
{
int aux = 0;
boolean listaVacia = true;
while(aux < MAX_VERTICES && listaVacia){

if(grafo[v][aux] == 1)
{
listaVacia = false;
}
else
{
aux = aux + 1;
}
}
if(aux == MAX_VERTICES) throw new RuntimeException("La lista de

Adyacencia esta vacía");
return aux;
}
//Retorna el siguiente adyacente, retorna -1 si no hay más adyacentes
public int proxAdy(int v, int ady){
int prox = ady + 1;
while(prox < MAX_VERTICES && grafo[v][prox] == 0){
prox = prox + 1;
}
if(prox == MAX_VERTICES)return -1;
return prox;
}
// ----- Fin de Operaciones para obtener Lista de Adyacencia ----- //

REFERENCIAS BIBLIOGRAFICAS
a) Cairo – Guardati; “Estructuras de Datos”, Segunda Edición, Ed. McGrawHill,Pags.

1-53
b) Aaron M. Tenenbaum – Yedidyah Langsam – Moshe A. Augenstein, “Estructuras de
Datos en C”, Ed. Pretince Hall, Pags. 1-67
c) Herbert Schildt. C++, Guía de Autoenseñanza. Osborne McGraw-Hill, 2001
d) Stanley Lippman, Josie Lajoie. C++ Primer. Addison Wesley, 1998
e) Michael J. Folk, Bill Zoellick, Greg Riccardi. File Structures in C++: Third Edition.
Addison-Wesley, 1998
f) Estructuras de Datos, http://www.infor.uva.es/~cvaca/asigs/edg.html
g) A.V. Aho, J.E. Hopcroft, J.D. Ullman. Estructuras de Datos y Algoritmos. Addison
Wesley, 1988.
h) Gottfried, B. S. (1991). Programación en C. Serie Schaumm. McGraw-Hill.
i) Fco. Javier Ceballos (2000), Java 2 Curso de programación, España, RA-MA.

ANEXO A
GUIA DE LABORATORIO DE ECLIPSE

GUIA DE LABORATORIOS
Laboratorio Nº1
Instalación del Editor Eclipse

¿Qué es Eclipse?
En la web oficial de Eclipse (www.eclipse.org), se define como “An IDE for everything and nothing in
particular” (un IDE para todo y para nada en particular). Eclipse es, en el fondo, únicamente un
armazón (workbench) sobre el que se pueden montar herramientas de desarrollo para cualquier
lenguaje, mediante la implementación de los plugins adecuados. La arquitectura de plugins de
Eclipse permite, además de integrar diversos lenguajes sobre un mismo IDE, introducir otras
aplicaciones accesorias que pueden resultar útiles durante el proceso de desarrollo como:
herramientas UML, editores visuales de interfaces, ayuda en línea para librerías, etc.
1. INSTALACION DE JAVA
Debemos instalar el compilador de Java y la máquina virtual de Java. Estas herramientas las
podemos descargar de:
Java SE Development Kit (descargar el Windows x64 o si tiene un sistema operativo de 32

bits instale el Windows x86).
https://www.java.com/es/download/manual.jsp

Una vez que tenemos el JDK (Java Development Kit) procedemos a instalarlo:
Dependiendo del sistema operativo instalado en su máquina cualquiera de los siguientes archivos
que contienen la máquina virtual de java (JVM):
- Jre-8u73-windows-x64.exe (para sistemas Windows de 64 bits)

- Jre-8ut3-windows-i586.exe (para sistemas Windows de 32 bits)

La versión a instalar conviene que sea la última (en este momento disponemos la versión 8)
Presionamos el botón "next". Haremos la instalación por defecto por lo que presionamos el botón
next nuevamente:

Una vez finalizado el proceso de instalación debe aparecer un diálogo similar a este y presionamos
el botón Close.
2. INSTALACION DE ECLIPSE
Eclipse es un entorno de trabajo profesional, por lo que en un principio puede parecer complejo el
desarrollo de nuestros primeros programas.
Todo programa en Eclipse requiere la creación de un "Proyecto", para esto debemos seleccionar
desde el menú de opciones:
1. Crear la carpeta EjerciciosED sobre el escritorio.

2. Copiar sobre el escritorio de tu equipo la siguiente carpeta que contiene el instalador de
eclipse, que el docente te ha copiado.

3. INGRESAR A ECLIPSE
Para ingresar a eclipse debe hacer 2 click en la carpeta eclipse-standard-kepler-SR2-win32, luego

ingresar a la carpeta eclipse.
Seleccionar la aplicación eclipse, como se ve a continuación:

Se iniciara eclipse
Luego pedirá configurar la carpeta donde se guardaran los programas por defecto, es decir el
directorio del espacio de trabajo, presionamos el botón OK.

Una vez concluido nos deberá salir el siguiente entorno:
Esta es la pantalla inicial de eclipse donde nos muestra una ventana de bienvenida.

Laboratorio Nº2
Estructuras Secuenciales - Condicionales Simples – Compuestas

- Multiples
Objetivo:
 Conocer los tipos de datos del lenguaje java
 Aplicar los diferentes operadores relacionales, aritméticos y lógicos
 Programar estructuras secuenciales, condicionales simples y compuestas y selectivas
múltiples.
Operadores
En una condición deben disponerse únicamente variables, valores constantes y operadores
relacionales.
>Operadores Relacionales:
> (mayor)
< (menor)
>= (mayor o igual)
<= (menor o igual)
== (igual)
!= (distinto)
Operadores Matemáticos
+ (más)
- (menos)
* (producto)
/ (división)
% (resto de una división) Ej.: x=13%5; {se guarda 3}
Operadores Lógicos
&& (y)
|| (o)
! (negación)
ESTRUCTURAS SECUENCIALES
El orden en que se ejecutan por defecto las sentencias de un programa es secuencial. Esto significa
que las sentencias se ejecutan en secuencia, una después de otra, en el orden en que aparecen
escritas dentro del programa.

La estructura secuencial está formada por una sucesión de instrucciones que se ejecutan en orden
una a continuación de la otra.
Actividades para este laboratorio:

1. Crear el proyecto EstructurasSecuenciales
2. Crear el paquete secuenciales
3. Crear la Clase AreaRectangulo
4. Crear la clase DatosBebe
Creamos el proyecto:

Creamos el paquete secuenciales
Seleccionar el proyecto estructurasSecuenciales

Ejemplo 1.
Escribir un programa que permita calcular el área del rectángulo, dado la base y la altura por el
usuario.
A=B * H
Donde:
A= área del rectángulo, será de tipo entero.
B= base del rectángulo, será de tipo entero.
H= altura del rectángulo, será de tipo entero.
Actividades
1. Crear la clase AreRectangulo en el paquete secuenciales
Ir al explorador de proyectos / seleccionar el paquete secuenciales / botón derecho / new / class
Escribir el nombre de la clase AreaRectangulo

Escribimos el código del programa en el programa principal:

Salida:
EJEMPLO 2
Escribir un programa que permita leer los datos de un recién nacido, estos datos son: nombre,
talla, peso, hora de nacimiento, género y el nombre de la mamá. Luego de leer que los imprima.
Actividades:
1. Crear la clase DatosBebe en el paquete secuenciales

Escribir el siguiente código:
package secuenciales;
public class DatosBebe {

Scanner teclado=new Scanner(System.in);

String nom, mama;
float horaNac, peso;
int talla;
char genero;
System.out.print("Ingrese el nombre del bebe...");

nom=teclado.next();
System.out.print("Ingrese el peso del bebe en kg...");
peso=teclado.nextFloat();
System.out.print("Ingrese la talla del bebe en cm...");
talla=teclado.nextInt();
System.out.print("Ingrese el genero del bebe...");
genero=(teclado.next()).charAt(0);
System.out.print("Ingrese el nombre de la mama del bebe...");
mama=teclado.next();
System.out.println("\n \n Nombre: "+nom);

System.out.println("Peso en kg. "+peso);
System.out.println("Talla en cm. "+talla);
System.out.println("Genero: "+genero);
System.out.println("Nombre Madre: "+mama);
}
Salida

ESTRUCTURAS SELECTIVAS
Las estructuras selectivas son aquellas que permiten realizar acciones de acuerdo al resultado
de la evaluación de una condición:
Estas estructuras son:
 Estructuras Selectivas Simples (if )

 Estructuras Selectivas Compuestas (if-else)
 Estructuras Selectivas Multiples( switch-case)
Actividades para el laboratorio de estructuras selectivas

Para los programas de estructuras selectivas se pide realizar las siguientes actividades:
2. Crear el proyecto EstructurasSelectivas en la Carpeta EjerciciosED

3. Crear el paquete selectivas en el proyecto EstructurasSelectivas
 ESTRUCTURA SELECTIVA SIMPLE.

se evalúa la condición y si ésta se cumple se ejecuta una determinada acción o grupo de
acciones. En caso contrario se saltan dicho grupo de acciones.
if(expresión_booleana){
instrucción 1
instrucción 2
.......
}
Representación gráfica:
Condicion verdad
operaciones
Falso

Se trata de una estructura CONDICIONAL SIMPLE porque por el camino del verdadero hay
actividades y por el camino del falso no hay actividades.
Por el camino del verdadero pueden existir varias operaciones, entradas y salidas, inclusive
ya veremos que puede haber otras estructuras condicionales.
Ejemplo 1.
Ingresar el sueldo de una persona, si supera los 3000 Bs. mostrar un mensaje en pantalla
indicando que debe pagar impuestos.
Diagrama de flujo:
Podemos observar lo siguiente: Siempre se hace la carga del sueldo, pero si el sueldo que
ingresamos supera 3000 pesos se mostrará por pantalla el mensaje "Esta persona debe
abonar impuestos", en caso que la persona cobre 3000 o menos no aparece nada por
pantalla.
Programa:
Actividades:
1. Crear la Clase EstructuraCondicionalSimple1 en el paquete Selectivas.

package selectivas;
public class EstructuraSelectivaSimple1 {

float sueldo;
System.out.print("Ingrese el sueldo:");
sueldo=teclado.nextFloat();
if (sueldo>3000) {
System.out.println("Esta persona debe pagar impuestos");
}
}
Salida cuando el sueldo es mayor 3000.
Salida cuando el sueldo es menor a 3000.
 ESTRUCTURA CONDICIONAL COMPUESTA.
Se evalúa la condición y si ésta se cumple se ejecuta una determinada instrucción o grupo

de instrucciones. Si no se cumple se ejecuta otra instrucción o grupo de instrucciones.
if(expresión booleana){
instrucciones 1
}
else{
instrucciones 2
}

Falso (Condición)
Verdad
Operación 2 Operación 1
EJEMPLO:
Realizar un programa que solicite ingresar dos números distintos y muestre por pantalla el
mayor de ellos.
Diagrama de flujo:
Se hace la entrada de num1 y num2 por teclado. Para saber cuál variable tiene un valor
mayor preguntamos si el contenido de num1 es mayor (>) que el contenido de num2, si la
respuesta es verdadera vamos por la rama de la derecha e imprimimos num1, en caso que
la condición sea falsa vamos por la rama de la izquierda (Falsa) e imprimimos num2.
Como podemos observar nunca se imprimen num1 y num2 simultáneamente.

Estamos en presencia de una ESTRUCTURA CONDICIONAL COMPUESTA ya que tenemos
actividades por la rama del verdadero y del falso.
Programa:
Actividades:
1. Crear la Clase EstructuraCondicionalCompuesta1 en el paquete Selectivas y realizar el

siguiente ejemplo
public class EstructuraSelectivaCompuesta1 {

int num1,num2;
System.out.print("Ingrese primer valor:");
num1=teclado.nextInt();
System.out.print("Ingrese segundo valor:");
num2=teclado.nextInt();
if (num1>num2) {
System.out.print(num1);
} else {
System.out.print(num2);
}
Salida por verdad:
Salida por falso:

 ESTRUCTURA CONDICIONAL COMPUESTA IF-ELSE-IF
Se obtiene anidando sentencias if ... else. Permite construir estructuras de selección más
complejas.
if (expresion_booleana1)
instruccion1;
else if (expresion_booleana2)
instruccion2;
else
instruccion3;
Cada else se corresponde con el if más próximo que no haya sido emparejado.
Una vez que se ejecuta un bloque de instrucciones, la ejecución continúa en la siguiente

instrucción que aparezca después de las sentencias if .. else anidadas.
El diagrama de flujo que se presenta contiene dos estructuras condicionales. La principal se

trata de una estructura condicional compuesta y la segunda es una estructura condicional
simple y está contenida por la rama del falso de la primera estructura.

EJEMPLO
Escribir un programa que pida por teclado tres notas de un alumno, calcule el promedio e
imprima alguno de estos mensajes:
Si el promedio es >=7 mostrar "Promocionado".

Si el promedio es >=4 y <7 mostrar "Regular".
Si el promedio es <4 mostrar "Reprobado".
Diagrama de flujo:
Analicemos el siguiente diagrama. Se ingresan tres valores por teclado que representan las
notas de un alumno, se obtiene el promedio sumando los tres valores y dividiendo por 3
dicho resultado (Tener en cuenta que si el resultado es un valor real solo se almacena la
parte entera).
Primeramente preguntamos si el promedio es superior o igual a 7, en caso afirmativo va por

la rama del verdadero de la estructura condicional mostramos un mensaje que indica
"Promocionado" (con comillas indicamos un texto que debe imprimirse en pantalla).
En caso que la condición nos de falso, por la rama del falso aparece otra estructura
condicional, porque todavía debemos averiguar si el promedio del alumno es superior o
igual a cuatro o inferior a cuatro.
Programa:
Actividades:
1. Crear la clase EstructuraSelectivaAnidada en el paquete selectivas
package selectivas;
public class EstructuraCondicionalAnidada {

int nota1,nota2,nota3;
System.out.print("Ingrese primer nota:");

nota1=teclado.nextInt();
System.out.print("Ingrese segunda nota:");
System.out.print("Ingrese tercer nota:");
int promedio=(nota1 + nota2 + nota3) / 3;
if (promedio>=7) {
System.out.print("Promocionado");
} else if (promedio>=4) {
System.out.print("Regular");
} else {
System.out.print("Reprobado");
}
}

Salida 1.
Salida 2.
Salida 3.
 ESTRUCTURA SELECTIVA MULTIPLE (SWITCH-CASE)

Se utiliza para seleccionar una de entre múltiples alternativas.
La forma general de la instrucción switch en Java es la siguiente:
switch (expresión){
case valor 1:
instrucciones;
break;
case valor 2:
instrucciones;
break;
· · ·
default:
instrucciones;
}
La instrucción switch se puede usar con datos de tipo byte, short, char e int. También con
tipos enumerados y con las clases envolventes Character, Byte, Short e Integer. A partir de
Java 7 también pueden usarse datos de tipo String en un switch.
Funcionamiento de la instrucción switch:
- Primero se evalúa la expresión y salta al case cuya constante coincida con el valor de la
expresión.
– Se ejecutan las instrucciones que siguen al case seleccionado hasta que se encuentra un
break o hasta el final del switch. El break produce un salto a la siguiente instrucción a
continuación del switch.
– Si ninguno de estos casos se cumple se ejecuta el bloque default (si existe). No es
obligatorio que exista un bloque default y no tiene porqué ponerse siempre al final, aunque
es lo habitual.
EJEMPLO.
Escribir un programa que lee por teclado un mes (número entero) y muestra el nombre del
mes.
Programa:
Actividades
1. Crear la clase SelectivaMultiple dentro del paquete selectivas
package selectivas;
public class SelectivaMultiple {

int mes;
Scanner teclado = new Scanner(System.in);
System.out.print("Introduzca un numero de mes: ");
mes = teclado.nextInt();
switch (mes)
{
case 1: System.out.println("ENERO");
break;
case 2: System.out.println("FEBRERO");
break;

case 3: System.out.println("MARZO");
break;
case 4: System.out.println("ABRIL");
break;
case 5: System.out.println("MAYO");
break;
case 6: System.out.println("JUNIO");
break;
case 7: System.out.println("JULIO");
break;
case 8: System.out.println("AGOSTO");
break;
case 9: System.out.println("SEPTIEMBRE");
break;
case 10: System.out.println("OCTUBRE");
break;
case 11: System.out.println("NOVIEMBRE");
break;
case 12: System.out.println("DICIEMBRE");
break;
default : System.out.println("Mes no válido");
}
Salida
PROBLEMAS PROPUESTOS
1. Realizar un programa que lea por teclado dos números, si el primero es mayor al segundo
informar su suma y diferencia, en caso contrario informar el producto y la división del
primero respecto al segundo.
2. Se ingresan tres notas de un alumno, si el promedio es mayor o igual a 51 mostrar un
mensaje "APROBADO".
3. Se ingresa por teclado un número positivo de uno o dos dígitos (1..99) mostrar un mensaje
indicando si el número tiene uno o dos dígitos.
(Tener en cuenta que condición debe cumplirse para tener dos dígitos, un número entero).
4. Se cargan por teclado tres números distintos. Mostrar por pantalla el mayor de ellos.
5. Se ingresa por teclado un valor entero, mostrar una leyenda que indique si el número es
positivo, nulo o negativo.

6. Confeccionar un programa que permita cargar un número entero positivo de hasta tres
cifras y muestre un mensaje indicando si tiene 1, 2, o 3 cifras. Mostrar un mensaje de error
si el número de cifras es mayor.
7. Un postulante a un empleo, realiza un test de capacitación, se obtuvo la siguiente
información: cantidad total de preguntas que se le realizaron y la cantidad de preguntas que
contestó correctamente. Se pide confeccionar un programa que ingrese los dos datos por
teclado e informe el nivel del mismo según el porcentaje de respuestas correctas que ha
obtenido, y sabiendo que:
Nivel máximo: Porcentaje>=90%.

Nivel medio: Porcentaje>=75% y <90%.
Nivel regular: Porcentaje>=50% y <75%.
Fuera de nivel: Porcentaje<50%.
8. Escribir un programa que pida ingresar la coordenada de un punto en el plano, es decir dos
valores enteros x e y (distintos a cero).
Posteriormente imprimir en pantalla en que cuadrante se ubica dicho punto. (1º Cuadrante
si x > 0 Y y > 0 , 2º Cuadrante: x < 0 Y y > 0, etc.)
9. De un operario se conoce su sueldo y los años de antigüedad. Se pide confeccionar un

programa que lea los datos de entrada e informe:
a) Si el sueldo es inferior a 500 y su antigüedad es igual o superior a 10 años, otorgarle un
aumento del 20 %, mostrar el sueldo a pagar.
b) Si el sueldo es inferior a 500 pero su antigüedad es menor a 10 años, otorgarle un
aumento de 5 %.
c) Si el sueldo es mayor o igual a 500 mostrar el sueldo en pantalla sin cambios.
10. Escribir un programa en Java que contiene una una instrucción switch debe leer dos
números enteros por teclado y un operador (de tipo carácter, ejem. +, -, *, /) y muestra el
resultado de la operación.

Laboratorio Nº3
Estructuras Repetitivas
Objetivo:
 Conocer la estructura while, do-while y for.
Las estructuras repetitivas permiten ejecutar de forma repetida un bloque específico de

instrucciones.
Las instrucciones se repiten mientras o hasta que se cumpla una determinada condición.
Esta condición se conoce como condición de salida.
Tipos de estructuras repetitivas:

- ciclo while
- ciclo do – while
- ciclo for

1. Crear el proyecto estructurasRepetitivas en la carpeta EjerciciosED
2. Crear el paquete repetitivas en el proyecto estructurasRepetitivas
 Estructura de repetición WHILE:

Esta estructura primero verifica la condición y luego ejecuta la acción. La acción puede ser una
acción simple o una acción compuesta (bloque de instrucciones encerradas entre llaves).
SINTAXIS:
Para una sola acción:

while (condición)
Acción;
Para varias acciones:
while(condición)
{
Accion1;
Accion2;
.
.
.
Acción n;
}
EJEMPLO
Programa que lee números por teclado. La lectura acaba cuando el número introducido sea
negativo. El programa calcula y muestra la suma de los números leídos.
Actividad
1. Crear la clase RepetitivaWhile en el paquete repetitivas
Programa:
package repetitivas;
public class RepetitivaWhile {

int suma = 0, num;
System.out.print("Introduzca un número: ");
num = teclado.nextInt();
while (num >= 0){
suma = suma + num;
System.out.print("Introduzca un número: ");
num = teclado.nextInt();
}
System.out.println("La suma es: " + suma );

}
Salida:
 Estructura de repetición DO- WHILE:

Este tipo de estructura primero ejecuta la acción y luego verifica la condición. La acción puede ser
simple o compuesta.
SINTAXIS:
do
acción;
while (condición);

do{
Acción1;

Acción2;
Accion n;
}while (condición);
EJEMPLO
Programa que lee un número entre 1 y 10 ambos incluidos
Actividad:
1. Crear la clase RepetitivaDoWhile en el paquete repetivias
public class RepetitivaDoWhile {

int n;
Scanner teclado = new Scanner( System.in );
do {
System.out.print("Escribe un número entre 1 y 10: ");
n = teclado.nextInt();
}while (n<1 || n >10);
System.out.println("Ha introducido: " + n);
}
Salida:
 Estructura de repetición FOR:
Este tipo de estructuras incluye un contador como parte de su estructura, lo cual, quiere decir que

se conoce el número de veces que se repetirá el cuerpo del bucle.
SINTAXIS:
for (inicio; condicion; incremento)

Acción;
for (inicio; condicion; incremento)

{
Acción1;
Acción2;
.
.
.
Accion n;
EJEMPLO:
Programa que muestra el valor de a, b y su suma mientras que la suma de ambas es
menor de 10. En cada iteración el valor de a se incrementa en 1 unidad y el de b en 2.
Actividad:
1. Crear la clase RepetitivaFor en el paquete repetitivas
Programa:
public class RepetitivaFor {

int a, b;
for(a = 1, b = 1; a + b < 10; a++, b+=2){
System.out.println("a = " + a + " b = " + b + "
a + b = " + (a+b));
}
}
Salida
BUCLES ANIDADOS
Bucles anidados son aquellos que incluyen instrucciones for, while o do-while unas dentro
de otras.
Debemos tener en cuenta que las variables de control que utilicemos deben ser distintas.
Los anidamientos de estructuras tienen que ser correctos, es decir, que una estructura
anidada dentro de otra lo debe estar totalmente.
EJEMPLO:
Programa que dibuja un rectángulo sólido de asteriscos. El número de filas y columnas se
pide por teclado
Actividades:
1. Crear la clase BuclesAnidados en el paquete repetitivas

Programa:
import java.util.*;
public class BuclesAnidados {

{
int filas, columnas;
//leer número de filas hasta que sea un número > 0
do{
System.out.print("Introduce número de filas: ");
filas = teclado.nextInt();
}while(filas<1);
//leer número de columnas hasta que sea un número > 0
do{
System.out.print("Introduce número de columnas: ");
columnas = teclado.nextInt();
}while(columnas<1);
for(int i = 1; i<=filas; i++) { //filas
for(int j = 1; j<=columnas; j++){ //columnas
System.out.print(" * ");
}
}
}
}
Salida:

1. Escribir un programa que lea 10 números enteros y luego muestre cuántos valores
ingresados fueron múltiplos de 3 y cuántos de 5. Debemos tener en cuenta que hay
números que son múltiplos de 3 y de 5 a la vez.
2. Realizar un programa que acumule (sume) valores ingresados por teclado hasta ingresar el
9999 (no sumar dicho valor, indica que ha finalizado la carga). Imprimir el valor acumulado
e informar si dicho valor es cero, mayor a cero o menor a cero.
3. En un banco se procesan datos de las cuentas corrientes de sus clientes. De cada cuenta
corriente se conoce: número de cuenta y saldo actual. El ingreso de datos debe finalizar al
ingresar un valor negativo en el número de cuenta.
Se pide confeccionar un programa que lea los datos de las cuentas corrientes e informe:
a)De cada cuenta: número de cuenta y estado de la cuenta según su saldo, sabiendo que:
Estado de la cuenta 'Acreedor' si el saldo es >0.
'Deudor' si el saldo es <0.
'Nulo' si el saldo es =0.
b) La suma total de los saldos acreedores.
4. Escribir un programa que lea n pares de datos, cada par de datos corresponde a la medida
de la base y la altura de un triángulo. El programa deberá informar:
a) De cada triángulo la medida de su base, su altura y su superficie.
b) La cantidad de triángulos cuya superficie es mayor a 12.
5. Desarrollar un programa que solicite la carga de 10 números e imprima la suma de los
últimos 5 valores ingresados.
6. Desarrollar un programa que muestre la tabla de multiplicar del 5 (del 5 al 50)
7. Confeccionar un programa que permita ingresar un valor del 1 al 10 y nos muestre la tabla
de multiplicar del mismo (los primeros 12 términos)
Ejemplo: Si ingreso 3 deberá aparecer en pantalla los valores 3, 6, 9, hasta el 36.
8. Escribir un programa para realizar la carga de 10 valores enteros por teclado. Se desea
conocer:
a) La cantidad de valores ingresados negativos.
b) La cantidad de valores ingresados positivos.
c) La cantidad de múltiplos de 15.
d) El valor acumulado de los números ingresados que son pares.

Laboratorio Nº4
Cadenas en Java
Objetivo:
9. Conocer el tipo de dato String (cadena) y sus diferentes funciones.
La clase String tiene varios métodos muy útiles como saber su longitud, trocear la cadena, etc.
Recuerda que para invocar un método debemos escribir el nombre del String, un punto y el nombre
del método, más sus parámetros. Es importante que si necesitas almacenar el valor devuelto, uses
una variable para ello. Por ejemplo:
String cadena=”americano”;
boolean empiezaPor=cadena.startWith (“a”);
Estos son los métodos más conocidos:

Método Descripción Parámetro Tipo de
dato
devuelto
charAt Devuelve el carácter Un char
indicado por parámetro parámetro
int
compareTo Sirve para comparar Un int
cadenas, devuelve un número parámetro - Si
según el resultado. String, devuelve un
Recuerda que no sigue el la cadena número
alfabeto español, lo a mayor que
compara según la tabla comparar. 0: la
ASCII. primera
cadena es
mayor que
la segunda.
- Si
devuelve un
0: las
cadenas son
iguales.
- Si
devuelve un
número
menor que
0: la
primera
cadena es
menor que
la segunda

compareToIgnoreCa Es igual que el anterior, Un int
se pero ignorando mayúsculas o parámetro - Si
minúsculas. String, devuelve un
la cadena número
a mayor que
comparar 0: la
primera
cadena es
mayor que
la segunda.
- Si
devuelve un
0: las
cadenas son
iguales.
- Si
devuelve un
número
menor que
0: la
primera
cadena es
menor que
la segunda
concat Concatena dos cadenas, es Un Un nuevo
como el operador +. parámetro String con
String, las cadenas
la cadena concatenada
a s.
concatena
r
copyValueOf Crea un nuevo String a Un array String
partir de un array de char. de char
Este método debe invocarse
de manera estática, es
decir,
String.copyValueOf(array_ch
ar)
endWith Indica si la cadena acaba String boolean
con el String pasado por
parámetro.
equals Indica si una cadena es String boolean
igual que otra.
equalsIgnoreCase Es igual que el anterior, String boolean
pero ignorando mayúsculas o
minúsculas.
getBytes Devuelve un array de bytes Ningún Un array de
con el código ASCII de los parámetro bytes
caracteres que forman el
String.
indexOf Devuelve la posición en la String o int
cadena pasada por parámetro char
desde el principio. -1 si
no existe.
indexOf Igual que el anterior, pero String o int
ademas le indicamos la char, el
posición desde donde segundo
empezamos a buscar. parámetro
es un int
lastIndexOf Devuelve la posición en la String o int
cadena pasada por parámetro char
desde el final. -1 si no
existe.
lastIndexOf Igual que el anterior, pero String o int
ademas le indicamos la char, el
posición desde donde segundo
empezamos a buscar. parámetro
es un int
lenght Devuelve la longitud de la Ningún int
cadena. parámetro
matches Indica si la cadena cumple String boolean
con la expresión pasada
como parámetro.
replace Devuelve un String Dos String
cambiando los caracteres parámetro
que nosotros le indiquemos. s char,
el
primero
es el
carácter
que
existe en
el String
y el
segundo
por el
que
queremos
cambiar.
replaceFirst Devuelve un String Dos String
intercambiando solo la parametro
primera coincidencia. s String,
el
primero
son los
caractere
s que
existe en
el String
y el
segundo
por el
que
queremos
cambiar.
replaceAll Devuelve un String Dos String
intercambiando todas las parametro
coincidencias que se s String,
encuentren. el
primero
son los
caractere
s que
existe en
el String
y el
segundo
por el
que
queremos
cambiar.
startsWith Indica si la cadena empieza String boolean
por una cadena pasada por
parámetro.
substring Trocea un String desde una Dos String
posición a otra. parámetro
s int,
indica
desde
donde
empieza
hasta
donde
acaba,
este
ultimo no
se
incluye.
toCharArray Devuelve en un array de Ningún Un array de
char, todos los caracteres parámetro char
de una String.
toLowerCase Convierte el String a Ningún String
minúsculas. parámetro
toUpperCase Convierte el String a Ningún String
mayúsculas. parámetro
trim Elimina los espacios del Ningún String
String. parámetro
valueOf Transforma una variable Un String
primitiva en un String. parámetro
Para invocarse debe usarse , que
con String. Por ejemplo, puede ser
String.valueOf(variable) un:
boolean
char
double
int
float
long

Array de
char
Referenci
a a un
objeto

1. Crear el proyecto Cadenas
2. Crear el paquete cadenaEjemplos
EJEMPLO 1.
Solicitar el ingreso de dos apellidos. Mostrar un mensaje si son iguales o distintos.
PROGRAMA:
Actividad:
1. Crear una clase ComparaApellidos en el paquete cadenaEjemplos
package cadenaEjemplos;
public class ComparaApellidos {

String apellido1,apellido2;
System.out.print("Ingrese primer apellido:");
apellido1=teclado.next();
System.out.print("Ingrese segundo apellido:");
apellido2=teclado.next();
if (apellido1.equals(apellido2)) {
System.out.print("Los apellidos son iguales");
} else {
System.out.print("Los apellidos son distintos");
}

Salida:
EJEMPLO 2
Hacer un programa que ingrese una cadena de caracteres y determine el número de mayúsculas y
el número de minúsculas.
PROGRAMA:
Actividad:
1. Crear la clase ContarMayMin en el paquete cadenaEjemplos
public class ContarMayMin {
public static int contarMayusculas(String cadena) {

int n = 0;
for (int i = 0; i < cadena.length(); i++) {
if(cadena.charAt(i)> 64 && cadena.charAt(i)<91)
n++;
}
return n;
}
public static int contarMinusculas(String cadena) {

int n = 0;
for (int i = 0; i < cadena.length(); i++) {
if(cadena.charAt(i)> 96 && cadena.charAt(i)<123)
n++;
}
return n;
}

String chain;
System.out.print("Ingrese una cadena de caracteres: ");
chain = teclado.nextLine();
System.out.println("El numero de Mayusculas de la cadena es : " +
contarMayusculas(chain));
System.out.println("El numero de Minusculas de la cadena es : " +
contarMinusculas(chain));
Salida:
EJEMPLO 3.
Hacer un programa que reciba un string S y devuelva el mismo string S al cual se le han eliminado
los espacios.
Programa:
Actividad:
public class QuitarEspacios {

public static String eliminarEspacios(String cadena) {
String temp="";
char caracter;
for(int i=0;i<cadena.length();i++){
caracter=cadena.charAt(i);
if(!Character.isWhitespace(caracter))
temp=temp+caracter;
}
return temp;
}
String cade;
System.out.print("Ingrese una cadena de caracteres: ");
cade = eliminarEspacios(teclado.nextLine());
System.out.println("La cadena sin espacios es: "+cade);
}
}
Salida:
1. Escribir un programa que reciba como datos una cadena de caracteres y un carácter y
reporta el número de veces que se encuentra el carácter en la cadena.
2. Implemente un programa que indique si una palabra es un palíndrome . Una palabra es

palidrome si se lee igual de izquierda a derecha que de derecha a izquierda.
3. Implemente un programa que reciba una cadena S y una letra X, y coloque en mayúsculas
cada ocurrencia de X en S. (la función debe modificar la variable S).
4. Ingresar una cadena y determinar cuantas palabras se encuentran en la cadena. Cada

palabra se separa por medio de un espacio en blanco.
5. Hacer un programa que al recibir como datos dos cadenas de caracteres forme una tercera
cadena intercalando los caracteres de las palabras de las cadenas recibidas.
Laboratorio Nº5
Wrapper clases
Tipos primitivos
Una variable primitiva es un nombre relacionado a una localidad de memoria que almacena un valor.
Los datos primitivos se utilizan en expresiones que manejan los operadores aritméticos y lógicos
que se definen en el lenguaje
Tipos objeto
Una variable objeto es una referencia a un bloque de memoria que contiene un objeto. Los objetos
pueden contener una gran variedad de operaciones definidas por el usuario que mejoran la
aplicación
Java ha designado clases que nos permiten convertir un valor de un tipo primitivo a un objeto del
mismo tipo.
Así, un objeto de tipo Integer puede contener el valor de una variable primitiva tipo int, pero incluye
operaciones para accederlo y desplegarlo.
Definición de Wrapper classes

Existe una clase envolvente por cada tipo primitivo en Java.
Se llaman envolventes porque guardan o envuelven un valor de tipo primitivo al interior de un

objeto.
3 Un EnteroEnvuelto
Tabla de Wrapper clases
Tipo primitivo Wrapper Class
byte Byte
short Short
int Int
long Long
float Float
double Double
boolean Boolean
char Character
Wrapper clases
Object
number Character Boolean
Byte short Integer Long Float Double
Creación de Objetos de Wrapper classes

Existen 2 formas de crear estos objetos:
 Dando un primitivo como argumento:
Integer unEnteroEnvuelto;
unEnteroEnvuelto = new Integer(3);
 Dando un String como argumento:
Integer unEnteroEnvuelto2;
unEnteroEnvuelto2 = new Integer(“-345”);
Operaciones
Para obtener el primitivo envuelto:
Integer objA;
objaA = new Integer(3);
int n = objA.intValue( ) ;
Nota: Así como hay intValue() hay tambien floatValue(), doubleValue(), etc…
Para comparar objetos:
Integer objA, objB;

objA = new Integer(3);
objB = new Integer(4);
int t = objA.compareTo(objB) ;
boolean b = objA.equals(objB) ;
Métodos Static en Wrapper classes

Operaciones:
Para convertir de String a primitivo:
int n = Integer.parseInt(“123”) ;
Para convertir a String en diferentes bases:
String s1 = Integer.toString(45) ;
String s2 = Integer.toString(45, 2) ;
La Clase Character
Los métodos static que pueden resultar muy útiles para el manejo de caracteres son:
public static boolean isLetter(char ch)

public static boolean isDigit(char ch)
public static boolean isWhitespace(char ch)
public static boolean isUpperCase(char ch)
public static boolean isLowerCase(char ch)
public static char toUpperCase(char ch)

public static char toLowerCase(char ch)
EJEMPLO 1.
public static String cleanString(String str){
String s = “”;
for (int i = 0; i<str.length( ); i++){
if (Character.isLetter(str.charAt(i)))
s= s + Character.toUpperCase(str.charAt(i));

}
return s;
}
Ejemplos:
Integer objA = new Integer(35)
Integer objB = new Integer(50);
int t = objA.compareTo(objB); // t < 0 porque 35 < 50
boolean b = objB.equals(new Integer(“50”)); // b is true
Integer objMin = (objA.compareTo(objB) > 0) ? objA :
objB;

Libro de Estructura de Datos en Java de Katy Version Ii PDF

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Libro de Estructura de Datos en Java de Katy Version Ii PDF

Загружено:

Авторское право:

Доступные форматы

Estructuras de Datos en Java

Katya Maricela Pérez Martínez

Lic Katya Perez Martinez 2 Estructura de Datos

Lic Katya Perez Martinez 4 Estructura de Datos

Lic Katya Perez Martinez 5 Estructura de Datos

Todo programa en java está conformado por una o más clases.

Cada clase debe tener un nombre único.

EL KIT DE DESARROLLO JAVA (JDK)

Lic Katya Perez Martinez 6 Estructura de Datos

En este texto se utiliza el Eclipse.

Lic Katya Perez Martinez 7 Estructura de Datos

Ingresar al entorno integrado de Eclipse de la siguiente manera:

Para ingresar a eclipse debe hacer 2 clics en la carpeta eclipse-standard-kepler-SR2-win32, que

Ejecutar la aplicación eclipse.

Lic Katya Perez Martinez 8 Estructura de Datos

Lic Katya Perez Martinez 9 Estructura de Datos

Seleccionamos la carpeta de EjerciciosED que se encuentra sobre el escritorio.

Luego de aceptar nos muestra la siguiente pantalla:

Lic Katya Perez Martinez 10 Estructura de Datos

Lic Katya Perez Martinez 11 Estructura de Datos

CREACION DE PROYECTOS EN JAVA ECLIPSE

Menú / File / New / Project

Tal como se ve en la figura siguiente:

Lic Katya Perez Martinez 12 Estructura de Datos

Lic Katya Perez Martinez 13 Estructura de Datos

Lic Katya Perez Martinez 14 Estructura de Datos

Un paquete es un conjunto de clases. Crearemos en este primer ejemplo el paquete Ejercicios

Seleccionar desde Package Explorer / EjemploProyecto / botón derecho / New / Package

Luego escribimos el nombre del proyecto como se ve a continuación:

Lic Katya Perez Martinez 15 Estructura de Datos

Luego de esto vemos el paquete:

Seleccionar EjemploProyecto / paquete ejercicios / botón derecho / new / class

Lic Katya Perez Martinez 16 Estructura de Datos

A continuación le daremos el nombre de la clase Mensajes y habilitamos la cabecera del programa

Vemos los cambios que han ocurrido en el Package Explorer

Lic Katya Perez Martinez 17 Estructura de Datos

Un último cambio observable es que la vista “Outline”, que se encuentra a la derecha, se ha

AGREGAMOS CODIGO AL PROGRAMA PRINCIPAL

Escribimos el siguiente código:

Lic Katya Perez Martinez 18 Estructura de Datos

Para ejecutar ir al Menu / Run / Run

Nos saldrá el siguiente mensaje al que daremos ok.

Lic Katya Perez Martinez 19 Estructura de Datos

COMO ABRIR UN PROYECTO EXISTENTE

Ejemplo.- Abriremos un proyecto que se llama SumaDosNumeros.

Lic Katya Perez Martinez 20 Estructura de Datos

Lic Katya Perez Martinez 21 Estructura de Datos

Luego nos pedirá que busquemos la localización del proyecto:

Lic Katya Perez Martinez 22 Estructura de Datos

En este caso seleccionamos el proyecto que anteriormente se realizo, y este proyecto es

Lic Katya Perez Martinez 23 Estructura de Datos

Luego tenemos el proyecto abierto:

Lic Katya Perez Martinez 24 Estructura de Datos

C= número entero, es la suma de A y B

Lic Katya Perez Martinez 25 Estructura de Datos

Seleccionar del explorador de proyecto SumaDosNumeros/ botón derecho/ New /

Escribimos el nombre del paquete ejersuma.

Lic Katya Perez Martinez 26 Estructura de Datos

CREAR UNA CLASE DENTRO DEL PAQUETE

Seleccionar el paquete ejersuma / botón derecho / new / class

Escribir el nombre de la clase suma y habilitamos la cabecera del programa principal

Lic Katya Perez Martinez 27 Estructura de Datos

Lic Katya Perez Martinez 28 Estructura de Datos