You are on page 1of 112

UNIVERSIDAD SALESIANA

DE BOLIVIA
CARRERA INGENIERIA DE SISTEMAS

DOSSIER
PROGRAMACION II
Tercer Semestre

Lic. Katya Maricela Pérez Martínez
Lic. Gladys Francisca Chuquimia Mamani
Lic. Carmen Rosa Mollinedo Laura

INDICE
1.

CAPÍTULO I...........................................................................................1

INTRODUCCIÓN A LAS ESTRUCTURAS DE DATOS...........................................1
1.1.
INTRODUCCIÓN................................................................................................ 1
1.2.
ESTRUCTURAS FUNDAMENTALES.....................................................................1
1.3.
ABSTRACCIÓN.................................................................................................. 2
1.4.
DEFINICIÓN DE ESTRUCTURAS DE DATOS........................................................2
1.5.
T.D.A. (TIPO DE DATO ABSTRACTO)..................................................................3
1.6.
CLASIFICACIÓN DE LAS ESTRUCTURAS DE DATOS...........................................3
1.6.1. ESTRUCTURAS DE DATOS ESTÁTICAS...........................................................4
1.6.2. ESTRUCTURAS DE DATOS DINÁMICAS..........................................................4
1.6.3. ESTRUCTURAS DE DATOS LINEALES.............................................................4
1.6.4. ESTRUCTURAS DE DATOS NO LINEALES.......................................................4
1.7.
ESTRUCTURAS DE DATOS ESTÁTICAS...............................................................4
1.7.1. ARREGLOS................................................................................................... 4
1.7.2. ARREGLOS UNIDIMENSIONALES (VECTORES)...............................................5
1.7.3. Declaración de vectores...............................................................................5
Ejercicios................................................................................................................. 6
EJERCICIOS PROPUESTOS........................................................................................8
1.7.4. CADENAS DE CARACTERES...................................................................................10
1.7.5. LOS METODOS DE LA CLASE STRING.............................................................11
1.8.
ARREGLOS MULTIDIMENSIONALES..................................................................18
1.8.1. Matrices..................................................................................................... 18

DECLARACIÓN DE UNA MATRÍZ..................................................................................19

OPERACIONES CON ARREGLOS BIDIMENSIONALES...........................................................20
1.9.
REGISTROS (ESTRUCTURAS)..........................................................................21
1.9.1. DEFINICIÓN DE REGISTRO Y DECLARACIÓN DE LA VARIABLE DE REGISTRO.
22
1.9.2. ACCESO A LOS CAMPOS DE UN REGISTRO.................................................22
1.9.3. ARRAYS DE ESTRUCTURAS:........................................................................24
1.9.4. ESTRUCTURAS ANIDADAS:.........................................................................24
1.10. CONJUNTOS.................................................................................................... 26
1.10.1. DEFINICIÓN DE CONJUNTOS...................................................................26
1.11. MATRICES POCO DENSAS...............................................................................27
1.12. ARCHIVOS...................................................................................................... 30
2.

CAPÍTULO II........................................................................................35

PILAS....................................................................................................... 35
2.1.
INTRODUCCIÓN.............................................................................................. 35
2.2.
REPRESENTACIÓN DE LAS PILAS....................................................................36
2.3.
ESTRUCTURA DE UNA PILA UTILIZANDO ARREGLOS.......................................37
2.4.
OPERACIONES CON PILAS..............................................................................38
2.5.
IMPLEMENTACIÓN DEL TAD PILA EN LENGUAJE JAVA.......................................38
2.6.
APLICACIONES................................................................................................ 42
2.6.1. LLAMADAS A SUBPROGRAMAS...................................................................43
........................................................................................................................ 44
2.6.2. RECURSIÓN................................................................................................44
2.6.3. TRATAMIENTO DE EXPRESIONES ARITMÉTICAS..........................................44
3.

CAPÍTULO III
3.1.

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

INTRODUCCIÓN.............................................................................................. 47

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 2

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

CAPÍTULO RECURSIVIDAD....................................................................60
4.1.
4.2.
4.3.
4.4.
4.5.
4.6.
4.7.
4.8.

5.

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

CAPITULO IV LISTAS ENLAZADAS.........................................................67
5.1.
INTRODUCCIÓN A LAS ESTRUCTURAS DE DATOS DINÁMICA..........................67
5.2.
MECANISMOS PARA ENLAZAR INFORMACIÓN.................................................68
5.3.
LISTAS ENLAZADAS........................................................................................68
5.4.
TIPO DE DATO ABSTRACTO NODO..................................................................70
5.5.
CONSTRUCCIÓN DE UN TAD LISTA ENLAZADA LINEAL SIMPLE.......................70
5.6.
OPERACIONES BÁSICAS SOBRE LISTAS ENLAZADAS.......................................71
Creación de una lista vacía...................................................................................71
a) Inserción al Final de la lista............................................................................71
b)
Inserción al Inicio de la lista..........................................................................72
d) Eliminar el nodo del inicio de la Lista............................................................73
e) Eliminar el nodo del Final de la Lista.............................................................74
5.7.
IPLEMENTACIÓN EN EL LENGUAJE JAVA DE LA CLASE LISTAS LINEALES..........74
5.8.
LISTAS DOBLEMENTE ENLAZADAS.................................................................78
5.9.
LISTAS CIRCULARES DOBLES..........................................................................81

6.

CAPITULO VI ÁRBOLES Y GRAFOS........................................................84
6.1.
6.2.
6.3.
6.4.
6.5.
6.6.
A.
A.
A.
A.
6.7.
6.8.
6.9.

DEFINICIÓN ÁRBOL......................................................................................... 84
CONCEPTOS BÁSICOS....................................................................................84
CARACTERÍSTICAS DE LOS ARBOLES BINARIOS..............................................86
TRANSFORMACIÓN DE UN ARBOL GRAL. EN UN ARBOL BINARIO...................87
REPRESENTACIÓN DE UN ÁRBOL EN MEMORIA..............................................87
CLASIFICACIÓN DE ARBOLES BINARIOS..........................................................88
B. DISTINTO....................................................................................................... 89
B. SIMILARES..................................................................................................... 89
B. EQUIVALENTES..............................................................................................89
B. COMPLETOS.................................................................................................. 89
RECORRIDO DE UN ARBOL BINARIO...............................................................90
ARBOLES ENHEBRADOS.................................................................................91
ARBOLES BINARIOS DE BÚSQUEDA................................................................91

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 3

....11.15....................................................... 6............94 REPRESENTACIÓN EN MEMORIA ENLAZADA................ Katya Perez Martinez Page 4 ............................................................96 CAMINO MÍNIMO....... 6..................................................................................................... 6.......................................10............13....12..................... GRAFOS...14..94 OPERACIONES SOBRE GRAFOS................................. 6..... 6....................................6.............92 REPRESENTACIÓN EN MEMORIA SECUENCIAL....... 98 [Estructura de Datos] Lic................................. 92 DEFINICIONES BÁSICAS.

abstracción en el sentido de que se ignoran algunas propiedades de los objetos reales. caracteres. INTRODUCCIÓN Para procesar información en un computador es necesario hacer una abstracción de los datos que tomamos del mundo real. como son los números enteros.1. pues la memoria del ordenador es finita.”  “Escribir en C o C++ es como utilizar un sierra eléctrica sin ningún tipo de protección. 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.1. números reales. 1. Los punteros (si los tiene) son también un tipo de datos. ESTRUCTURAS FUNDAMENTALES Los datos a procesar por una computadora se clasifican en:  Simples  Estructurados Los datos simples ocupan sólo una casilla de memoria. En realidad suministra un subconjunto de éstos. Capítulo I Introducción a las Estructuras De Datos  “Escribir en C o C++ es como utilizar un sierra eléctrica sin ningún tipo de protección.” — Bob Gray — Bob Gray 1. por tanto una variable simple hace referencia a un único valor a la vez. es decir. El tamaño de todos los tipos de datos depende de la máquina y del compilador sobre los que se trabaja. . se simplifican. Cualquier lenguaje suministra una serie de tipos de datos simples.2.

Ejemplos: Dato Simple Declaramos una variable A de tipo entero y asignamos el valor 25. se tomará como herramienta para los programas y representar las diferentes estructuras de datos el Lenguaje C++ y programas y representar las diferentes estructuras de datos el Lenguaje C++ y Java. DEFINICIÓN DE ESTRUCTURAS DE DATOS [Estructura de Datos] Lic.50. A = 20 30 40 50 60 Identificador 1.3. Tiene varios componentes.60}. A = 25. se tomará como herramienta para los Cabe hacer notar que en el presente texto. Java. Cabe hacer notar que en el presente texto. 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. int A[5] .40. 1. A int A.30.4. Katya Perez Martinez Page 2 . A = {20.  Identificador 25 Dato Estructurado Declaramos un dato compuesto o estructurado A que tendrá 5 elementos de tipo entero.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.

(TIPO DE DATO ABSTRACTO) Al diseñar una estructura de datos con la técnica de abstracción pasa a ser un TDA.A. que no debiera estar presente en el TAD. debido a que no se cuenta con elementos que nos permitan realizar esta operación. que:  Puede implementarse en cualquier lenguaje  Puede aplicarse en cualquier concepto Ejemplo: Abstraemos el concepto Estudiante ESTUDIANTE Nombre del TAD Elementos Operaciones o métodos Ru: entero Nombre: Cadena Sexo: carácter Direccion: Cadena LeerDatosEstudiante () ImprimirDatosEstudian te () ModificarDireccion() CalcularNotaFinal() Como se puede notar existe una operación No Permitida denominada: CalcularNotaFinal(). 1.6. CLASIFICACIÓN DE LAS ESTRUCTURAS DE DATOS Las estructuras de datos desde el punto de vista de asignación de memoria. T.5. Katya Perez Martinez Page 3 . 1.Una estructura de datos es cualquier colección de datos organizados de tal forma que tengan asociados un conjunto de operaciones para poder manipularlos. se clasifican en:  Estructuras de datos estáticas [Estructura de Datos] Lic.D. Recuerda en todo momento que sólo deben incluirse las operaciones que puedan trabajar con los elementos que contiene el TAD.

2.7.6. Por ejmplos: Listas Enlazadas. Desde el punto de vista de la informática. 1.1. Grafos y Matrices 1.4. Registros y Conjuntos. ARREGLOS [Estructura de Datos] Lic. Katya Perez Martinez Page 4 .3. 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. las pilas.6. 1. Por ejemplo tenemos a los Arreglos. 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. existen tres estructuras lineales especialmente importantes: vectores.6. Árboles y Grafos. ESTRUCTURAS DE DATOS LINEALES Las estructuras de datos lineales se derivan de-l concepto de secuencia. 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. ESTRUCTURAS DE DATOS ESTÁTICAS 1.7. Por ejemplo: Árboles. Los diferentes TADs basados en este concepto se diferenciaran por las operaciones de acceso a los elementos y manipulación de la estructura.6. Primero se definen las secuencias como conjuntos de elementos entre los que se establece una relación de predecesor y sucesor.1. las colas y las listas. Estructuras de datos dinámicas También pueden ser clasificadas en:  Estructuras Lineales  Estructuras No Lineales 1. 1.

Un arreglo tiene dos partes: Componentes e índices C1 i0 C2 i1 … … Componentes Cn iN Indices Componentes: Hacen referencia a los elementos que forman el arreglo. Índices: Permiten referirse a los componentes del arreglo en forma individual.3. Notación: Podría ser de diferentes maneras. 1. C hace referencia a todo el vector..2. Ordenada: Porque se puede determinar cuál es el enésimo elemento.. también se llaman vectores. Homogénea: Porque todos los elementos son del mismo tipo. Por ejemplo: Array [0. 1. Finita: Porque todo arreglo tiene un límite.Definición: Colección finita. Katya Perez Martinez Page 5 .9] de enteros: Vector Vector: C C= 30 0 50 1 elemento 70 60 2 … 8 Identificador Indice Donde. Su sintaxis es: [Estructura de Datos] Lic. homogénea y ordenada de elementos.7. 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.7. ARREGLOS UNIDIMENSIONALES (VECTORES) Son los arreglos más simples y constan de un solo índice.

println (losValores [0]). Identificador: es el nombre del vector. de la siguiente manera: Identificador = new tipo [ cantidad_de_elementos ]. } } El programa: Array. Por ejemplo: public class Array Archivo: { Array. Luego.Tipo_dato identificador[ ]. se debe crear el Array con el operador new. System. Donde: Tipo_dato: es el tipo de datos de los elementos del vector. Implementación del TAD Vector Este es el diseño del TAD vector que maneja números enteros. Katya Perez Martinez leedim() leervector() mostrarvector() Page 6 . que almacena un máximo de 10 elementos enteros. VECTOR V[15]: Entero N: Entero [Estructura de Datos] Lic. losValores = new int [10].java public static void main (String arg []) { int losValores []. O bien: Tipo_dato [ ] identificador. losValores [0] = 100. trabaja con el vector losValores.java.out.

println ("Cuantos elementos insertara en el Vector? ").*. static InputStreamReader Caracteres. Katya Perez Martinez } } Page 7 . } static void leervector () throws IOException { int i. dato = Buffer. static BufferedReader Buffer.println("Ingrese elemento "+ i + " = "). i++) { System. i < n. Buffer = new BufferedReader(Caracteres). Lic.out. v[i] = Integer.Ejercicios A continuación se muestra la implementación de este TAD en Java.parseInt(dato). } static void mostrarvector () throws IOException { int i.JAVA import java.readLine().out. static void leedim () throws IOException { System.readLine (). } for(i=0.io. dato = Buffer.in).out. Caracteres = new InputStreamReader (System. static int n. n = Integer. leedim (). } } public static void main (String [] args) throws IOException { v = new int[15]. static String dato. for(i=0. [Estructura de Datos] mostrarvector(). i < n. i++) { System. leervector(). //ARCHIVO VECTOR.print(v[i] + " "). public class Vector En { lenguaje static java: int v[].parseInt (dato).

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

Psicomotricidad. Ejemplo: 4 2 4 4 7 7 A= 1 2 3 4 5 6 Eliminando los duplicados queda: 4 2 7 A= 1 2 3 3. Hallar la suma de los elementos de la diagonal principal c. Katya Perez Martinez Naranjas para comer Page 9 . Porcentaje de alumnos ingresados en el año X de la carrera Y c. 4. Se conoce el total de toneladas cosechadas de cada uno de los tipos de naranjas. Año en el cual la carrera Y tuvo el mayor ingreso de alumnos. Contaduría Pública y Educación). Contar los elementos negativos y positivos b. 5. en los últimos 4 años. En la Universidad se conoce el número de alumnos que ingresaron en sus 5 diferentes carreras (Ingeniería de Sistemas. Total de alumnos por año b. a continuación obtenga e imprima: a. (toda esta información la proporciona el usuario). Buscar el elemento X dado por el usuario y retorne el valor 1 si fue encontrado y 0 caso contrario. entonces habrá 0.La información se almacena en un arreglo como se muestra en el siguiente ejemplo. Realice un programa que elimine elementos duplicados de un vector.6 13 52 TOTAL GANADO 1064 BS 2. Derecho. Diseñe un TAD y luego implementarlo para que suministre la siguiente información: a. En cada parcela se pueden cultivar dos tipos de naranjas: para jugo y para comer. Una cooperativa de productores de naranjas almacena el total de toneladas cosechadas durante el último año en N parcelas. Naranjas para jugo [Estructura de Datos] Lic. Si en una parcela no se hubiera cosechado alguno de los tipos. Diseñe el TAD necesario para formar una matriz de orden NxM y la llene de datos enteros.

Se repite 3 1 2 Cadenas de Caracteres Los arreglos de caracteres tienen varias características únicas. Realice un programa que de un vector de N elementos. Katya Perez Martinez Page 10 . por cada elemento indique la cantidad de veces que se repite.4. Imprimir las parcelas que tuvieron una producción de 0. Leer la información y las toneladas por tipo de naranja de cada una de las parcelas b. Ejemplo: 4 2 4 4 7 7 B= 1 2 3 4 5 6 La salida sera : Element o 4 2 7 1.A= 10 0 1 50 0 2 Parcela 1   60 0 3 0 80 0 5 4 Parcela 2 30 0 6 … 50 0 … 35 0 n Parcela 3 En la parcela 1 se cosechan: 100 toneladas de naranjas para jugo y 500 toneladas de naranjas para comer En la parcela 2 se cosecharon: 600 toneladas de naranjas para jugo y 0 toneladas de naranjas para comer. Calcular e imprimir el total de la producción por parcela c. [Estructura de Datos] Lic. Un arreglo de caracteres puede inicializarse de la siguiente forma: char CADENA1[ ] = "rosa". 6.7. NOTA: Observe que la información de una misma parcela ocupa posiciones consecutivas en el arreglo. Se pide: a.

1. El tamaño de CADENA1 está determinado por el compilador. false de otra manera. • Los caracteres en las cadenas tienen un número de posición que inicia en CERO y termina en n-1. false de otra manera. Katya Perez Martinez Page 11 . ' o '. LOS METODOS DE LA CLASE STRING • Las cadenas no se pueden comparar con = = . ' \0 ' }. ' a '.  Los arreglos de caracteres pueden inicializarse también con constantes individuales dentro de una lista.7. char CADENA1[ ]= {' r '. Por ejemplo: char CAD2[20]. • Los siguientes son algunos de los métodos más comunes en aplicaciones java y su sintaxis.5. cin >> CAD2. más un caracter especial de terminación denominado caracter nulo (' \0 '). [Estructura de Datos] Lic.equalsIgnoreCase(cadena2) regresa true si las cadenas son iguales ignorando las mayúsculas.equals(cadena2) regresa true si cadena1 y cadena2 son iguales. Considerar cadena1 y cadena2 como variables (objetos) de tipo String. y generalmente es de 256 caracteres máximo.  También podemos colocar una cadena de caracteres directamente dentro de un arreglo de caracteres desde el teclado. • cadena1. ' s '. • cadena1. donde n es la longitud de la cadena.  La cadena "rosa" contiene cuatro caracteres.

• cadena1. Por ejemplo: cadena2 =”Cochabamba”. Katya Perez Martinez Page 12 .concat(cadena2). Si no existe la subcadena regresa -1. regresa otra cadena convirtiendo todas las letras a mayúsculas.indexOf(subcadena. regresa otra cadena convirtiendo todas las letras a minúsculas.char2) regresa otra cadena remplazando char1 por char2. regresa el i-ésimo carácter de la cadena. regresa una subcadena que empieza en indiceInicial y termina en indiceFinal-1. false de otra manera. indiceFinal). regresa otra cadena sin espacios en blanco. • cadena1. regresa el numero.'I').charAt(i).substring(indiceInicial.valueOf(arregloDeCaracteres). • cadena1. regresa true si cadena1 termina con subcadena. • cadena1. • cadena1. • String. • cadena1.endsWith(subcadena). • cadena1. regresa un entero que indica la posición donde inicia la subcadena en la cadena.replace(char1.• cadena1. • cadena1. entero.trim(). 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.replace( 'a'.length().toLowerCase(). de caracteres en la cadena. Esta conversión [Estructura de Datos] Lic. regresa la representación String del arreglo de caracteres. equivalente a cadena1 + cadena2 .indiceInicial). cadena2 tendrá el valor de CochIbImbI • cadena1.toUpperCase().compareTo(cadena2) regresa un valor entero 0 si son iguales. caracteres de nueva línea y tabuladores del inicio y del final de la cadena original. • cadena1.

• CONVERSIÓN DE TIPOS PRIMITIVOS NUMÉRICOS A CADENA Integer. regresa el valor convertido en cadena.toCharArray(). Integer. regresa un valor octal en cadena EJERCICIOS RESUELTOS [Estructura de Datos] Lic. regresa el valor entero de la cadena representado en la base numérica base. cadena1. Integer.toHexString(numeroEntero).toOctalString(numeroEntero). De manera semejante se convierten los otros tipos primitivos a cadena.parseDouble(“cadenaNumerica”). Integer. regresa el valor numérico doble correspondiente al valor representado en la cadena. Double. • String cadena1= new String(arregloDeCaracteres).toString(valorDoble).toString(valorEntero). regresa un valor hexadecimal en cadena. regresa un valor binario en cadena.parseInt(“cadenaNumerica”. De manera semejante se convierten los otros tipos primitivos de cadena a valores numéricos.también puede ser realizada usando el constructor de la clase String.toBinaryString(numeroEntero). regresa el valor numérico entero correspondiente al valor representado en la cadena. base). Double.parseInt(“cadenaNumerica”). Integer. Integer. regresa el valor convertido en cadena. Katya Perez Martinez Page 13 . regresa el arreglo de caracteres correspondiente a cadena1.

indexOf (" "). char blanco = ' '. System. int n = 1.substring (i + 1). System.Cadena ().1. int cuantos = 0. // recorto la cadena para quitar una palabra i = st. //para encontrar la posicion del primer blanco } while (i > 0) { // mientras haya espacios en blanco n++.out. // para contar la ultima palabra } [Estructura de Datos] Lic.indexOf (" ").out.print ("deme la cadena "). Katya Perez Martinez Page 14 . cad = Leer. cuantos = contar (cad). // sumo 1 al contador st = st.println ("Habia " + cuantos + "palabras"). Diseñamos el TAD las Guia31 contar(): entero main() /*Este programa pretende contar el numero de palabras que hay en una cadena las palabras estan separadas por un espacio en blanco */ public class Guia31 { public static void main (String args[]) { String cad = new String (""). // para contar la primera palabra int i = st. Contar el numero de palabras que hay en una cadena. palabras están separadas por un espacio en blanco. } public static int contar (String st) { char a. // encuentro el siguiente blanco } return n++.

c = Lectura. } public static String reemplazar (String st. // colocamos un asterisco en al cadena nueva } else { otra = otra + a. cad = Leer. // cadena a revisar char c. Katya Perez Martinez Page 15 . c). char letra) { char a. System. // nueva cadena a formar for (int i = 0 . // devolvemos la nueva cadena } } [Estructura de Datos] Lic.Caracter (). El resultado queda en otra cadena No puede usar la funcion replace */ public class Guia32 { public static void main (String args[]) { String cad = new String (""). String otra = new String ("").length () .print ("Deme el caracter …. // caracter a buscar String nueva = new String ("").println ("la cadena nueva es….out. Diseñamos el TAD Guia32 reemplazar(): Cadena main() /* Este programa pretende reemplazar todas las ocurrencias de un caracter c en la cadena cad por un asterisco. i < st.2. System. System.print ("deme la cadena….out. i++) { // recorremos la cadena caracter a caracter a = st.Cadena (). El resultado queda en otra cadena.out. Escribir un programa para reemplazar todas las ocurrencias de un carácter c en la cadena cad por un asterisco. // tomamos un caracter if (a == letra) { // si el caracter es el buscado otra = otra + '*'.charAt (i). nueva = reemplazar (cad. ")."). " + nueva).. // de lo contrario colocamos el mismo caracter que tenia } } return otra. No usar la función replace.

System. cad = Lectura. System.print ("dame la cadena ….length () . String otra = new String (""). Diseñamos el TAD Guia33 suprime(): Cadena main() /* Este programa pretende suprimir todos los espacios en blanco de unacadena cad El resultado queda en otra cadena */ public class Guia33 { public static void main (String args[]) { String cad = new String (""). i++) { a = st. for (int i = 0 . } } [Estructura de Datos]     Katya Perez Martinez Lic.Cadena (). nueva = suprime (cad. programa que pretende suprimir todos los espacios en blanco de una cadena cad. String nueva = new String ("").").println ("la cadena nueva es …" + nueva). } } return otra. blanco). if (a != espacio) { otra = otra + a. char espacio) { char a. Page 16 .out.charAt (i). char blanco = ' '. } public static String suprime (String st. i < st.3.out. El resultado queda en otra cadena.

i < n .out. palabra = Lectura. i++) { if ((p. Diseñamos el TAD Guia34 Contar() main() // Programa que sirve para contar cuántas vocales tiene una palabra o frase.charAt (i) == 'i') || (p.println ("La palabra tiene " + cont + " vocales"). Contar (palabra). } static void Contar (String p) { int n = 0. n = p. paterno. for (int i = 0 .. mes y anio de los datos del usuario.charAt (i) == 'e') || (p. materno.print(“Dame una palabra o una frase….charAt (i) == 'o') || (p. class Guia34 { public static void main (String args[]) { String palabra. dia.Cadena (). Katya Perez Martinez Nombre: cadena Paterno: cadena Materno:cadena dia: entero mes: entero anio:entero Generar(): cadena main() Page 17 . cont = 0.out.”).4. Escribir una aplicación para generar un código a partir del nombre. } } 5.length ().charAt (i) == 'a') || (p.charAt (i) == 'u')) cont++. Guia35 [Estructura de Datos] Lic. Programa que sirve para contar cuántas vocales tiene una palabra o frase. } System. System.

charAt (0)..String.Entero (). anio. public class Guia35 { static String Nombre.. Page 18 . Nombre = Lectura. do { System. materno.print ("Cual es tu Apellido paterno. int d.Cadena (). System. paterno = Lectura. //extrae la inicial del apellido materno Codigo = Codigo + cod.Cadena (). paterno. String pat. dia = Lectura.charAt (0)..print ("Cual es tu nombre.. // concatena la inicial del nombre con la inicial del paterno cod = mat...charAt (0)..")."). int m. String mat.print ("Cual es tu Apellido Materno.print ("Dia de nacimiento.. //extrae el primer caracter del apellido paterno Codigo = Codigo + cod. return Codigo.toString (mes)) + (Integer. System. static int dia.toString (anio))."). Katya Perez Martinez } while (mes > 13 || mes < 1). System.out. String Codigo = new String (""). //extrae el primer caracter del nombre Codigo = Codigo + cod.."). } public static void main (String args[]) { String Micodigo. } while (dia > 31 || dia < 1).Cadena ().. cod = nom.print ("Mes de nacimiento.Entero (). int a) { char cod.lang.out.out.. [Estructura de Datos] mes = Lectura. do { System..out."). Lic. static String Generar (String nom. mes. //almacena en Codigo la inicial del nombre cod = pat.toString (dia)) + (Integer..out..Diseñamos el TAD // PROGRAMA PARA CODIFICAR UN NOMBRE CON LAS INICIALES DEL nOMBRE+PATERNO+MATERNO // +DIA+MES+ANIO DE NACIMIENTO import java. materno = Lectura. //concatena lo que tenia codigo con la inicial materno Codigo = Codigo + (Integer.

anio = Lectura. 4. } while (anio > 99)."). Escriba una clase que reciba como parámetro el nombre de una persona. 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. materno. Escriba una clase que permita eliminar un substring substr de un string str.. 1.print ("Anio de nacimiento Ej 97. mes. System.do { System. ARREGLOS MULTIDIMENSIONALES [Estructura de Datos] Lic.out.print (" el codigo generado es . un espacio y después el nombre de pila. anio).8. } } EJERCICIOS PROPUESTOS 1." + Micodigo). Katya Perez Martinez Page 19 . Crear una clase donde dado un string de palabras sustituir cada ocurrencia de un caracter dado por otro caracter. con el apellido seguido de una coma. El procedimiento debe imprimir el nombre de pila de la persona seguido de su apellido.Entero ()..out. (por ejemplo: todas las s por *) 3. 2.. dia. si no está devuelve el mismo string sin alterar. paterno.. Micodigo = Generar (Nombre..

debemos hacer referencia a dos índices (que representan la posición como renglón y columna). Por ejemplo.  Los valores son agrupados en renglones. El número de dimensiones (índices) permitido depende del lenguaje elegido.  Declaración de una Matríz La sintaxis en el lenguaje C++ es el siguiente: tipo nombre_de_variable [rango1][rango2]. Se analizarán primero los arreglos bidimensionales (caso especial de los multidimensionales) por ser los mas utilizados. Matrices Una matriz es un arreglo de dos dimensiones. En arreglos de dos dimensiones. {3. Katya Perez Martinez Page 20 . 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.1. y para especificar cualquier elemento. un arreglo bidimensional b[2][2] puede declararse e inicializarse así: int b[2][2] = { {1.4} }.  Un arreglo multidimensional puede inicializarse desde su declaración.  Cada elemento de un arreglo bidimensional puede referenciarse de la siguiente manera: arreglo [ i ] [ j ].8. 1. ya que la computadora almacena los datos en una forma totalmente diferente.Existe en la mayoría de los lenguajes una estructura de arreglos multidimensionales.2} . Aunque no se justificará aquí.  C++ soporta hasta arreglos con 12 dimensiones. [Estructura de Datos] Lic. el primer elemento representa el renglón y el segundo la columna.

estas operaciones a continuación.print ("Ingrese elemento (" + i + ".  nombre_de_variable es el nombre del arreglo.out. por lo que se realizará un ejemplo de f = Leer.. } } } 21 ." + j + "). System.  Eliminación class matriz {  Modificación static int M[] [] = new int [20] [20].out. j++) { Datos] [Estructura de Page Lic."). Katya Perez Martinez System. i <= f ..donde:  tipo puede ser cualquier tipo de dato (int."). for (int i = 1 .... j <= c . i++) Ejemplo:for (int j = 1 ... c = Leer.").out.println ("******REGISTRO DE MATRIZ ******").out.print ("Ingrese el numero de columnas de la matriz. int f.. j <= c .print ("Ingrese el numero de filascon de algunas la matriz. i <= f .. import java. char..Entero (). i++) { System."). M [i] [j] = Leer. unidimensionales. } } static void imprimir () { System.*. float. System.. j++) { System. Podemos trabajar con cada uno de los elementos de la matriz: X[3][5] = 20.  Operaciones con arreglos bidimensionales Las operaciones que pueden realizarse con arreglos bidimensionales son las siguientes:  Lectura/escritura  Asignación  Actualización: //programa para manejo Inserción de matrices de numeros enteros.Entero ()... c...Entero ().IMPRIMIENDO LA MATRIZ.io.out. for (int i = 1 .  rango 1 corresponde al número de renglones que conforman el arreglo..print (M [i] [j] + " "). for (int j = 1 .).. etc.  static Ordenación  static Búsqueda void leerMatriz () { En general los arreglos bidimensionales son una generalización de los System.println ()...out..  rango 2 corresponde al número de columnas.println (".out..

todos del mismo tipo. } } 1. que era un tipo estructurado de datos. Sin embargo. imprimir ().9. REGISTROS (ESTRUCTURAS) Cuando se habló de los arreglos se mencionó que se trataba de una colección de datos. Katya Perez Martinez Page 22 .public static void main (String args[]) { leerMatriz (). y que son ellos se podía solucionar un gran número de problemas. Ejemplo Una compañía tiene por cada empleado los siguientes datos: [Estructura de Datos] Lic. 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).

9. 1. Para ello.campo Ejemplo: [Estructura de Datos] Lic. donde cado uno de sus componentes se denomina campo. Los campos de un registro pueden ser todos de diferentes tipos. sino que debe especificarse qué elemento (campo) del registro interesa.ACCESO A LOS CAMPOS DE UN REGISTRO Como un registro es un dato estructurado no puede accecsarse directamente como un todo. No se establece orden entre los campos. Arce 123 Centr Calle 12 134 al 5 Obraj es Edad Sexo 25 M 29 F Antig 2 3 Si se quisiera almacenar estos datos no sería posible usar un arreglo. ya que sus componentes deben ser todos del mismo tipo. Un registro es un dato estructurado.2. 1. Por lo tanto también podrán ser registros o arreglos. en la mayoría de los lenguajes se sigue la siguiente sintaxis: Variable_registro.9. Katya Perez Martinez Page 23 .1. Nom Juan Maria Nombre Pat Rodrígu ez Alvarez Mat Salas Varga s Direccion Calle Nro Zona Av.     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. Cada campo se identifica por un nombre único (el identificador de campo).DEFINICIÓN DE REGISTRO Y DECLARACIÓN DE LA VARIABLE DE REGISTRO.

.println ("FECHA DE INGRESO "). } public boolean VerificaSueldo (float X) { if (sueldo < X) return true.out. fechaing.out. { } System. System. else [Estructura de Datos] Lic.")..out. System.println ("SUELDO:___" + sueldo). System..Escribir un programa para leer los registros de un empleado.Entero (). System..Cadena (). nombre = Lectura.print ("sueldo.Entero ().print ("ANIO. sueldo = Lectura.Entero ().").out. private String nombre.println ("NOMBRE:___" + nombre). System..println ("anio:___" + fechaing..Entero ()..print ("MES. System.out.print ("CI.out. } public private void leeDatos fecha () fechaing = new fecha (). Empleado. private class fecha { int dia. System.out.println ("Ingrese los datos del empleado:")..println ("CI:___" + ci).."). System.dia = Lectura..out. ci = Lectura.out."). fechaing.out.out.out. private float sueldo. fechaing.println ("INGRESE LA FECHA DE INGRESO:").println ("dia:___" + fechaing. } } Page 24 ..print ("Nombre:.").out.out.mes).out. System. sus datos son CI.dia). System.mes = Lectura. System.").anio).anio = Lectura.println ("mes:___" + fechaing. nombre.java class empleado { private int ci.print ("DIA. sueldo y fecha de ingreso. System. Katya Perez Martinez return false. anio. mes. System. public void ImprimeDatos () { System...Real ().

java class LlamaEmpleado { public static void main (String arg[]) { empleado E. ARRAYS DE ESTRUCTURAS: La combinación de las estructuras con los arrays proporciona una potente herramienta para el almacenamiento y manipulación de datos. E = new empleado ().java (el anterior programa) LlamaEmpleado.A continuación codificamos el programa para llamar al programa de empleado.ImprimeDatos (). Katya Perez Martinez Page 25 . } } 1. ESTRUCTURAS ANIDADAS: También está permitido anidar estructuras.leeDatos ().4. E.3.9.9. [Estructura de Datos] Lic. 1. E. con lo cual se pueden conseguir superestructuras muy elaboradas.

ImprimeDatos ()..println ().println (). y para acceder a ellas se necesita hacer referencia a la estructura más externa. static void ImprimirEmpleados (empleado ve[].out. System.").En general. n = Lectura. static int ve[].EMPLEADOS CON SUELDOS MENOR A X. System.println (). i <= n ..out. } } static void ListaConSueldoMenorX (empleado ve[]. for (int i = 1 . System.").VerificaSueldo (sx) == true) ve [i]. empleado.java.println ("EMPLEADO: " + i). i++) { System.. ve [i]. no es una práctica corriente definir estructuras dentro de estructuras. Ejemplo: //PROGRAMA PARA LEER N EMPLEADOS EN UN VECTOR DE REGISTROS class regemp Utilizaremos el registro del empleado. ahora mediante un arreglo que static int n.out..IMPRIMIENDO DATOS DE LOS EMPLEADOS.out.out.. i <= n . int n) { System.println ("EMPLEADO : ve [i] = new empleado ().. sx = Lectura.Entero (). El(empleado programa es elint siguiente regemp.println (".. ya que resultan tener un ámbito local.. System.. System.out..println ()."). n) { System."). } [Estructura de Datos] } Lic.out.println ("Menores a cual sueldo desea listar.out. System.out.println (). que se escribió en el archivo { static empleadopara e[] =implementar new empleado [10].. System.print ("Cuantos empleados desea registrar.println ("EMPLEADO: " + i). almacena a NLeerEmpleados empleados..out....out. Katya Perez Martinez Page 26 .. int n) { float sx.java. " + i). for (int i = 1 . ve [i]. if (ve [i].out. i++) { System.println (".leeDatos (). i++) { System. } return n..ImprimeDatos ().Real ().. } for (int i = 1 . i <= n .

ImprimirEmpleados (e. CONJUNTOS El conjunto es también un tipo de dato estructurado.10. DEFINICIÓN DE CONJUNTOS Los conjuntos serán definidos de la siguiente manera: [Estructura de Datos] Lic. n). caracteres. El tipo base puede ser solamente un tipo ordinal (enteros. 1. Katya Perez Martinez Page 27 .1.10. } } 1. enumerados y subrangos). Puede definirse un conjunto como una colección de objetos del mismo tipo base.public static void main (String args[]) { n = LeerEmpleados (e. n).n). ListaConSueldoMenorX (e.

50 MAYUSCULAS = CONJUNTO DE ‘A’. Poco Densa indica una proporción muy alta de ceros entre los elementos de la matríz. MATRICES POCO DENSAS Matriz es un término matemático utilizado para definir un conjunto de elementos organizados por medio de renglones y columnas. Ejemplo: La matriz A de 4 filas por 4 columnas. Katya Perez Martinez Page 28 .Ident_conjunto = CONJUNTO DE tipo_base Donde: Tipo_base es cualquier tipo ordinal de dato. Jose. MAYUSCULAS y ALUMNOS.. MAYUSCULAS es el tipo conjunto formado por las letras mayúsculas. y finalmente ALUMNOS es el tipo conjunto formado por todos los elementos del tipo enumerado NOMBRES. equivalente al término arreglo bidimensional utilizado en computación. Julio. solo 4 de ellos son diferentes de cero. del total de elementos que es 16. NUMEROS es el tipo conjunto formado por todos los números enteros comprendidos entre el 1 y el 50 inclusive.’Z’ ALUMNOS = CONJUNTO DE nombres 1. Es decir una matriz poco densa es aquella que tiene gran cantidad de elementos ceros. A continuación presentamos uno de ellos. [Estructura de Datos] Lic.Javier) NUMEROS = CONJUNTO DE 1. NOMBRES = (Juan.. 0 0 0 0 Existen diversos métodos para A= 1 1 0 0 1 0 1 0 0 1 0 0 almacenar los valores diferentes de cero de una matríz poco densa.11. Ejemplo: Se definen los conjuntos NUMEROS.

} public int VALOR () { return valor. Katya Perez Martinez } Page 29 . MatrizPocoDensa (int f. private int col. int v) { fila = f. } [Estructura de Datos] Lic. otro para guardar la columna. int c. } public int FILA () { return fila. valor = v. se lo ha denominado MatrizPocoDensa. private int valor. El siguiente programa nos permite crear la estructura para una matriz poco densa.Arreglo de Registros Se utiliza un arreglo unidimensional. } public int COL () { return col.java: MatrizPocoDensa. donde cada elemento es un registro formado por tres campos: uno para guardar la fila donde se encontró el valor diferente de cero. y el tercero para guardar el valor del elemento distinto de cero de la matriz.java public class MatrizPocoDensa { private int fila. col = c.

(k . } } } } M [0] = new MatrizPocoDensa (m. for (j = 1 . k = 1. e).print ("INGRESE EL NUMERO DE COLUMNAS DE LA MATRIZ.").Entero ().out. System.out.java System. j. j..println ("IMPRIMIENDO LA MATRIZ POCO DENSA.Entero ().out. for (i = 1 . k. j <= n ." + j + ") ="). e.. k = 0..print (" " + D [k].Entero (). m = Lectura.VALOR () > k) k = k + 1.print (" 0 "). } } } 30 . System.VALOR () + " ").. j.FILA () . k = 1. if (D [0]. n = Lectura. n.. i++) { System.. MatrizPocoDensa M[] = new MatrizPocoDensa [20].COL () == j)) { System..1)).print ("Ingrese el valor de la posicion (" + i + ". j <= D [0].").. if (e != 0) { M [k] = new MatrizPocoDensa (i.COL () .println ()."). j++) { MatrizPD. k.out.out. e = Lectura. static void ImprimirMatrizPocoDensa (MatrizPocoDensa D[]) { int i.print ("INGRESE EL NUMERO DE FILAS DE LA MATRIZ. m. } [Estructura de Datos] Page else Lic. k = k + 1. Katya Perez Martinez System.FILA () == i) && (D [k]. i <= m . i <= D [0].. j++) { if ((D [k]. for (i = 1 . System. return M. i++) { for (j = 1 . n.out.out.El programa para utilizar matrices poco densas es el siguiente: class MatrizPD { static MatrizPocoDensa[] LeerMatrizPocoDensa () { int i.

Declare e inicialice un vector de N elementos de modo que los componentes de indice par valgan 0 y los de indice impar valgan 1.0. . . .12.} public static void main (String args[]) { MatrizPocoDensa A[] = new MatrizPocoDensa [20]. V(1.) [Estructura de Datos] Lic. Ejm.1. Katya Perez Martinez Page 31 . A = LeerMatrizPocoDensa (). ImprimirMatrizPocoDensa (A).0. . ARCHIVOS Ejercicios Propuestos ARREGLOS DE UNA DIMENSIÓN 1. } 1. .

19: 20 . Katya Perez Martinez ***** **** * * * Page 32 . Una vez calculados.59: 60 . desviación estándar. Modifica el programa del ejercicio anterior para que muestre. el programa pedirá al usuario que introduzca un número y dirá si es o no es uno de los N primeros números de Fibonacci. además.109: 0 110 .149: 0 4 Modifica el programa para que muestre un histograma de edades.19: 5 20 .59: 1 60 .29: 30 . Escriba un programa que almacene en un vector los N primeros números de Fibonacci.139: 0 140 . la siguiente tabla: 0 . etc.79: [Estructura de Datos] Lic. Ejemplo: si el usuario introduce las siguientes edades correspondientes a 12 personas: 10 23 15 18 20 18 57 12 29 31 78 28 el programa mostrará (además de la media. Considera que ninguna edad es igual o superior a 150.119: 0 120 . La tabla anterior se mostrará ahora como este histograma: 0 .9: 10 . entre 20 y 29.49: 0 50 . Escriba un programa que almacene en un vector los N primeros números de Fibonacci.49: 50 .129: 0 130 . 4.9: 0 10 .89: 0 90 .69: 0 70 . 3. entre 10 y 19. cuántas edades hay entre 0 y 9 años.79: 1 80 .99: 0 100 .29: 4 30 .2.69: 70 .39: 1 40 .39: 40 . moda y mediana). Una vez calculados. el programa los mostrará por pantalla en orden inverso.

el programa [Estructura de Datos] Lic. Katya Perez Martinez Page 33 .89: 90 .149: Como puedes ver.29 | 30 – 39 | 40 – 49 | 50 – 59 | 60 69 | 70 – 79 | | | | | | - 7 Diseñe un programa que pida el valor de N números enteros distintos y los almacene en un vector. cada asterisco representa la edad de una persona.99: 100 . 5 Modifica el programa anterior para que el primer y último rangos de edades mostrados en el histograma correspondan a tramos de edades en los que hay al menos una persona. Si se da el caso.139: 140 .80 .129: 130 . El histograma mostrado antes aparecerá ahora así: 10 20 30 40 50 60 70 - 19: 29: 39: 49: 59: 69: 79: ***** **** * * * 6 Modifica el programa del ejercicio anterior para que muestre el mismo histograma de esta otra forma: | | ####### | | | | | | ####### | ####### | | | | | | ####### | ####### | | | | | | ####### | ####### | | | | | | ####### | ####### | ####### | ####### | | ####### | +----------+-----------+-----------+-----------+-----------+----------+-----------+ | 10 – 19 | 20 .119: 120 .109: 110 .

21. ¿Cuántos meses tuvieron una cosecha superior al promedio anual? iii. por el método de la burbuja. Aij = 0 [Estructura de Datos] Lic. los del renglón 2 con los del N-1. A continuación. Escriba un programa que intercambie por renglón los elementos de un arreglo bidimensional. ¿Cuántos meses tuvieron una cosecha inferior al promedio anual?Escriba un programa que proporcione estos datos. El programa finaliza cuando el usuario introduce un número negativo. Se desea la siguiente información: i. el programa pedirá que se introduzca una serie de números enteros y nos dirá si cada uno de ellos está o no en el vector. Aij = (bi) v. Los elementos del renglón 1 deben intercambiarse con los del renglón N. A continuación. Escriba un programa que asigne valores a A. El promedio anual de toneladas cosechadas ii. si introduce un número repetido y solicitará nuevamente el número hasta que sea diferente de todos los anteriores. ARREGLOS MULTIDIMENSIONALES 20. a partir de B teniendo en cuenta los siguientes criterios: iv. 9 En un arreglo se ha almacenado el número total de toneladas de cereales cosechadas durante cada mes del año anterior. tan pronto sea posible. Luego ordenar el vector. y así sucesivamente. Katya Perez Martinez si i <= j si i >j Page 34 . el programa mostrará los N números por pantalla 8 Diseñe un programa que lea y almacene en un vector N números enteros asegurándose de que sean positivos.advertirá al usuario.

La Tabla Pedro 0 3 3 5 1 0 Maria 2 1 0 7 2 3 Rosa 1 1 2 3 2 2 Luis 5 2 1 1 0 5 Rosa vendió 2 autos del modelo M3 contiene gastos que registra una ama de casa correspondiente a los 12 meses del año anterior. Una agencia automotriz distribuye 6 modelos diferentes de coches y tiene 5 vendedores. Hallar la suma de los elementos de la diagonal secundaria f. Katya Perez Martinez Telefon o 840 560 400 700 450 670 560 570 540 Mercad o 250 280 275 340 310 320 325 323 290 Page 35 .22. Asimismo. Vendedores Modelos Juan M1 4 M2 2 M3 0 M4 3 M5 4 M6 0 24. a continuación obtenga e imprima: d. Diseñe el TAD necesario para formar una matriz de orden NxM y la llene de datos enteros. devuelva el elemento que corresponda a esa posición 23. Dado la fila y la columna por el usuario. para entregar el premio al mejor vendedor. (toda esta información la proporciona el usuario). necesita saber cuál es el vendedor que más coches ha vendido. Meses/Gas tos Enero Febrero Marzo Abril Mayo Junio Julio Agosto Septiembre Agua Luz 23 28 34 24 29 34 45 48 32 57 60 55 87 80 65 67 78 54 [Estructura de Datos] Lic. Contar los elementos pares e impares e. Se desea un programa que escriba un informe mensual del número de automóviles vendidos por cada vendedor y por modelo y el número total de cada modelo vendido por cada uno de los vendedores.

(datos: clave. Katya Perez Martinez Page 36 . REGISTROS 25. cantidad_vendida) b) Reabastecimientos de un producto: se deben actualizar los campos que correspondan. Una compañía distribuye N productos a distintos comercios de la ciudad. se conocen los gasto realizados por la ama de casa. y dado un gasto se conocen los gastos mensuales. cantidad comprada) c) Actualizar el precio de un producto: se deben proporcionar todos los datos relacionados con un producto. (Dato: clave) 2. y verificar que la nueva existencia no esté por debajo del mínimo. (Datos: clave.Octubre Noviembre Diciembre 33 35 38 50 70 62 250 330 300 300 350 430 Es posible interpretar esta tabla de la siguiente manera: dado un mes. Capítulo II Pilas [Estructura de Datos] Lic. Para ellos almacena en un arreglo toda la información relacionada con su mercancía:  Clave  Descripción  Existencia  Mínimo a mantener de existencia  Precio unitario Escriba un programa que pueda llevar a cabo las siguientes operaciones: a) Venta de un producto: se deben actualizar los campos que correspondan.

el último que entra es el primero que sale). está en el fondo de la pila (bottom) y que k. Las restricciones definidas para la pila implican que si una serie de elementos A. b. cuando se quiere introducir un nuevo plato. . resulta que el último elemento que se inserta en una pila es el primero que se borra. está en el Tope. se dice que a. el último que se ha introducido. E se añaden. 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. Cuando se coge un nuevo plato. c. Un ejemplo típico de pila lo constituye un montón de platos.”               de los programas deberían autoeliminarse al ser ejecutados. Katya Perez Martinez Page 37 . se dice que una pila es una lista LIFO (Last Input First Output. en la forma en que la máquina procesa las llamadas a los procedimientos. El extremo donde se realizan estas operaciones se denomina habitualmente 'cima' o tope (top en nomenclatura inglesa). D. C. 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 más accesible. del punto más accesible. Ejemplos: Una pila de papeles.. k ). éste se pone en la posición más accesible. por el contrario. B. la basura. entonces el primer elemento que se borre de la estructura deberá ser el E. Por esta razón. es el elemento más inaccesible de la pila. Dada una pila P = (a.“SiJava Javadispusiera dispusierade deun unmecanismo mecanismoreal realde derecolección recolecciónde debasura. Por tanto.1. igualmente. en este orden a una pila. lamayoría mayoría “Si              de los programas deberían autoeliminarse al ser ejecutados.”  — Robert Sewell — Robert Sewell 2.. Cada llamada a un procedimiento (o función) hace que el sistema almacene toda la [Estructura de Datos] Lic. encima del último plato. es decir. éste se extrae.

constantes.) 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. Comprobar si la pila está vacía. REPRESENTACIÓN DE LAS PILAS Las pilas no son estructuras fundamentales de datos. y además una variable auxiliar a la que se [Estructura de Datos] Lic. b. c. d. Como en un procesador sólo se puede estar ejecutando un procedimiento. éstas son: a. Crear la pila. De ahí que la estructura pila sea muy apropiada para este fin. Eliminar elementos de la cima..2. Katya Perez Martinez Page 38 . Añadir elementos a la cima. La especificación correcta de todas estas operaciones permitirá definir adecuadamente una pila. e. dirección de retorno. esto quiere decir que sólo es necesario que sean accesibles los datos de un procedimiento (el último activado que está en la cima). asociadas con la estructura pila existen una serie de operaciones necesarias para su manipulación. En consecuencia deberá definirse cuál será el tamaño máximo de la pila.información asociada con ese procedimiento (parámetros. Acceder al elemento situado en la cima. Las pilas pueden representarse mediante el uso de:  Arreglos  Listas Enlazadas Aquí se utilizarán arreglos. no están definidas como tales en los lenguajes de programación (como lo están por ejemplo los arreglos). es decir. etc. variables. 2. Como en cualquier estructura de datos. Es necesaria para saber si es posible eliminar elementos.

utilizando arreglos. 2.4.denominará TOPE. que será un apuntador al último elemento insertado en la pila. Katya Perez Martinez Page 39 . Tope: es la varible que indica la posición del ultimo elemento de la pila. 444 ESTRUCTURA DE UNA PILA UTILIZANDO ARREGLOS 222 Nombre del TAD 434 elementos 555 operaciones PILA V[MAX]: tipo_dato Tope: entero Poner(e) Quitar() Imprimir() Vacia() Donde los elementos son: V[MAX]:es el vector que representa a la pila y es de tamaño de la pila.3. MAX PILA = TOPE TOPE 1555 2434 4 3 2 1 3222 44444 … MAX TOPE PILA 2. En la figura siguiente se presentan dos alternativas de representación de una pila. Y las operaciones como se describen a continuación. OPERACIONES CON PILAS [Estructura de Datos] Lic.

Las operaciones principales con pilas son:  Pone (e) un elemento en la pila (push) boolean llena () { if (tope == MAX)  Quita () un elemento de la pila (pop) return (true). { tope--.print ("elemento?. return (elem).println ("PILA VACIA.out. for (int i = 1 . i--) System. private final int MAX = 20. private int tope. { tope++.out. System. for (int i = tope ... retorna el valor verdad. i <= n . si es asi. if (vacia ()) System. else caso contrario falso. desde } 2. i >= 1 . e. System..io. "). return (false). else n = Lectura.Entero (). si es asi.println ("PILA LLENA. reotrna el valor  Vacia() verifica System..out..  }Llena() verifica si la pila esta llena.."). void poner (int elem) { if (llena ()) si la pila esta vacia.. tope = 0. Lic.out.... { public class Pila elem = v [tope]. return (true). i++) } { System. verdad.println ("PILA CREADA. } el tope hasta el fondo de la pila.println (". IMPLEMENTACIÓN DEL TAD PILA EN LENGUAJE int quitar () {JAVA int elem = 0..  Imprime() Permite imprimir todos los elementos de la pila v [tope] = elem.. [Estructura dee Datos] = Lectura.").Entero ().. } } boolean vacia () void llenarPila () { { if (tope == 0) int n.. } } } Page 40 .").La definición de una estructura de datos queda completa al incluir las operaciones que se pueden realizar en ella. else return (false).println (v [i]). } void imprimir () Pila () { { System.. Katya Perez Martinez poner (e).").IMPRIMIENDO LA PILA. //clase pila y sus operaciones else import java. } private int v[] = new int [MAX].out.println ("cuantos elementos ??.*.5..out.").out. caso contrario falso..

Ejercicios con pilas [Estructura de Datos] Lic. Katya Perez Martinez Page 41 .

poner (e + f). A. (). static Pila P3 = new Pila (). (String args[]) { static void EliminaNegativos (Pila A) { Pila aux = new Pila P1.. { P. } } Page 42 .a. System. P2.").. static Pila P2 = new Pila (). Lic. static void sumarPilas (Pila A. Eliminar elementos negativos de una pila. while (!A.vacia sumarPilas (P1. } } while (!aux. e = A.poner (e). Pila C) { int e.println ("Eliminando Elementos Negativos de la Pila.imprimir [Estructura de Datos] (). { P3.vacia ()) { e = A.imprimir (). while (!A. } } publiclosstatic void main (String args[]) b.vacia ()) { e = aux. P. P1.imprimir (). f.out. //sumar dos pilas del mismo tamaño class EjPila1 { static Pila P1 = new Pila ().imprimir ().quitar ().quitar ().poner (e).quitar (). C.llenarPila ().()) P2. Sumar dos pilas del mismo tamaño. Katya Perez Martinez P. } //ELIMINAR ELEMENTOS NEGATIVOS DE LA PILA } class EjPila2 { static P = void new Pila publicPila static main ().imprimir (). if (e > 0) } aux.llenarPila ().quitar ().llenarPila (). EliminaNegativos (P). P2. int e. Pila B. f = B. P3).

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

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

A=

13 24

377

489

B = 1 23

5

TOPE

C=

1

89 33 77
2
3

4

[Estructura de Datos]
Lic. Katya Perez Martinez

44

11
2

344

433 5
TOPE

4
5

11
6

3
7

23
8
Page 43

TOPE

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

}

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

public static void main (String args[])
{
p1.llenarPila ();
p2.llenarPila ();
p1.imprimir ();
p2.imprimir ();
Intercala (p1, p2);
}

}

2.6. APLICACIONES
Las pilas son una estructura de datos muy usada en la solución de diversos tipos de
problemas. Ahora se verán algunos de los casos más representativos de aplicación de
pilas:

Llamadas a subprogramas

Recursión

Tratamiento de expresiones aritméticas

Ordenación

2.6.1.

LLAMADAS A SUBPROGRAMAS

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 44

Cuando se tiene un programa que llama a un subprograma, internamente se usan pilas
para guardar el estado de las variables del programa en el momento que se hace la
llamada. Así, cuando termina la 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
….



….
….
UNO

PP


….
TRES
….

DOS


….
….

TRES

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 45

6. Katya Perez Martinez Page 46 .6. para poder regresar y seguir ejecutándolo a partir de la instrucción inmediata a la llamada. Revisaremos algunos conceptos: [Estructura de Datos] Lic. 2.2.(o prefija). 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.  Permiten guardar el estado de las variables en el momento que se hace la llamada.TOPE 5 4 5 4 5 4 3 3 3 2 2 1 1 TOPE PP TOPE 2 1 PP 0 TOPE 5 4 5 4 5 4 3 3 3 2 2 2 DOS 1 PP TOPE 1 PP TOPE 1 0 PP 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. 2. RECURSIÓN Se Tratará en el tema 5 el tema de recursión. para poder seguir ocupándolas al regresar del subprograma.3. Se dejará para entonces la aplicación de pilas en procesos recursivos.

 Presentaremos. Dada la expresión A+B se dice que está en notación infija. algunos ejemplos de conversión de expresiones infijas a notación polaca 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.  La subexpresiones patentizadas tendrán más prioridad que cualquier operador.  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.  Dada la expresión AB+ se dice que está en notación postfija.  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. EJEMPLO [Estructura de Datos] Lic.  Si hubiera en una expresión dos o más operadores de igual prioridad. entonces se procesarán de izquierda a derecha. Katya Perez Martinez Page 47 . y su nombre se debe a que el operador (+) está entre los operandos ( A y B). paso a paso. y su nombre se debe a que el operador (+) está antes que los operando (A y B). ya que éste queda establecido por la ubicación de los operadores con respecto a los operandos.

Katya Perez Martinez Page 48 . Insertar el elemento X en una pila cuyos elementos estan ordenados en forma ascendente desde el fondo hasta el tope. 2. 9. 1. Escriba un subprograma que invierta los elementos de una pila. 6. 10. [Estructura de Datos] Lic. 12. 7. 1. 4. y la traduzca anotación postfija. Eliminar los elementos divisores de X de la pila Intercambiar cada elemento de la pila con su adyacente. 5.2. 11. Eliminar el primer elemento par de la pila Hallar la frecuencia de repetición de cada elemento de la pila Apilar los elementos de la pila B sobre la pila A. El primero de ellos es una expresión simple. mientras que el segundo presenta un mayor grado de complejidad. Traduzca las siguietes expresiones a notación postfija utilizando el algoritmo de evaluación. 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 EJERCICIOS PROPUESTOS 1. 1. Los elementos repetidos ocupan posiciones sucesivas. 8. Insertar n elementos después al fondo de una pila que ya tiene datos. X*(Z+W)/(T-V) Z-W*Y+XˆK W*(Z/(K-T)) Realizar un programa para hallar el mayor elemento de una pila P.En este ejemplo se presentan dos casos de traducción de notación infija a postfija. La pila debe quedar ordenada Escriba un programa que lea una expresión en notación infija. Realizar un procedimiento para intercambiar el último elemento de la pila por el primer elemento. Escriba un programa que elimine los elementos repetidos de una pila. 3. 13.3.1.

1. se acercó un tigre.3. Volvió a su casa. . se Cielos le apareció un ángel. el primer elemento que entra a la cola será el primero en salir. Los elementos se eliminan en el mismo orden en el que se insertaron. "¿Cómo hará para alimentarse?". "¿Cómo hará para alimentarse?". toma tus herramientas. se encerró en ella. Ejemplos: [Estructura de Datos] Lic. Capítulo III Colas caminodel delTigre Tigre ElElcamino Un hombre caminaba por el bosque cuando vió una zorra lisiada. "Si Dios ayuda a la zorra. Cuando Volvió su casa. Debido a esta característica. y le dejó a la zorra lo que había "Si Dios la tigre.¡Levántate. con un animal entre los dientes. Cuando ya se estaba quedando demasiado débil para salir a trabajar. First Out: Primero en entrar. Las colas en computación son muy similares a las colas de la vida real. ese momento. se encerró en ella. . pensó. Katya Perez Martinez Page 49 . zorra. Un hombre caminaba por el bosque cuando vió una zorra lisiada.con también me vaentre a ayudar". Sació su apetito. Una cola TDA permite a una lista de cosas ser removidos en el orden en que fueron almacenados. las colas también reciben el nombre de estructuras FIFO (First In. se le apareció un ángel. primero en salir).¡Levántate. INTRODUCCIÓN La estructura de datos "cola" también llamada "Queue". reflexionó. y sigue el camino del tigre! de Paulo Coelho de Paulo Coelho 3. Una cola es una lista de elementos en la que éstos se introducen por un extremo y se eliminan por otro. también me va a ayudar". sobrado. pensó. Sació su apetito. y se quedó esperando que los Cielos le proveyeran de alimento. toma tus herramientas. En ese momento. reflexionó. Nada pasó. es un tipo de datos abstracto "TDA". débil y se quedó esperando que los le proveyeran ya se aestaba quedando demasiado para salir a trabajar. y sigue el camino del tigre! . Nada pasó. . de alimento. Por lo tanto. se ayuda acercóaun un animal los dientes.¿Por qué decidiste imitar a la zorra lisiada? -preguntó el ángel. y le dejó a la zorra lo que había Ensobrado.¿Por qué decidiste imitar a la zorra lisiada? -preguntó el ángel.

utilizaremos arreglos. cola de clientes esperando ser atendidos por algún cajero en un banco c. 22. 3. Debe definirse el tamaño máximo para la cola y dos variables auxiliares. pero puede ser representado en forma estática (arreglos). 33 y 44. Las colas pueden representarse mediante el uso de: Arreglos Listas Enlazadas.  Sólo se puede añadir información al final de la cola.  Existe un orden de elementos ya que es una estructura lineal.a. el frente y el final de la cola. Katya Perez Martinez Page 50 . [Estructura de Datos] Lic. 3. cola de procesos esperando ser ejecutados por una CPU Al igual que la pila. Como en el caso de las pilas. 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).3.  Sólo se puede acceder y eliminar al dato que está en el frente de la cola. en ese orden. REPRESENTACIÓN DE LAS COLAS Al igual que las pilas. pero los elementos no están ordenados por su valor sino por orden de introducción en la cola. las colas no existen como estructuras de datos estándares en los lenguajes de programación. CARACTERÍSTICAS  Todos los elementos de la cola son del mismo tipo. la cola es una estructura de datos dinámica. En el ejemplo siguiente se muestra una representación de una cola en la cual se ha insertado cuatro elementos: 11.  Existen dos extremos en la estructura lineal cola.2. cola de clientes esperando pagar en una caja de supermercado b.

ESTRUCTURA DE UNA COLA IMPLEMENTADO MEDIANTE ARREGLOS A continuación diseñamos la estructura de datos para una cola representada mediante un arreglo: COLA elementos V[MAX]: tipo_dato frente: entero fin: entero operaciones Insertar(e) Eliminar() Imprimir() Vacia() Llena() FRENTE() Donde los elementos son: V[MAX]:es el vector que representa a la cola y es de tamaño MAX. Fin: es la variable que indica la posición del último elemento de la cola. está en el FINAL de la cola. Mientras que el elemento 44.El elemento 11 está en el frente ya que fue el primero que entró en la cola. que fue el último en entrar. Katya Perez Martinez Page 51 .4. Y las operaciones. Frente: es la variable que indica la posición del elemento del frente de la cola. MAX=6 Ejemplo: sea una cola Q de números enteros: Q= 1 11 22 2 3 33 Frente 44 4 5 6 Final 3. [Estructura de Datos] Lic. como se describen a continuación.

no borra nada 'físicamente'. private int frente. Estas operaciones serían:  Insertar(e): Inserta un elemento al final de la cola. else return (false).. 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.3.intaunque esto último no sea estrictamente necesario. como private mucho. fin. COLAS LINEALES A continuación implementamos el código correspondiente al programa } boolean de manejo devacia colas () lineales en java: { if (frente == 0) return (true)..5.  FINAL(): Retorna el valor del fin. } Page 52 . Aunque esa posición aun contenga datos será considerada como vacía a Cola efectos del()otro puntero 'fin'.println ("COLA CREADA..  Llena(): Verifica si la cola está llena.  Eliminar(): Elimina un elemento del frente de la cola. Esto puede hacerse de varias formas. retorna un valor booleano.  FRENTE(): Retorna el valor del frente.  Vacia(): Verifica si la cola esta vacía. OPERACIONES CON COLAS Análogamente a las pilas. Katya Perezif Martinez return (true). { frente = 0.out. fin = 0. } boolean llena () { [Estructura de Datos] (fin == MAX) Lic. System. es necesario definir el conjunto de operaciones básicas para especificar adecuadamente una estructura cola. //COLA LINEAL DE NUMEROS Eliminar un elemento deENTEROS la cola:Y SUS OPERACIONES class Cola { Comofinal veraint la MAX eliminación = 20. retorna un valor booleano."). sólo se encarga de actualizar el puntero 'frente' en una posición y devolver el valor x private int v[] = new int [MAX]. else return (false).  Imprimir(): Imprime los elementos desde el frente hasta el final de la cola.

} else { System.")..out.. Katya { Perez Martinez } return (fin). } int eliminar () { int e = 0. i++) System.println ("COLA LINEAL LLENA.void insertar (int elem) { if (!llena ()) { fin++.println (v [i]). } else { } System.").. for (int i = frente . v [fin] = elem. fin = 0..println ("IMPRIMIENDO LA COLA.exit (0). if (frente == fin) { frente = 0.exit (0).. } return (e). if (frente == 0) frente = 1.").out.out. i <= fin .. if (!vacia ()) { e = v [frente]... } else frente = frente + 1. } void imprimir () { System.out. Page 53 .. System. System.println ("LA COLA ESTA VACIA. } [Estructura de Datos] int FINAL () Lic..

Katya Perez Martinez Page 54 .Entero ().Entero (). i++) { System.print ("Introduzca un elemento.out. System. i <= N . } void llenarCola () { int N. N = Lectura."). e = Lectura. Eliminar los divisores de x de una cola [Estructura de Datos] Lic..int FRENTE () { return (frente). for (int i = 1 . insertar (e).. int e.out.println ("Cuantos elementos desea insertar a la cola ??"). } } } EJERCICIOS CON COLAS LINEALES a..

while (A.print ("Ingrese el valor de x.Entero ()... System."). En la siguiente figura se muestra la representación de una cola circular.6. x = Lectura. EliminarDivisoresX (Q). int m = A.println ("***** Eliminando Divisores de X de la Cola Lineal****** "). int e.print ("/////" + m).out.imprimir (). static void EliminarDivisoresX (Cola A) { int x.// ELIMINAR LOS DIVISORES DE X DE UNA COLA LINEAL class EjCola1 { static Cola Q = new Cola ().insertar (e).FRENTE () != m + 1) { e = A. 9 Ejemplo 8 1 [Estructura de Datos] Lic. COLAS CIRCULARES Para hacer un uso más eficiente de la memoria disponible se trata a la cola como una estructura circular. if (x % e != 0) A. } } 3.out. Katya Perez Martinez 33 45 Page 55 . System. Es decir.llenarCola (). public static void main (String args[]) { Q.FINAL ().eliminar ().. } } A. el elemento anterior al primero es el último. Q.imprimir ().out. System.

7. A continuación mostramos la implementación } en Java de una Cola Circular. relación a int una estructura datos lineal. ColaCircular () 3. por tanto a continuación private int fin.. Katya } Perez Martinez Page 56 . private int frente. else [Estructura de Datos] return (false). en el cual ya no es posible adicionar elementos siguiendo la anterior estructura. El diseño de la estructura de datos de una cola circular no varia en (a) v[] private = new intde [MAX]..out.println ("COLA CREADA. fin = 0. básicas con colas circulares son: insertar. { Operaciones Con Colas Circulares frente = 0..22 Final 2 85 67 7 Frente 6 3 4 5 Para el siguiente ejemplo (a)."). se propone la alternativa (b): 1 2 3 D E 4 5 Frente Final (a) F 1 2 3 D E 4 5 Final Frente FinalCIRCULARFinal //COLA DE NUMEROS ENTEROS Y SUS OPERACIONES (b) class ColaCircular { Final Frente final int MAX = 20. boolean vacia () { if (frente == 0) return (true). eliminar y Las operaciones System. mostrar una cola circular. Lic. mostramos las operaciones que sufren cambios en este tipo de colas.

exit (0). if (frente == fin) { frente = 0. System... else if (frente == 0) { frente = 1. } else { } System. else frente = frente + 1."). Katya Perez Martinez { } System.println ("LA COLA ESTA VACIA. System..exit (1).. if (!vacia ()) { e = v [frente]. fin = 1. } void insertar (int elem) { if (!llena ()) { if (fin == MAX) fin = 1.boolean llena () { if ((fin == MAX && frente == 1) || (fin + 1 == frente)) return (true). fin = 0. } [Estructura de Datos] else Lic."). } int eliminar () { int e = 0.. } else fin++.out. Page 57 . else return (false).out.println ("COLA CIRCULAR LLENA. } else if (frente == MAX) frente = 1. v [fin] = elem.

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

8.insertar (e). EJERCICIOS CON COLAS CIRCULARES a. Page 59 . } public static void main (String args[]) { Q.println ("***** Eliminando elementos Negativos de la Cola Circular ****** ").3. [Estructura de Datos] Q.FINAL ().imprimir (). if (e>0) A. static void EliminarNegativos (ColaCircular A) { int e. Eliminar los elementos negativos de la cola circular // ELIMINAR LOS NEGATIVOS DE LA COLA CIRCULAR class EjColaCircular1 { static ColaCircular Q = new ColaCircular ().imprimir ().out.FRENTE () != m + 1) { e = A.llenarCola (). Lic. Katya Perez Martinez } } EliminarNegativos(Q).eliminar (). while (A. int m = A. } A. System.

Si los ítems tienen claves iguales. ya que debo recorrer toda la cola para encontrar el ítem que debo retirar. el CPU asigna prioridades a las distintas tareas que debe ejecutar y las inserta en su cola. Podemos representar una cola de prioridad como una lista contigua ordenada. Katya Perez Martinez Page 60 . pero la inserción tomaría un tiempo proporcional al número de elementos que se encuentren en la cola. pero el de extracción es muy lento. Algunas aplicaciones de éste tipo de estructura son: la representación simulada de eventos dependientes del tiempo.3. hay que tener en cuenta que dicha operación se debe realizar en forma tal que la cola quede ordenada. 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. para de esta manera realizarlas en el orden correcto (multitareas). 3. Otro ejemplo puede verse en los sistemas informáticos.9. en la cual retirar un ítem es una operación inmediata. APLICACIÓN DE PILAS Y COLAS [Estructura de Datos] Lic. controlando partidas y aterrizajes de aviones. en la cual el proceso de inserción es inmediato. Otra forma de representación es a través de una lista desordenada.10. como por ejemplo el funcionamiento de un aeropuerto. COLAS DE PRIORIDADES Una cola de prioridad es una estructura característica. entonces la regla usual utilizada es que el primer ítem insertado es el que se retirará primero.

ya que un array unidimensional sólo tiene dos puntos fijos. la pila 1 crecerá incrementando los índices hacia A[n] y la pila 2 lo hará decrementando los índices hacia A[1]. La división inicial de A[1. el array A se puede dividir en segmentos de igual tamaño. y asignar a cada uno de los segmentos a una pila.Hasta ahora se ha tratado solamente con la representación en memoria y manipulación de una única pila o cola. es posible utilizar eficientemente todo el espacio disponible. Supongamos que seguimos transformando las estructuras de datos en representaciones Secuenciales.. Se han visto dos representaciones secuenciales eficientes para dichas estructuras. Sin embargo. A[1. en ocasiones. [Estructura de Datos] Lic. De esta manera. de forma que se cumpla la condición f(i)=c(i) si y solamente si la pila i está vacía. no es posible seguir la misma estrategia. Katya Perez Martinez Page 61 . Si se plantea representar más de dos pilas sobre ese mismo array A. es necesario dividir en m segmentos la memoria disponible. por ejemplo m pilas. y cada pila requiere un punto fijo para representar el elemento más profundo.n] en segmentos se puede hacer en base al tamaño esperado de cada una de las estructuras. Si sólo hay que representar dos pilas sobre un mismo array A[1. Si no es posible conocer esa información. es preciso representar varias estructuras utilizando el mismo espacio de memoria. tipo array. Para cada pila i. Se puede hacer crecer las dos pilas partiendo desde los extremos opuestos del array.n]. Cuando se requiere representar secuencialmente más de dos pilas. 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. En general. se hace que f(i) esté una posición por debajo del fondo real de la pila. Entonces.n]. 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. A[1] y A[n]... la solución puede resultar simple.

mírate en el espejo de ti mismo y serás libre y fuerte mírate en el espejo de ti mismo y serás libre y fuerte y dejarás de ser un títere de las circunstancias. 14. Hallar el menor elemento de la cola 10. Lic. 15. Utilice colas circulares resuelva el problema de Josefo. Realizar un programa para eliminar los elementos positivos de una cola.. 2.EJERCICIOS 1. 8. Utilizando 13. Escriba un programa que invierta los elementos de una cola. una estructura de cola para simular el movimiento de clientes en una cola de espera de un banco. Insertar dos elementos después del elemento X de la cola 5. Sumar dos colas A y B en una Cola C. Intercambiar cada elemento con su adyacente. Eliminar los elementos impares de la cola lineal 4. CAPÍTULO RECURSIVIDAD [Estructura Aprende a nacer desde el dolor y a ser más grande Aprende a nacer desde el dolor y a ser más grande que el más grande de los obstáculos. Intercambiar el elemento del frente de la cola por el elemento del final de la cola. 9. 4. que el más grande de los obstáculos. Eliminar los elementos múltiplos de X de la cola circular 12. de Datos] porque tu mismo eres tu destino. Escriba un procedimiento para insertar un elemento en una doble cola Escriba un programa que cree una pila a partir de una cola. y dejarás de ser un títere de las circunstancias. Escribir un programa para intercambiar con su adyacente los elementos de una cola 3. Katya Perez Martinez Pablo Neruda Pablo Neruda Page 62 . Llevar los elementos primos al frente de la cola 11. 7. porque tu mismo eres tu destino. Hallar el promedio de los elementos de la cola 6.

etc. – Soluciones más simples. Katya Perez Martinez Page 63 . AMBITO DE APLICACIÓN: – General – Problemas cuya solución se puede hallar solucionando el mismo problema pero con un caso de menor tamaño.4. 4. Se dice que un objeto es recursivo. do-while.1.2. ¿EN QUÉ CONSISTE LA RECURSIVIDAD? En el cuerpo de sentencias del subalgoritmo se invoca al propio subalgoritmo para resolver “una versión más pequeña” del problema original.3. que hacen uso de bucles while. • Condición necesaria: ASIGNACIÓN DINÁMICA DE MEMORIA 4. for. Son recursivos aquellos algoritmos que. si en parte está formado por sí mismo o se define en función de sí mismo El concepto de recursividad va ligado al de repetición. 4. estando encapsulados dentro de una función. RAZONES DE USO: – Problemas “casi” irresolubles con las estructuras iterativas. en contraposición a los algoritmos iterativos.4. INTRODUCCIÓN Definición de Recursividad: Técnica de programación muy potente que puede ser usada en lugar de la iteración. – Soluciones elegantes. Habrá un caso (o varios) tan simple que pueda resolverse directamente [Estructura de Datos] Lic. son llamados desde ella misma una y otra vez.

FORMA DE ENFRENTAR PROBLEMAS RECURSIVOS.sin necesidad de hacer otra llamada recursiva.....) INICIO . a) Debe existir un caso BASE o Fin de recursión ete debe ser un caso en que la función se puede computar en forma simple (sin llamar a ninguna "copia" de ella).. Katya Perez Martinez Page 64 . ALGORITMO Recursivo(. El ejemplo clásico de esto último es el recorrido de arboles.. . FIN “. No importa cuan difícil sea ese problema. • Aspecto de un subalgoritmo recursivo. Este es el caso en que se DETIENE la recursión b) b) Parte puramente recursiva Se debe confiar en que.5.... Hay que verificar que el problema "más pequeño" sea efectivamente MÁS PEQUEÑO. es decir. ESA función VA A RESOLVER EL PROBLEMA QUE LE ENTREGAMOS. 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”. debemos creer que lo soluciona. Recursivo(..). al llamar a una COPIA de la función. que el problema esté más cerca de [Estructura de Datos] Lic. Como el costo de la programación aumenta con regularidad y el costo de la computación disminuye. 4. 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.

} En la siguiente figura vemos el proceso de la recursividad [Estructura de Datos] Lic. return ( res ). res=1. i++ ) res = res * i. La idea es que sepamos que en cada llamada recursiva estamos mas cerca del caso BASE PROBLEMA DE TAMAÑO N PEQUEÑO CALCULO + PROBLEMA DE TAMAÑO N-1 Ejemplo definición de nº natural: El N º 0 es natural El Nº n es natural si n-1 lo es El factorial de un número natural esta definido como: n! = n*(n-1)*(n-2)* . i <= n. } //RECURSIVO: int Factorial ( int n ) { if (n == 0) return (1).. return (n * Factorial (n-1) ). for (i=1. *3*2*1 con 0!= 1 claramente se ve que: n! = n * (n-1)! ^ ^ ^ | | | | | Problema de tamaño (n-1) | Calculo Problema de tamaño n //ITERATIVO: int Factorial( int n ) { int i.solucionarse. Katya Perez Martinez Page 65 ..

Katya Perez Martinez Page 66 . [Estructura de Datos] Lic.  Recursividad múltiple: Se da cuando hay más de una llamada a sí misma dentro del cuerpo de la función.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. TIPOS DE RECURSIVIDAD  Recursividad simple: Aquella en cuya definición sólo aparece una llamada recursiva. se efectúa la operación de vaciar la pila efectuando todos los cálculos que previamente se habían dejado pendientes Por lo general. Se puede transformar con facilidad en algoritmos iterativos. 4. en donde la operación original se deja en el fondo y en el tope aparecería el caso base.6. Una vez que se llenó la pila. 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. resultando más dificil de hacer de forma iterativa. los lenguajes de alto nivel como el C.

1) ). return ( Fib( n-1) + Fib(n-2) ). return (impar (nump-1) ). int Ack ( int n.7. }  Recursividad anidada: En algunos de los arg.m-1) ) ). } 4. Katya Perez Martinez Page 67 . LA PILA DE RECURSION [Estructura de Datos] Lic. a través de otras funciones. } int impar ( int numi ) { if ( numi == 0 ) return(0). return( Ack (n-1. de la llamada recursiva hay una nueva llamada a sí misma.Ejemplo int Fib( int n ) /* ej: Fibonacci */ { if ( n <=1) return(1). Ejemplo: Par o Impar: int par ( int nump ) { if ( nump == 0 ) return(1). }  Recursividad cruzada o indirecta: Son algoritmos donde una función provoca una llamada a sí misma de forma indirecta. return( par ( numi -1) ). Ack(n. int m ) /* ej: Ackerman */ { if (n == 0 ) return (m+1) else if ( m == 0 ) return (Ack (n-1.

se libera la memoria asignada en la pila y se vuelve a la instrucción actual.8. 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. Pila del programa: Parte destinada a las variables locales y parámetros de la función que está siendo ejecutada. Segmento de datos: Parte de la memoria destinada a almacenar las variables estáticas. Se crean más copias hasta llegar a los casos bases. Montículo: Parte de la memoria destinada a las variables dinámicas. 4. En el caso recursivo. donde se resuelve directamente el valor. En ese momento se crean en la pila nuevos parámetros y variables locales. LA LLAMADA A UNA FUNCIÓN Se reserva espacio en la pila para los parámetros de la función y sus variables locales. int exp ) { if (exp == 0 ) return(1). Se guarda en la pila la dirección de la línea de código desde donde se ha llamado a la función. exp- Page 68 .La memoria del ordenador se divide (de manera lógica. } base * xelevn (base . El nuevo ejemplar de función comieza a ejecutarse. Al terminar la función. Máquina. no física) en varios segmentos (4): Segmento de código: Parte de la memoria donde se guardan las instrucciones del programa en cod. Se almacenan los parámetros de la función y sus valores en la pila. [Estructura de Datos] Lic. y se va saliendo liberando memoria hasta llegar a la primera llamada (última en cerrarse) EJERCICIOS 1) Calcular x elevado a n de forma recursiva: 3^2 = 9 3^0 = 1 float xelevn ( float base. Katya Perezreturn( Martinez 1)).

int b ) { if ( b == 0 ) return(0). Katya Perez Martinez Page 69 . return( a + multi(a. Multiplicar 2 nºs con sumas sucesivas recursiva: 3*2 = 6 int multi( int a. } C) realizar en forma recursiva la función de Stirling d) implementar en forma recursiva la función de ackerman e) implementar en forma recursiva el problema de las torres de Hanoi [Estructura de Datos] Lic.b). b-1) ).

5. tienen una propiedad común: son estáticos. INTRODUCCIÓN A LAS ESTRUCTURAS DE DATOS DINÁMICA Hasta ahora. ya sean simples o estructurados. pero no su estructura. Evitemos la muerte en suaves cuotas. La técnica usada para manejar estas situaciones es la asignación dinámica de memoria. no preguntando de un asunto que desconoce o no respondiendo cuando le indagan sobre algo que sabe. recordando Evitemos la muerte en suaves cuotas. no preguntando de un asunto que desconoce de iniciarlo. quien abandona un proyecto antes Muere lentamente. que el simple hecho de respirar. Capitulo IV Listas Enlazadas Muere lentamente. Pablo Neruda Pablo Neruda 5. Ejemplo 2: [Estructura de Datos] Lic. Son variables estáticas y se definen en tiempo de compilación. Hay muchas situaciones en las que se desea cambiar el tamaño de las estructuras usadas. Con este tipo de asignación se tendrán variables dinámicas o referenciadas. Ejemplo 1: Si se declara un Vector de 5 elementos de tipo int. Katya Perez Martinez Page 70 . 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. éste podrá cambiar su contenido. que pueden crearse y destruirse en tiempo de ejecución. recordando siempre que estar vivo exige un esfuerzo mucho mayor siempre que estar vivo exige un esfuerzo mucho mayor que el simple hecho de respirar. o no respondiendo cuando le indagan sobre algo que sabe. quien abandona un proyecto antes de iniciarlo.1. todos los tipos de datos que se han visto.

). apellidos. ¿Qué estructura puede utilizarse para realizarla? Una respuesta inmediata pareciera ser la de usar un array (vector o matriz). Ejemplo 3: Bases de datos para almacenar los datos de los estudiantes de la universidad Elementos de un dibujo de pantalla. etc.Si se pide diseñar un programa para gestionar una agenda de teléfonos con los datos de personas (nombre. cumpleaños. ÁRBOLES Y GRAFOS [Estructura de Datos] Lic. cuyo tamaño depende del dibujo trazado 5.2. teléfono.. pueden surgir los siguientes problemas: ¿Qué pasa si se quieren insertar más personas de MAX en la agenda? Hay que recompilar el programa para ampliar MAX Si el número de personas de la agenda es mucho menor que MAX se está desperdiciando memoria que podría ser utilizada por otros programas En muchos otros casos no es posible conocer anteladamente el numero de “elementos” que se van a usar. Katya Perez Martinez Page 71 . email. MECANISMOS PARA ENLAZAR INFORMACIÓN 1.. dirección. 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. Si se usa un arreglo de dimensión MAX.

5.  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 sucesor de un elemento es NULL.  Cuando la cabeza es NULL.  Una lista enlazada es una estructura de datos en la que los objetos están ubicados linealmente. la cantidad de los mismos puede variar.  Si el predecesor de un elemento es NULL. LISTAS ENLAZADAS Las listas enlazadas son estructura de datos naturales donde el número de elementos que la integran no es conocido. Gráficamente una lista simplemente enlazada se representa de la siguiente forma: Dirección de memoria Cabeza de la Lista Nodo 23 P Ultimo elemento de la Lista Info 12 4 enlace NOTA Las listas almacenadas en arreglos están sujetos al tamaño del arreglo para su crecimiento. se trata de la cabeza de la lista. o en su mejor caso. la lista está vacía o no existe la lista Toda lista cuenta con una cabecera y nodos. Katya Perez Martinez Page 72 . se trata de la cola de la lista.3. Si estos están vacíos se esta ocupando [Estructura de Datos] Lic.

TIPO DE DATO ABSTRACTO NODO Un NODO es una estructura compuesta básicamente de dos partes:  Un campo de información.memoria sin uso. Una lista enlazada es una secuencia ordenada de elementos llamados nodos 5.  Todos los nodos de la lista son del mismo tipo. Katya Perez Martinez ListaLineal P: Nodo InsertarInicio(e) InsertarFinal() EliminarInicio() EliminarFinal() Recorrido() Page 73 . en el cual se almacena la dirección del nodo siguiente.  Características:  Las listas son una secuencia ordenada de elementos llamados nodo  Toda lista tiene una cabecera y una cola. La implementación de un nodo podría ser de la siguiente forma: 5. en cual se almacenan datos o estructuras  Un campo de dirección.5. Además las listas reflejan el orden lógico y el orden físico de los elementos en el arreglo. CONSTRUCCIÓN DE UN TAD LISTA ENLAZADA LINEAL SIMPLE Nodo Info: tipo_dato Dirsgte: Nodo Nodo() [Estructura de Datos] Lic.4.

La estructura del nodo para una lista enlazada Lineal Simple es la siguiente. o remover todos los elementos de la misma. OPERACIONES BÁSICAS SOBRE LISTAS ENLAZADAS Existen cinco operaciones básicas que se pueden hacer sobre listas enlazadas:  Creación: de una lista vacía  Vacía: Retorna verdadero si la lista L está vacía y falso en caso contrario.6.  Acceso: Examinar el primer elemento de la lista. dirsgte: almacena la dirección del siguiente nodo de la lista.  Anula: Permite convertir la lista en una lista vacía  Imprime Lista: Imprime los elementos de la lista L [Estructura de Datos] Lic. private nodo () { } } Donde: Info: es la información del nodo.  Buscar: ver si la lista contiene un elemento determinado. para datos de tipo doublé.  Eliminar: Se puede quitar el primer elemento de la lista. Katya Perez Martinez Page 74 . en caso de ser el último nodo entonces apunta a nulo. implementado en java private class nodo { private double info. private nodo dirsgte. 5.  Inserción: Agregar un elemento al final de la lista.

if (p == null) p = q.Creación de una lista vacía A continuación implementamos la sentencia para crear una lista vacía en java.dirsgte. nodo t = p.dirsgte = null.dirsgte = p. Lic. else { while (t. q.info = elem. q. nodo p = null.dirsgte = q. La implementación en java es la siguiente: public void insertarFinal (double elem) { //Inserta un elemento elem al final de la lista p en el nodo q nodo q = new nodo (). t. a continuación se muestra la implementación en public void insertarInicio (double elem) java: { //Aniadir un elemento al principio de la lista nodo q = new nodo ().dirsgte != null) t = t. } } b) Inserción al Inicio de la lista En el siguiente segmento de código se implementa el caso en el que el nuevo nodo se inserta en la cabeza de la lista. [Estructura de Datos] Page 75 q. Katya Perez Martinez p = q. } . Inserción a) Inserción al Final de la lista En el siguiente segmento de código se ejemplifica solamente el caso en el que el elemento se adiciona al final de la lista tal y como si se tratase de una estructura Pila o Cola.info = elem. q.

a partir del nodo cabeza de la lista hasta encontrar el último nodo.out.dirsgte.println (" .out...info + " ").RECORRIDO DE LA LISTA.... Katya Perez Martinez } } . public void recorrido () { //Recorrer la lista System. Recordemos que el último nodo tiene la propiedad que su miembro dirsgte es igual a NULL. [Estructura de Datos] Page 76 q = q..10). nodo q = p.Para el siguiente ejemplo se ilustra el proceso de adición de un nuevo nodo p = Inserta_Inicio(&p. while (q != null) { System. Lic."). c) Recorrido de una Lista: Para mostrar los elementos de la lista se realiza el recorrido de la misma.println (q.

else { nodo t = p. q = null.d) Eliminar el nodo del inicio de la Lista La siguiente función recibe una lista y devuelve esa misma lista.dirsgte. if (p.dirsgte != null) { t = q.dirsgte = null. while (q. q = q. [Estructura}de Datos] Lic.dirsgte. } t. q = null. sin el nodo que ocupaba inicialmente la posición de la cabeza. } e) Eliminar el nodo del Final de la Lista void eliminaFinal () { //elimina un nodo del final de la lista nodo q = p. Katya Perez } Martinez Page 77 . p = p. La función será la siguiente: void eliminaInicio () { //elimina el nodo del inicio de la lista nodo q = p.dirsgte == null) p = null.

[Estructura de Lic.dirsgte. A continuación realizamos la implementación del programa completo de public class listaLineal { listas simples. private nodo dirsgte. Page 78 . Katya Perez Martinez else { while (t.io. es el puntero cabecera private nodo p = null. } public void insertarFinal (double elem) { //Inserta un elemento elem al final de la lista p en el nodo q nodo q = new nodo ().*.dirsgte = p. if (p == null) p =Datos] q. IPLEMENTACIÓN EN EL LENGUAJE JAVA DE LA CLASE LISTAS LINEALES //LISTAS LINEALES import java. p = q.dirsgte != null) t = t.7. q.dirsgte = null. q. nodo t = p.5. //crea la lista p //nodo de una lista lineal simplemente enlazada private class nodo { private double info. para datos de tipo doublé en java //p: referencia al primer elemento de la lista. q. q. private nodo () { } } public listaLineal () { } public void insertarInicio (double elem) { //Aniadir un elemento al principio de la lista nodo q = new nodo ().info = elem.info = elem.

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

io..*. class ejemLista1 { public static void main (String args[]) throws IOException { EJERCICIO //crear una lista lineal L vacia listaLineal L para = new listaLineal ().println ("Cuantos elementos desea ingresar a la lista ?"). N = Integer.. Escribir una aplicación en java llamar a todas las operaciones con listas. dato = br. insertarFinal (elem).doubleValue ().recorrido (). } } } import java.println ("ingrese elemento ."). Katya Perez Martinez } } Page 80 . L. [Estructura de Datos] Lic.eliminaInicio ().valueOf (dato). L. for (int i = 1 . dato = br.eliminaFinal (). elem = Double.out.out. i++) { System. L.parseInt (dato).readLine ().double elem. i <= N . //leer datos reales y agregarlos a la lista L.readLine (). System.. L. L.recorrido ().llenarLista ().recorrido ().

uno de ellos apuntando a su predecesor (li) y otro a su sucesor (ld).8. La estructura de un nodo en una lista doble es la siguiente: Existen dos tipos de listas doblemente ligadas:  Listas dobles lineales. [Estructura de Datos] Lic. Por medio de estos punteros se podrá avanzar o retroceder a través de la lista.5. Katya Perez Martinez Page 81 . LISTAS DOBLEMENTE ENLAZADAS Una 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. En este tipo de lista doble. según se tomen las direcciones de uno u otro puntero.  Listas dobles circulares. En este tipo de lista doble. ó doblemente enlazada es una colección de nodos en la cual cada nodo tiene dos punteros. tanto el puntero izquierdo del primer nodo como el derecho del último nodo apuntan a NIL.

Debido a que las listas dobles circulares son más eficientes. y p para referenciar al nodo presente. Algoritmo de creación top<--NIL repite si top=NIL entonces new(p) lee(p(dato)) p(ld)<--p p(li)<--p top<--p en caso contrario new(p) lee(p(dato)) p(ld)<--top p(li)<--p p(ld(li))<--p mensaje(otro nodo?) lee (respuesta) hasta respuesta=no [Estructura de Datos] Lic. En la figura siguiente se muestra un ejemplo de una lista doblemente ligada lineal que almacena números: En la figura siguiente se muestra un ejemplo de una lista doblemente ligada circular que almacena números: A continuación mostraremos algunos algoritmos sobre listas enlazadas. los algoritmos que en esta sección se traten serán sobre listas dobles circulares. Katya Perez Martinez Page 82 . también usaremos el apuntador top para hacer referencia al primer nodo en la lista. Como ya se mencionó. llamaremos li al puntero izquierdo y ld al puntero derecho.

Algoritmo para recorrer la lista --RECORRIDO A LA DERECHA. Katya Perez Martinez Page 83 . p<--top repite escribe(p(dato)) p<--p(li) hasta p=top(li) Algoritmo para insertar antes de 'X' información p<--top mensaje (antes de ?) lee(x) repite si p(dato)=x entonces new(q) leer(q(dato)) si p=top entonces top<--q q(ld)<--p q(li)<--p(li) p(ld(li))<--q p(li)<--q p<--top en caso contrario p<--p(ld) hasta p=top Algoritmo para insertar despues de 'X' información p<--top mensaje(despues de ?) lee(x) repite si p(dato)=x entonces new(q) [Estructura de Datos] Lic. p<--top repite escribe(p(dato)) p<--p(ld) hasta p=top --RECORRIDO A LA IZQUIERDA.

Katya Perez Martinez Page 84 . Enseguida se mostrarán los algoritmos más comunes en listas circulares. utilizaremos el apuntador top para hacer referencia al primer nodo en la lista. LISTAS CIRCULARES DOBLES Las listas circulares tienen la característica de que el último elemento de la misma apunta al primero La siguiente figura es una representación gráfica de una lista circular.lee(q(dato)) q(ld)<--p(ld) q(li)<--p p(li(ld))<--q p(ld)<--q p<--top en caso contrario p<--p(ld) hasta p=top Algoritmo para borrar un nodo p<--top mensaje(Valor a borrar) lee(valor_a_borrar) repite si p(dato)=valor_a_borrar entonces p(ld(li))<--p(ld) p(li(ld))<--p(li) si p=top entonces si p(ld)=p(li) entonces top<--nil en caso contrario top<--top(ld) dispose(p) p<--top en caso contrario p<--p(ld) hasta p=top 5.9. Al igual que en las secciones anteriores. [Estructura de Datos] Lic.

Katya Perez Martinez Page 85 .Algoritmo de creación repite new(p) lee(p(dato)) si top=nil entonces top<--p q<--p en caso contrario q(liga)<--p q<--p p(liga)<--top mensaje (otro nodo ?) lee(respuesta) hasta respuesta=no Algoritmo para recorrer la lista p<--top repite escribe(p(dato)) p<--p(liga) hasta p=top Algoritmo para insertar antes de 'X' información new(p) lee(p(dato)) si top=nil entonces top<--p p(liga)<--top en caso contrario mensaje(antes de ?) lee(x) q<--top r<--top(liga) repite si q(dato)=x entonces p(liga)<--q r(liga)<--p si p(liga)=top entonces top<--p q<--q(liga) r<--r(liga) hasta q=top Algoritmo para insertar después de 'X' información new(p) lee(p(dato)) mensaje(después de ?) lee(x) q<--top r<--top(liga) repite si q(dato)=x entonces q(liga)<--p p(liga)<--r [Estructura de Datos] Lic.

Insertar un nuevo nodo después del tercer nodo de la lista lineal 3. Es decir antes de insertar un determinado elemento se debe verificar antes que éste no se encuentre en la lista. Escriba un programa que permita adicionar elementos no repetidos a una lista. una vez insertado X. adicionar un elemento X a una lista de forma ordenada. 5. Eliminar todos los elementos X dado por el usuario de una lista circular simple.q<--q(liga) r<--r(liga) hasta q=top Algoritmo para borrar mensaje(valor a borrar ) lee(valor_a_borrar) q<--top r<--top p<--top mientras q(liga)<>top haz q<--q(liga) repite si p(dato)=valor_a_borrar entonces si p=top entonces si top(liga)=top entonces top<--NIL en caso contrario top<--top(liga) q(liga)<--top en caso contrario r(liga)<--p(liga) dispose(p) p<--top en caso contrario r<--p p<--p(liga) hasta p=top EJERCICIOS 1. 4. Katya Perez Martinez Page 86 . de tal forma que la lista quede ordenada. [Estructura de Datos] Lic. Eliminar el primer elemento negativo de la lista lineal 2.

Escriba un programa que permita eliminar el elemento de la cola de una lista 7. Eres el único responsable por ella. Eres el único responsable por ella. Cuando tus amigos cambian. X dado por el usuario 8. Considere que dos listas L1 y L2. Y no te dejes vencer" "examínate. Cuando tu pareja cambia. Insertar N nodos nuevos después del nodo K-esimo. 6.1. Eliminar N nodos desde la posición k de la lista enlazada circular simple. Katya Perez Martinez Page 87 . cuando tu cambias. "examínate. de la lista L2. Cuando tus padres cambian.6. Tu vida cambia. Tu vida no cambia cuando cambia tu jefe. 9. 10.. Cuando tu pareja cambia. cuando tu cambias. DEFINICIÓN ÁRBOL [Estructura de Datos] Lic. Tu vida cambia.. En una lista doble eliminar todos los elementos cuya información sea X. entonces se desea llevar todos los elementos impares al final de la lista L1. Y no te dejes vencer" 6. Cuando tus padres cambian. Cuando tus amigos cambian. Capitulo VI Árboles y Grafos Tu vida no cambia cuando cambia tu jefe. ya tienen elementos de tipo doublé.

Este es el nodo que usaremos para referirnos al árbol.2. CONCEPTOS BÁSICOS a. 'C' y 'D'. Katya Perez Martinez Page 88 . es decir. 'H'. En cuanto a la posición dentro del árbol: c. En el ejemplo. ese nodo es el 'A'. 6. 'K'. y es lo que en realidad les da la apariencia de árboles. b. [Estructura de Datos] Lic. Esto hace que estos árboles estén fuertemente jerarquizados. 'N' y 'O'. Nodo padre: nodo que contiene un puntero al nodo actual. d. En el ejemplo hay varios: 'G'. 'L'. 'L' y 'M' son hijos de 'F'. Nodo raíz: nodo que no tiene padre. En el ejemplo. Nodo hoja: nodo que no tiene hijos. el nodo 'A' es padre de 'B'. 'I'.Un árbol es una estructura no lineal en la que cada nodo puede apuntar a uno o varios nodos. 'M'. cada nodo sólo tendrá un padre. Nodo hijo: cualquiera de los nodos apuntados por uno de los nodos del árbol. Los árboles con los que trabajaremos tienen otra característica importante: cada nodo sólo puede ser apuntado por otro nodo. En el ejemplo.

La representación gráfica de un árbol binario es la siguiente: [Estructura de Datos] Lic. 'E'. etc. En el árbol del ejemplo. con relación a su tamaño: f. etc.3. i. si puede apuntar a tres será de orden tres. Existen otros conceptos que definen las características del árbol. estos son los nodos que no pertenecen a ninguna de las dos categorías anteriores. En el ejemplo: 'B'. Así sucesivamente. 6. y el nodo 'N'. 'C'. Nivel: se define para cada elemento del árbol como la distancia a la raíz. 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. la 'H' cero. g. la rama 'B' tiene altura 2. 'F' y 'J'. 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. también podemos hablar de altura de ramas. diremos que un árbol en el que cada nodo puede apuntar a otros dos es de orden dos. Nodo rama: aunque esta definición apenas la usaremos. medida en nodos. Orden: es el numero potencial de hijos que puede tener cada elemento de árbol. Katya Perez Martinez Page 89 . ya que tanto 'A' como 'D' tienen tres hijos. el nodo 'D' tiene nivel 1.e. y no existen elementos con más de tres hijos. Como cada nodo de un árbol puede considerarse a su vez como la raíz de un árbol. En el ejemplo. la rama 'G' tiene altura 1. h. Grado: el número de hijos que tiene el elemento con más hijos dentro del árbol. el nodo 'G' tiene nivel 2. De este modo. El nivel de la raíz es cero y el de sus hijos uno. Altura: la altura de un árbol se define como el nivel del nodo de mayor nivel. nivel 3. 'D'. El árbol del ejemplo tiene altura 3. el grado es tres.

mientras que las dinámicas están representadas por listas. [Estructura de Datos] Lic. Los arboles pueden ser construidos con estructuras estáticas y dinámicas. La definición de árbol es la siguiente: es una estructura jerárquica aplicada sobre una colección de elementos u objetos llamados nodos. hijo. llamados subarboles. además se crea una relación o parentesco entre los nodos dando lugar a términos como padre.Los arboles representan las estructuras no lineales y dinámicas de datos más importantes en computación . registros y conjuntos. sucesor. 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. Las estáticas son arreglos. antecesor. 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. etc. puesto que a cada elemento del árbol pueden seguirle varios elementos. La figura siguiente representa a un árbol general.. Katya Perez Martinez Page 90 . Una forma particular de árbol puede ser la estructura vacía. Dinámicas porque las estructuras de árbol pueden cambiar durante la ejecución de un programa. ansestro. No lineales. uno de los cuales es conocido como raíz. hermano.

Por medio de arreglos. Enlazar en forma vertical el nodo padre con el nodo hijo que se encuentra más a la izquierda. para construir un árbol genealógico. Para esto.Los arboles tienen una gran variedad de aplicaciones. Los nodos del árbol binario serán representados como registros que contendrán como mínimo tres campos. Por ejemplo. debe eliminarse el vínculo de ese padre con el resto de sus hijos. Rotar el diagrama resultante aproximadamente 45 grados hacia la izquierda. Enlazar los hijos de cada nodo en forma horizontal (los hermanos). Sin embargo la más utilizada es la primera.4. puesto que es la más natural para tratar este tipo de estructuras. EN UN ARBOL BINARIO Estableceremos los mecanismos necesarios para convertir un árbol general en un árbol binario.5. Katya Perez Martinez Page 91 . se pueden utilizar para representar fórmulas matemáticas. 6. debemos seguir los pasos que se describen a continuación: 1. para el análisis de circuitos eléctricos y para numerar los capítulos y secciones de un libro. 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. para organizar adecuadamente la información. TRANSFORMACIÓN DE UN ARBOL GRAL. y así se obtendrá el árbol binario correspondiente. En un campo se almacenará la [Estructura de Datos] Lic. 2. 6. Además. 3.

Cada nodo se representa gráficamente de la siguiente manera: El algoritmo de creación de un árbol binario es el siguiente: Procedimiento crear(q:nodo) inicio mensaje("Rama izquierda?") lee(respuesta) si respuesta = "si" entonces new(p) q(li) <-. B. Similares. Katya Perez Martinez Page 92 .  A. [Estructura de Datos] Lic. B.  A. CLASIFICACIÓN DE ARBOLES BINARIOS Existen cuatro tipos de árbol binario:.  A. Equivalentes. Distinto.nil crear(p) en caso contrario q(li) <-.información del nodo.6.  A.nil mensaje("Rama derecha?") lee(respuesta) si respuesta="si" entonces new(p) q(ld)<--p crear(p) en caso contrario q(ld) <--nil fin INICIO new(p) raiz<--p crear(p) FIN 6. B. Los dos restantes se utilizarán para apuntar al subarbol izquierdo y derecho del subarbol en cuestión. Completos. B.

B. SIMILARES Dos arboles binarios son similares cuando sus estructuras son idénticas. Ejemplo: A. Ejemplo: A. B.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. B. RECORRIDO DE UN ARBOL BINARIO [Estructura de Datos] Lic. Ejemplo: A. tiene dos hijos. pero la información que contienen sus nodos es diferente. EQUIVALENTES Son aquellos arboles que son similares y que además los nodos contienen la misma información. COMPLETOS Son aquellos arboles en los que todos sus nodos excepto los del ultimo nivel. el subarbol izquierdo y el subarbol derecho 6.7. DISTINTO Se dice que dos árboles binarios son distintos cuando sus estructuras son diferentes. Katya Perez Martinez Page 93 . B. A.

preorden y postorden. 3. o recorrer el subarbol derecho en preorden. o Recorrer el subarbol derecho en postorden. A continuación se muestra un ejemplo de los diferentes recorridos en un árbol binario. o Examinar la raíz. Cada una de ellas tiene una secuencia distinta para analizar el árbol como se puede ver a continuación: 1. 2. ARBOLES ENHEBRADOS [Estructura de Datos] Lic. INORDEN o Recorrer el subarbol izquierdo en inorden. Inorden: GDBHEIACJKF Preorden: ABDGEHICFJK Postorden: GDHIEBKJFCA 6. Katya Perez Martinez Page 94 . PREORDEN o Examinar la raíz. POSTORDEN o Recorrer el subarbol izquierdo en postorden.8. o Recorrer el subarbol izquierdo en preorden. o Recorrer el subarbol derecho en inorden.Hay tres manera de recorrer un árbol : en inorden. o Examinar la raíz.

El siguiente ejemplo es un árbol binario enhebrado a la derecha.  ARBOL ENHEBRADO A LA IZQUIERDA.Existe un tipo especial de árbol binario llamado enhebrado. Un ejemplo de arbol binario de búsqueda es el siguiente: [Estructura de Datos] Lic.  ARBOL ENHEBRADO A LA DERECHA. el cual contiene hebras que pueden estar a la derecha o a la izquierda. Este tipo de árbol tiene un apuntador a la derecha que apunta a un nodo antecesor. Estos arboles tienen un apuntador a la izquierda que apunta al nodo antecesor en orden 6. Katya Perez Martinez Page 95 . 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. La ventaja especial de utilizar un árbol es que se facilita la búsqueda.9. ARBOLES BINARIOS DE BÚSQUEDA Un árbol de búsqueda binaria es una estructura apropiada para muchas de las aplicaciones que se han discutido anteriormente con listas.

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. V2. V2-&gtV3.. Es cuando todos sus vértices. tal que cada uno de estos V1-&gtV2.  LONGITUD DE CAMINO.Es una secuencia de vértices V1. GRAFOS Un grafo dirigido G consiste en un conjunto de vértices V y un conjunto de arcos o aristas A. . excepto tal vez el primero y el último son distintos.6. Es un camino simple de longitud por lo menos de uno que empieza y termina en el mismo vértice. Katya Perez Martinez Page 96 . Es el número de arcos en ese camino..10. .W) donde V es el vértice inicial y W es el vértice terminal del arco. V1-&gtV3. es un par ordenado de vértices(V.  Flujo y control en un programa. 6. Los vertice se denominan también nodos o puntos.  CICLO SIMPLE. DEFINICIONES BÁSICAS La terminología que manejaremos regularmente para el uso de grafos es la siguiente:  CAMINO. [Estructura de Datos] Lic. Las aplicaciones más importantes de los grafos son las siguientes:  Rutas entre ciudades. Vn. V3. Los arcos se utilizan para representar relaciones entre estos objetos.11. Un arco.  CAMINO SIMPLE.  Determinar tiempos máximos y mínimos en un proceso.

Un grafo G es conexo. ARISTAS PARALELAS.El grado de salida de un nodo V de un grafo G. costo ó un valor de cualquier tipo de dato.  GRAFO ACICLICO.  GRAFO UNILATERALMENTE CONEXO.  GRAFO PESADO ó ETIQUETADO. es el número de arcos o aristas que empiezan en V. Se dice que un grafo es aciclíco cuando no contiene ciclos. Katya Perez Martinez Page 97 .W) de G hay un camino de V a W o un camino de W a V. Una etiqueta puede ser un nombre. Es cuando hay más de una arista con un vértice inicial y uno terminal dados.Un grafo dirigido G es completo si para cada par de nodos (V. Un nodo o vértice V es adyacente al nodo W si existe un arco de m a n.  GRAFO CICLICO.  NODO FUENTE. es el número de aristas que terminan en V. y el número asociado al arco se le denomina factor de peso.  GRADO DE SALIDA. También a este grafo se le denomina red de actividades.  GRAFO CONEXO. es decir que cada nodo G es adyacente a todos los demás nodos de G.El grado de entrada de un nodo V de un grafo G.  GRADO DE ENTRADA. Se dice que un grafo es cíclico cuando contiene por lo menos un ciclo.Se le llama así a los nodos que tienen grado de salida positivo y un grado de entrada nulo. [Estructura de Datos] Lic.W) existe un camino de V a W y de W a V (forzosamente tendrán que cumplirse ambas condiciones). si y solo si existe un camino simple en cualesquiera dos nodos de G.  VERTICE ADYACENTE.Un grafo G es unilateralmente conexo si para cada par de nodos (V.  GRAFO COMPLETO ó FUERTEMENTE CONEXO. Un grafo es pesado cuando sus aristas contienen datos (etiquetas).

 NODO SUMIDERO. Una lista de adyacencia. es una matríz de dimensión n*n. donde matríz M[i.13.j] es verdadero si y solo si existe un arco que vaya del vértice y al vértice j. Una matríz de adyacencia.Se le llama sumidero al nodo que tiene grado de salida nulo y un grado de entrada positivo. REPRESENTACIÓN EN MEMORIA ENLAZADA Los grafos se representan en memoria enlazada mediante listas de adyacencia. que se obtuvo a partir del grafo anterior es la siguiente:  6. Veamos el siguiente grafo dirigido: La matríz de adyacencia. Katya Perez Martinez Page 98 . 6.12. se define de la siguiente manera: Para un vértice i es una lista en cierto orden formada por todos los vértices [Estructura de Datos] Lic. REPRESENTACIÓN EN MEMORIA SECUENCIAL Los grafos se representan en memoria secuencial mediante matrices de adyacencia. en donde n es el número de vértices que almacena valores booleanos.

adyacentes [a. Katya Perez Martinez Page 99 .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. que se obtuvo a partir del grafo anterior es la siguiente: Otros ejemplos de Representación de grafo son los siguientes [Estructura de Datos] Lic. Veamos el siguiente grafo dirigido: La lista de adyacencia.

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

:

Creación.

Inserción.

Búsqueda.

Eliminación.

En esta sección, continuaremos utilizando los apuntadores que se usaron
en las secciones anteriores. TOP para hacer referencia al primer nodo,
LD para indicar liga derecha y LA para indicar liga abajo, por último
usaremos los apuntadores P y Q para hacer referencia a los nuevos
nodos que vayan a ser usados.

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

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 100

p<--p(la)

ALGORITMO DE INSERCION
mensaje(valor a insertar ?)
lee(valor_a_insertar)
si top<>NIL entonces
p<--top
mientras p(la)<>NIL haz
p<--p(la)
new(q)
lee(q(dato))
p(la)<--q
q(la)<--NIL
mensaje(Hay 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

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 101

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

6.15. CAMINO MÍNIMO
Se denomina camino mínimo entre dos vértices V y W, al camino óptimo
entre ambos vértices.Para determinar el camino mínimo entre dos
vértices se utiliza el siguiente algoritmo:
desde i=1 hasta número_vértices haz
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 i=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])

[Estructura de Datos]
Lic. Katya Perez Martinez

Page 102

Se pide : Hacer un algoritmo que visualice los datos de las personas de mayor a menor edad . y un número entero . ordenados por edades . El procedimiento debe buscar el elemento NUM y una vez encontrado visualizar todos sus antecesores (los anteriores). Se pide : . Dado un árbol binario de busqueda . [Estructura de Datos] Lic. Katya Perez Martinez Page 103 . que contiene el nombre. Dado un ABB que contiene números enteros . el apellido y la edad de un grupo de personas .Hacer un procedimiento que reciba como parámetros: el puntero a raiz del arbol . 4.EJERCICIOS 3.

Conjunto de bits que contiene el código para un carácter. Tipo de estructura de datos que es un conjunto de caracteres almacenados consecutivamente. ASCII. él contenido de otra variable o el resultado de evaluar una expresión. Es uno de los posibles tipos de estructurar los datos. tienen un antecedente. dígito o carácter especial tiene su correspondiente código binario. Es la acción de poner en una variable un valor. es el más usado actualmente. 1 K (kilobyte) = 1024 bytes. (el raíz). Katya Perez Martinez Page 104 . Las capacidades de almacenamiento se miden en bytes o en sus múltiples. ASIGNACIÓN. En un programa es un grupo de instrucciones que se repiten hasta que se cumple una condición. BIFURCACIÓN. Lenguaje C orientado a objetos CADENA. C++.GLOSARIO ALGORITMO. 1Gb (Gigabyte) = 1024 Mb. Es una descripción de los pasos de una tarea. BYTE. En la mayoría de los lenguajes se representa con el signo igual. Como los ordenadores solo procesan dígitos binarios. 1 Mb (megabyte) = 1024K. C. American Standard Code for Information Interchange. cada letra. Lenguaje de programación de alto nivel que posee características de los de bajo nivel y esto lo hace adecuado para escribir software de sistemas. El byte de 8 bits. llamado octeto. Todos los elementos menos uno. Usado en programación. BUCLE. En programación: transferencia de la secuencia de ejecución a otra parte del programa. Todos pueden tener otros elementos asociados llamados consecuentes. Puede ser condicional o incondicional aunque esta última está mal vista en los lenguajes estructurados. También recibe este nombre un conjunto de programas relacionados lógicamente para realizar una tarea. Es un código muy utilizado para el intercambio de datos. [Estructura de Datos] Lic. ÁRBOL.

[Estructura de Datos] Lic. EXPRESIÓN. EJECUTAR. Cada una de las instrucciones que componen el sistema operativo y que el ordenador puede traducir en acciones específicas. COLA. Conjunto de variables. Es la unidad elemental de información desde el punto de vista externo. Tabla de traducción entre todos los posibles símbolos de dos alfabetos. constantes. CODIFICAR. Etiqueta. Mandato ejecutable por el ordenador. COMANDO. funciones y símbolos de operación que expresan un cálculo a realizar. Conjunto de datos en que sus componentes están relacionados entre sí de una forma particular y sobre los que se pueden realizar ciertas operaciones según sea el tipo de relación que hay entre ellos. Realizar una instrucción en código máquina o bien hacer que se realicen las instrucciones de un programa. Usado en programación. Programa que permite escribir y corregir ficheros de texto como documentos o programas. DIRECCIÓN. Proporcionan un valor que será del tipo (aritmético. Estructura de información consistente en una lista lineal en la que la nueva información se coloca en un extremo y la salida para procesar es por el otro extremo. Katya Perez Martinez Page 105 . COMPILADOR. alfanumérico o lógico) de las variables y constantes que contiene. Variable que contiene el número de acciones realizadas. nombre o número que identifica la posición de un dato en la memoria o en una unidad de almacenamiento EDITOR. Dígito. Ejemplos: la cola de trabajos pendientes de ejecutar o la cola de espera de impresión de resultados.CARÁCTER. Programa que traduce un programa escrito en un lenguaje de alto nivel a lenguaje de máquina. Además de traducir se detectan posibles errores de sintaxis. Es la parte de la programación consistente en escribir en un lenguaje informático el algoritmo que resuelve un problema. ESTRUCTURA DE DATOS. CONTADOR. El más conocido es el código ASCII (American Standard Code for Information Interchange). CÓDIGO. letra o símbolo que puede ser tratado por un ordenador.

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

upr.umag.uva.LECTURAS COMPLEMENTARIAS 1.cl/~rbaeza/handbook/hbook. algoritmos y material de referencia http://www. Katya Perez Martinez Page 107 .php?cap=024 http://decsai.edu. Algorithms and Data Structures Research & Reference Material".html 4.es/~jmrr/TAD2003/home.ugr. Muchas implementaciones.conclase. versión electrónica y en línea de uno de los libros sobre estructuras de datos de mayor interés (Baeza-Yates).clu.html 3.es/~lcv/Docencia/mp2/apuntes/tema3.cl/~mmarin/topinf/cs23/c++/pagina022a. http://www.net/c/curso/index. Tutorial de estructuras de datos en C++ interactivo http://decsai. Estructuras de Datos http://cuhwww.infor.csse. Estructuras arbóreas http://www.au/~lloyd/tildeAlgDS/index.es/~jfv/ed1/c++/cdrom5/index.edu/~jse/cursos/4097/notas/ 2.htm 6.monash.htm 5.uchile.dcc.htm [Estructura de Datos] Lic. Recursividad http://www. 7.ugr. MANUAL DE C++ http://kataix.pdf.

Metodología de la Programacion II [Estructura de Datos] Lic.8. Katya Perez Martinez Page 108 .