1 INTRODUCCION A LAS ESTRUCTURAS DE DATOS
1.1 AbstracciónTérminos simples:
Es un proceso mental, mediante el cual se extraen los rasgos esenciales de algo para representarlos por medio de un lenguaje gráfico o escrito. Debido a que es un proceso mental es una acción subjetiva y creativa es decir: depende del contexto psicológico de la persona que la realiza.
Términos de la POO:
Constituye un principio de la POO que:
“Enfatiza en detalles que son significativos y que suprime otros detalles que son por el momento irrelevantes”.
“Denota las características esenciales de un objeto que lo distinguen de todas las otras clases de objetos”.
1.2 Importancia de la abstracción
Dato: unidad básica de la información, que por lo general por si solo no dice nada. Información: es el conocimiento que puede comunicarse, generalmente es el conjunto
de datos pero que tienen relación y que tienen sentido;
La abstracción: es una técnica o metodología que permite diseñar o modelar Estructuras
de Datos, Consiste en representar bajos ciertos lineamientos de formato las características esenciales de una Estructura de Datos.
Su importancia radica en que la abstracción es una capacidad para modelar una realidad por medio de herramientas computacionales.
1.3 Estructuras de Datos
Cualquier colección o grupo de datos organizados, de tal forma que tengan asociados un conjunto de operaciones para poder manipularlos.
La mayoría de lenguajes de programación de alto nivel disponen de tipos de datos estructurados o estructuras de datos predefinidas.
Ejemplo: Arreglos, que no son más que un conjunto de datos, todos del mismo tipo, con
una organización lineal y con métodos claros de acceso a través de sus subíndices. Las
Tipos de Estructuras
Hacen referencia a un solo valor a la vez. Ocupan una sola casilla de memoria
Pueden ser: Entero, real, lógico carácter (donde: su tamaño depende del Lenguaje de Programación).
Se caracteriza por el hecho de que con un nombre se hace referencia a un grupo de casillas de memoria es decir ésta estructura está formada:
Por uno o varios datos simples. Por uno o varios datos compuestos.
Porque pueden tener algún tipo de comportamiento (métodos).
ED:Estructura de almacenamiento + Operaciones de manipulación (métodos).
Clasificación de las Estructuras de Datos
ESTATICAS DINAMICAS
Tienen una cantidad fija de memoria principal
Delimitan el espacio que ocupan en memoria en tiempo de
compilación
Ejemplo: Arreglos o Arrays, Cadenas
// declaración int [ ] A;
// crea un arreglo con 10
números // enteros
A = new int [ 10 ] ;
No tienen limitación en el tamaño de memoria principal ocupada
El espacio de memoria a ocupar se determina en tiempo de ejecución Ejemplo: listas, árboles, grafos, etc.
public class Nodo{ // Atributos private int dato; private Nodo sig; // Constructor
public Nodo (Nodo ns){ sig = sig;
}
// Métodos a implementar para la // clase Nodo
}
TDA: Tipo de Dato Abstracto: Es el modelo, junto con varias operaciones
definidas sobre el modelo, con lo que se representa a la estructura y el comportamiento del mundo real. El TDA, especifica el ¿Qué? más no el ¿Cómo?
1.4 Tipo de Dato Abstracto ( T.D.A)
TDA es un modelo matemático de estructuras de datos que especifica los tipos de datos almacenados, las operaciones definidas sobre esos datos y los tipos de los parámetros de esas operaciones.
COMPUESTAS SIMPLES
Un TDA define lo que cada operación debe hacer, más no como lo debe hacer. En un lenguaje de programación como Java un TDA puede ser expresado por una interface, que es una simple lista de declaraciones de métodos.
Un TDA es materializado por una estructura de datos concreta, en Java, es modelada por una clase. Una clase define los datos que serán almacenados y las operaciones soportadas por los objetos que son instancia de la clase. Al contrario de la las interfaces, las clases especifican como las operaciones son ejecutadas (Implementación).
La técnica de la abstracción de datos establece que al diseñar una nueva Estructura de Datos – pasa a ser un TDA que luego podrá ser implementado en cualquier lenguaje de programación.
Especificación lógica de un TDA
Es un documento en el que se plasma la abstracción realizada al diseñar una Estructura de Datos y a partir del cual se implementa la Estructura de Datos. En dicho documento se definirán claramente todas las reglas en las que podrá usarse el TDA
Partes:
1. Elementos que conforman la Estructura de Datos
Describe el tipo de los datos individuales que guardara la estructura. Ejemplo: números enteros, números reales, caracteres, fechas, registro con los datos de un empleado.
2. Tipo de organización en que se guardara los elementos
Lineal: Si hay una relación de uno a uno entre los elementos. (Arreglos)
Jerárquica: Si hay una relación de uno a muchos entre los elementos. (Arboles)
Red: Relación de muchos a muchos entre los elementos (grafos)
3. Dominio de la estructura (opcional)
Se describirá la capacidad de la estructura de datos en cuanto al rango posible de datos por guardar.
4. Descripción de las operaciones de la estructura
Para cada operación se debe considerar los siguientes puntos: • Nombre de la operación
Descripción breve de su utilidad • Datos de entrada a la operación
• Datos que generan como salida la operación
• Precondición: condición que debe cumplirse ANTES de utilizar la operación para que se ejecute sin problemas.
• Postcondicion : condición en que queda el TDA DESPUES de ejecutar la operación.
“Definir claramente la especificación lógica del TDA, facilita la implementación y aplicación de la Estructura de Datos.”
Importante: Averigua varios ejemplos de aplicaciones dentro del campo informático, donde se identifique a una estructura de datos y el tipo de organización en su implementación INVESTIGA..!!! 1.5 Niveles de abstracción de datos
1.- Nivel (Lógico o abstracto)
Corresponde a la especificación lógica del TDA. En este nivel se define abstractamente a la Estructura de Datos y las operaciones relacionadas con ella, independientemente del lenguaje de programación en el que se implemente o utilice la Estructura.
2.- Nivel (Físico o de Implementación)
Se decide el lenguaje de Programación en el que se va a implementar la estructura de datos. Así como los tipos de datos ya definidos en el lenguaje de programación servirán para representar a la estructura. y luego se implementa cada una de las operaciones diseñadas en el TDA
3. – Nivel de Aplicación o de Uso:
El programador usará el TDA para resolver determinadas aplicaciones, el uso del TDA se limita a llamar a las operaciones sobre la estructura que se requiera cuidando siempre de cumplir las reglas de cada operación especificadas en el nivel lógico.
Analiza:
Identifica los niveles de abstracción en el siguiente ejemplo de la vida real como lo es: “Construir un edificio”.
Piensa en otros casos más, comenta con tus compañeros y con tu profesora !!!
Analiza:
Identifica los niveles de abstracción en el siguiente ejemplo de la vida real como lo es: “Construir un edificio”.
Piensa en otros casos más, comenta con tus compañeros y con tu profesora !!!
Ventajas de utilizar la Técnica de Abstracción de Datos
Se tiene una implementación más clara, documentable y fácil de darle mantenimiento.
Debido a la independencia de datos, se puede crear paquetes como unidades de software reutilizable, con los que se obtienen Estructuras de Datos genéricas. Facilita y hace más rápido el desarrollo de aplicaciones.
Ejemplo de TDA:
En un sistema bancario las cuentas de cheques de los clientes pueden considerarse objetos. Todos ellos pertenecen a una cuenta llamada CUENTA _CHEQUES que definen para cada instancia los siguientes datos:
Numero de la cuenta. Nombre del cliente.
Sucursal donde se abrió la cuenta. Saldo de la cuenta.
Y las siguientes Operaciones Abrir cuenta
Deposito Retiro
Consultar saldo
A continuación elaboramos la especificación lógica que contienen los siguientes puntos:
TDA: CUENTA _CHEQUES. 1.- Elementos que conforman la estructura de datos
Número de cuenta cadena Nombre del cliente cadena Sucursal donde se abrió cadena Saldo de la cuenta real
2.- Tipo de organización.
El tipo de organización es lineal entre los números de cuentas
3.- Dominio
Existe entre 0 y 10000 cuentas, el dominio será todos aquello números que se ubiquen dentro del rango establecido.
4.- Descripción de las operaciones
- ABRIR_CUENTA:
Utilidad: Esta operación se ejecutará al crear un objeto de la clase CUENTA_CHEQUES, e implica solicitar por teclado los datos correspondientes para guardarlos en los atributos del objeto y colocar el valor de cero al saldo inicial.
Datos de entrada:Nombre del cliente, Nombre de la sucursal, (Saldo inicial de la cuenta será cero) Datos de salida: Número de cuenta
Precondiciones: Ninguna
Postcondiciones: Los datos ingresados serán guardados en los atributos correspondientes del objeto. - DEPOSITAR
Utilidad: Agrega la cantidad especificada al saldo de la cuenta. Datos de Entrada: Monto a depositar
Datos de Salida: Saldo disponible aumentado Precondiciones: Número de la cuenta exista
Que la cantidad a depositar sea mayor a cero Postcondiciones: Saldo de la cuenta agregado la cantidad especificada - RETIRAR
Utilidad: Quita al saldo de la cuenta la cantidad espeficada, validando que sea posible retirar esa cantidad. Datos de Entrada: Monto a retirar
Datos de Salida: saldo disponible disminuido Precondiciones: Que el número de cuenta exista
Que el saldo disponible sea mayor que la cantidad especificado para el retiro. Postcondiciones: saldo disponible disminuido en la cantidad especificada
- CONSULTAR_SALDO
Utilidad: Mostrar en pantalla el saldo de la cuenta correspondiente Datos de Entrada: Número de cuenta
Datos de Salida: Saldo disponible
Precondiciones: Exista el número de cuenta Postcondiciones: Ninguna
1.6 Representación de una estructura de datos
Puede entenderse como el punto de conexión entre la especificación lógica de una TDA y su implementación en un lenguaje de programación particular.
Dentro del proceso de abstracción de datos la representación de una estructura corresponde al inicio del segundo nivel de abstracción es decir el nivel físico. Constituye un esquema de cómo se almacenarán los elementos de la Estructura de Datos, en la memoria de tal forma que se logre su óptimo aprovechamiento.
Tipos de representaciones para una Estructura de Datos
Independientemente de las facilidades de implementación que ofrezcan los lenguajes de programación, una Estructura de Datos puede representarse de dos formas:
1. Representación de una estructura de datos por posiciones
El lugar físico donde se almacena un elemento determina automáticamente su posición relativa en la estructura de datos. Se podría considerar como un espacio de almacenamiento contíguo donde:
cada lugar sirve para almacenar un elemento. Un elemento esta en un lugar K, por lo tanto
Tipos
1. Por posiciones
2. Por ligas Almacenamiento disperso Almacenamiento contiguo Tendrá la k- ésima posición dentro de la estructura El elemento K+1 estará después de K por lo tanto se almacenará en el lugar k+1
del espacio de
1 Elemento 1
2 Elemento 2 Existe una relación lineal
… Elemento 1 pos 1
K Elemento k Elemento 2 pos 2
K+1 Elemento k+1 …. Elemento N pos N …
N Elemento N
Herramientas en los lenguajes de programación para desarrollar una representación por posiciones
Todos los lenguajes de programación proveen al programador de herramientas útiles para representar Estructuras de Datos en forma contigua, más conocidas como estructuras de datos implícitas del lenguaje.
1. Arreglos de elementos uniformes.- Solo almacenan un conjunto de elementos de un mismo tipo simple enteros, reales, cadenas o tipos compuestos registros con elementos de diferentes tipos
2. Registros de elementos de diversos tipos.- Permiten definir estructuras que contienen valores de diferentes tipos, almacenados como si fuera unidad.
3.- Archivos Secuenciales.- el almacenamiento es contiguo, son similares a los arreglos, permiten almacenar un conjunto de elementos aunque lo hace en la memoria secundaria.
Ventajas
- Fácil implementación.
- Rapidez de recorrido, debido a que la dirección de cada elemento está implícita en su posición física.
Desventajas
- Al realizar manipulaciones de los elementos
o Al agregar un nuevo elemento en algún lugar que no sea el último, se tiene que desplazar los elementos hacia abajo que están después de la posición de inserción deseada logrando que se genere un espacio para poder agregar un nuevo elemento.
o Al borrar un elemento que no sea el último deja un espacio no permitido entre los elementos, para lo cual se tiene que desplazar una posición hacia arriba los elementos, que están después del elemento borrado.
2. Representación de una estructura de datos por ligas
En este tipo de representación la ubicación física de un elemento no determina la posición relativa que tiene dentro de la Estructura de Datos.
El almacenamiento se realiza en forma dispersa: dos elementos contiguos en la Estructura de Datos no necesariamente deben estar almacenados físicamente en posiciones contiguas dentro del espacio de almacenamiento.
1 Elemento k Dir k+1
… Lista Uno:
Elemento k, el que sigue está en la
dirección Dir k+1, que es el
Elemento 1, el que sigue está en la
Dir 2 que es nula.
K Lista Dos.
K+1 Elemento 1 Dir 2 Elemento k+1, el que sigue tiene
dirección
… Nula Dir k+2
N Elemento k+1 Dir k+2
En necesario que cada elemento almacene la dirección física donde se ubica el elemento que le sigue en el Estructura de tal forma que puedan mantener una relación en donde está cada uno de los elementos.
Características
1.- La posición física del elemento no determina la posición relativa dentro de la Estructura de datos.
2.- El almacenamiento se realiza en forma dispersa.
3.- Es necesario que cada elemento almacena la dirección física del siguiente elemento.
4.- Cada elemento debe contener 2 o más campos (dato y dirección).
Ventajas
1.- La representación no es exclusiva debido a que mantiene una organización lineal
2.- Posibilidad de agregar y eliminar elementos de la estructura, sin tener que desplazar los elementos que ya estaban en ella.
3.- Permite un uso más eficiente del espacio de almacenamiento ya que puede crecer o decrecer en tiempo de ejecución, según requiera el usuario.
Desventajas
1.- Cada elemento deber “recordar” donde está alguno de los elementos, cada espacio es un elemento compuesto por (dato y la dirección del siguiente elemento).
2.- Las operaciones requieren mayor tiempo de procesamiento, debido a que el acceso no es directo, se requiere realizar un recorrido hasta encontrar el elemento deseado.
Herramientas en los Lenguajes de Programación para desarrollar una Representación por Ligas
En la mayoría no existen herramientas predefinidas, por lo tanto es el programador implementa las estructuras. Se recomienda el uso de apuntadores, un apuntador se define como un tipo capaz de almacenar una dirección de memoria, se considera como una referencia indirecta a un elemento.
2 ESTRUCTURAS DE DATOS BÁSICAS
2.1 Cadenas o StringsCadena: Es una secuencia finita de símbolos tomados como un conjunto de caracteres
(letras, números, caracteres especiales).
Strings: Internamente es un arreglo de caracteres, dependiendo del lenguaje de
Programación generalmente se considera el inicio de la cadena en la posición 0. La importancia del String radica en que la mayor parte de la información que se maneja actualmente en casi cualquier área del conocimiento puede verse como una secuencia de caracteres. Ejemplo: el nombre de una persona, el nombre del un libro, la información de un texto son vistas como cadenas de caracteres.
Conceptualización de un String como un TDA
Se puede diseñar muchos TDA, que definen una String considerando que operaciones se tomarán como básicas para el funcionamiento de dicha estructura y cuál será el conjunto de caracteres que aceptarán como parte de él.
TDA: String
Elementos: Conjunto de letras mayúsculas y minúsculas, caracteres especiales y dígitos. Estructura: Existe una relación lineal, debido a que se considera como una cadena de caracteres.
Dominio: Suponiendo que los Strings pueden almacenar entre 0 y 80 caracteres, su dominio será el conjunto de todas las cadenas que puedan formar con la combinación de elementos de esa longitud.
Operaciones: - INICIALIZAR
Utilidad: Nos sirve para definir el espacio a ocupar en la memoria por el string. Datos de entrada: Tamaño de memoria para el String
Datos de salida: El string S es nulo (esta vacio) Precondición: Ninguna
Postcondición: el String S es nulo. - INSERTAR_CARÁCTER_AL_FINAL
Utilidad: añadir un carácter al final
Datos de entrada: String S y la letra L que se insertará al final de S. Datos de salida: String S modificado
Precondición: El numero de letras en S es menor que 80.
Postcondición: el string S tiene una letra más en el extremo derecho - BORRAR_ CARÁCTER_AL_INICIO
- Utilidad: Permite borrar un carácter al inicio del String - Datos de entrada: String S al que se le borrara la primera letra - Datos de salida: String S modificado
- Precondición: el String S exista y no sea nulo
- Postcondicion: el String S tiene una letra menos en el extremo izquierdo - CONCATENAR
Utilidad: Unir dos Strings S1 y S2 Datos de entrada: Strings S1 y S2. Datos de salida: String S1 modificado.
Precondición: La suma de la longitud de S1 y S2 debe ser menor que 80.
Postcondición: A string S1 se le agrega todos los caracteres de s2(en el extremo derecho); s2 no se modifica.
- BUSCAR_SUBSTRING
Utilidad: Buscar un Substring S2 en S1 Datos de entrada: Strings S1 y S2.
Datos de salida: verdadero si S2 está contenida en S1, falso en caso contrario Precondición: S1 y S2 existan
- OBTENER_ CARACTER
Utilidad: Sirve para encontrar un carácter dentro del String
Datos de entrada: String S donde se desea conocer cierto carácter y la posición i del carácter que se desea conocer.
Datos de salida: Carácter que se encuentra en la posición i del String S
Precondición: El String S no sea nulo e i debe ser un valor entre 1 y la longitud de S Postcondición: Ninguna
- VERIFICA_VACIO
Utilidad: Sirve para verificar si una cadena o String está vacía o no Datos de entrada: String S que será verificado
Datos de salida: Verdadero si el String S no tiene caracteres y Falso en caso contrario. Precondición: Ninguna.
Postcondición: Ninguna. - VERIFICAR_LLENA
Utilidad: Sirve para verificar si una cadena está llena o no Datos de entrada: String S que será verificado
Datos de salida: Verdadero si la cadena o String S contiene 80 caracteres y Falso en caso contrario Precondición: Ninguna
Postcondición: Ninguna - INVIERTE
Utilidad: Sirve para invertir el orden de los caracteres de un String. Datos de entrada: String S1 a invertir
Datos de salida: String S2
Precondición: la secuencia de la cadena S se invierte, de forma que el primer carácter toma el lugar del último, el segundo del penúltimo y así sucesivamente.
Representación del TDA String.
Se puede almacenar en la memoria mediante almacenamiento contiguo y también podrá utilizarse el almacenamiento no contiguo.
1. Uso de un Carácter Centinela
Los caracteres se almacenan en un arreglo con longitud predefinida.
Se delimitan por un carácter especial, denominado “Centinela”-equivale a un carácter nulo en la mayoría de los lenguajes de programación ‘\0’.
MARTES\00 1 2 3 4 5………...n Desventaja.
El carácter centinela ocupará un espacio dentro del String. No se conoce la longitud del String por lo que se debería programar un método que permita realizar dicha operación.
Los lenguajes de programación que utilizan este tipo de almacenamiento son: C Y C++.
2. Almacenamiento de la longitud del String
Los elementos del String se almacenan en un arreglo de longitud predefinida.
La Longitud actual del String se almacenan en la posición 0 y no forma parte del String. max
ASCII6MARTES.... 0 1 2 3 4 5 6 N
Desventaja.
Debido a que la longitud ocupa una posición de un carácter la longitud se restringe a 265.
El lenguaje de programación que utiliza este tipo de almacenamiento es el Pascal. A L M A C C O E N N T A I M G I U E O N T O
EJERCICIOS PROPUESTOS
1. Cree un método que permita generar y presentar la letras del alfabeto mayúsculas separadas por un guión
2. Cree un método que permita contar el número de letras A que existen dentro de una cadena.
3. Cree un método que permita contar el número de letras mayúsculas que existen dentro de una cadena.
4. Cree un método que permita contar el número de palabras que existe dentro de una frase.
5. Cree un método que permita cambiar de mayúsculas a minúsculas y viceversa 1. Lista encadenada de nodos con un caracter
Genera una lista encadenada donde cada nodo almacena un solo carácter y la dirección del siguiente nodo de la lista.
Ventaja.
Puede generar Strings de longitud infinita. Desventaja.
Desperdicio del 80% en la memoria debido al almacenamiento en tantas direcciones de nodos.
2. Lista encadenada de nodos con N caracteres
Genera una lista encadenada donde cada uno de los nodos almacena N caracteres, del String (N>1) y la dirección donde se encuentra el siguiente nodo.
Ventajas.
Genera Strings de longitud infinita y se disminuye el desperdicio de memoria.
Desventajas.
La implementación de sus operaciones es más compleja, ya que la información contenida en el String está almacenada en forma de substrings. A N L O M A C C O E N N T A I M G I U E O N T O M A R T E S
2.2 Arreglos Unidimensionales (Arrays)
¿Qué es un arreglo Unidimensional?
Es un tipo de dato estructurado, está formado por una colección finita y ordenada de datos del mismo tipo.
Además de conoce como una estructura natural, que es utilizada para modelar lista de elementos iguales, donde el tipo de acceso es “DIRECTO” debido al uso de un índice que indica la posición relativa del elemento dentro de la Estructura de Datos y además porque para acceder a cada elemento se lo hace directamente sin tener que consultar elementos anteriores o posteriores.
Representación en memoria.
TDA: ARREGLO.
Elementos: Números enteros.
Estructura: Lineal entre los elementos del arreglo.
Dominio: Los datos o elementos posibles a guardar estarán en el rango de 0-20 números. Operaciones:
- OBTENER
Utilidad: Regresa el elemento del arreglo A, que tiene un rango r. Datos Entrada: índice i
Datos Salida: elemento e
Precondiciones: elemento e, este guardado dentro del arreglo A. índice i sea < rango.
Postcondiciones: se produce una condición de error si el índice i<0 o si i > N-1, donde n es la cantidad actual de elementos.
- AGREGAR
Utilidad: Colocar un elemento e, en el arreglo A del rango r. Datos Entrada: el elemento nuevo e
Datos Salida: El arreglo A con un elemento mas Precondiciones: haya espacio en el arreglo
Analiza:
Se tienen las notas de un grupo de 90 estudiantes y necesitamos saber cuántos de estos estudiantes tienen tienen una nota superior al promedio del grupo. ¿Cómo podríamos resolver este problema?....
Piensa en varias soluciones, comenta con tus compañeros y con tu profesora…..!!!
Analiza:
Se tienen las notas de un grupo de 90 estudiantes y necesitamos saber cuántos de estos estudiantes tienen tienen una nota superior al promedio del grupo. ¿Cómo podríamos resolver este problema?....
Piensa en varias soluciones, comenta con tus compañeros y con tu profesora…..!!! 100 A[0] 101 A[1] 102 A[2] 103 A[3] 104 A[4] . . . .
Postcondiciones: El arreglo con un elemento agregado. - MODIFICAR
Utilidad: Sustituir el elemento e del arreglo A de rango r en el índice i. Datos Entrada: elemento ea, y el nuevo elemento ne
Datos Salida: mensaje
Precondiciones: El arreglo este creado y no este vacio
Post condiciones: Se produce un mensaje de error, si el elemento no se encuentra en el arreglo. - ELIMINAR
Utilidad: quitar el elemento e del arreglo A de rango r en el índice i. Datos Entrada: elemento e
Datos Salida: mensaje indicando que la operación ha tenido éxito.
Precondiciones: el arreglo no este vacio y que el elemento se encuentre en el arreglo
Postcondiciones: Se produce un mensaje de error, si el elemento no se encuentra en el arreglo.
Representación de Arreglos
Manejo de arreglos en Java.
Los arreglos son considerados como objetos cuyo tamaño se determina en tiempo de compilación y no puede ser modificado en tiempo de ejecución.
Pueden contener. Tipos de datos (int, char, boolean, float)
Objetos de clases (los del API, o los definidos por el usuario). Se hace uso del operador [ ].
Dispone de una función miembro para consultar la longitud de arreglo length. Declaración de un arreglo.
<tipo dato/clase> [ ] identificador;
<tipo_dato/clase> identificador [ ]; Ejemplos: String [ ] días_Semana; int [ ] edades_Estudiantes; double [ ] notas; char [ ] vocales;
boolean [ ] productos disponibles. Creación de los arreglos.
Reservar el espacio en memoria y se requiere de un constructor que es el operador (new).
edades_Estudiantes = new int[20]; notas = new double[10];
vocales = new char[5];
Se puede declarar y crear el arreglo:
• Declarar y crear un arreglo vacio. String [ ] días_Semana=new String [7];
• O también: declarar y crear un arreglo con valores iníciales. int [ ] edades_Estudiantes={15,20,23,18};
Errores.
1. Crear arreglos estáticos en tiempo de compilación. int [4]edades;
2. Asignar valor a un arreglo sin haber determinado su tamaño. int [ ] edades;
edades [0]=15;
Principales Operaciones
1. Lectura
Saber el contenido o el valor del arreglo de una determinada posición.
Ejemplo.
int [ ] edades={15,18,20,25};
Sintaxis: Nombre_Arreglo[subindice];
edades[3]; retorna el 25 ya que está en la posición 3. 2. Escritura y actualización
Sintaxis: Nombre_Arreglo[subíndice]=”valor”;
Edades [1]=28; Ejemplo de actualización de la posición 1. 3. Presentación de los elementos arreglos.
Se lo hace a través de un recorrido. for(int i<0;i<edades.length;i++){
System.out.println(edades [i]); }
Recuerda: Java utiliza los siguientes api: Vector, Collection, Array
que son clases y/o interfaces que permiten almacenar cualquier clase de objetos como elementos y que pueden ser usados independientemente como unidimensionales o multidimensionales.
EJERCICIOS PROPUESTOS
1. Crear un método que rellene un arreglo con los números enteros comprendidos entre 2 y 20.
2. Escriba un método que rellene un arreglo con los números pares comprendidos entre 1 y 40.
3. Escribir un método, que rellene un arreglo con diez números enteros consecutivos a partir de un número pasado como parámetro y haga una copia de ese arreglo en otro.
4. Escribir un método, que permita ingresar por teclado diez elementos en un arreglo, determine la posición del arreglo en la que se encuentra el máximo valor de los elementos ingresados.
2.3 Arreglos Bidimensionales (Matrices)
¿Qué es un arreglo bidimensional?
Un arreglo bidimensional es un conjunto de datos homogéneos finito y ordenado donde se hace referencia a cada elemento por medio de dos índices: renglón (fila) y columna. Arreglos bidimensionales más conocidos como matrices (mxn), donde m representa a las filas y n a las columnas. También conocidos como arreglos de arreglos, su manipulación es similar a los arreglos unidimensionales sin acceso directo la única variación es que se requiere tantos índices como dimensiones se tengan.
Para calcular el número de elementos que están en la Matriz se realiza la siguiente operación:
ne=n elementos1* n elementos2*… n elementos n. ne=m*n
ne=3*2 ne=6.
Representación de una matriz
MATRIZ COLUMNAS FILAS 0 1 2 .. N 0 P(0,0) P(0,1) P(0,2) …p(0,N-1) 1 P(1,0) P(1,1) P(1,2) …p(1,N-1) 2 P(2,0) P(2,1) P(2,2) …p(2,N-1) Analiza:
Se requiere representar el número de accidentes mensual por región del Ecuador ¿Cómo podríamos resolver este problema?.... Piensa en varias soluciones, comenta con tus compañeros y con tu profesora…..!!!
Analiza:
Se requiere representar el número de accidentes mensual por región del Ecuador ¿Cómo podríamos resolver este problema?....
Piensa en varias soluciones, comenta con tus compañeros y con tu profesora…..!!!
…M P(M,0) P(M,1) P(M,2) …p(M-A,N-1)
Manejos de Arreglos Bidimensionales (Matrices)
Declaración:
<Tipo/Clase> [ ][ ]identificador; double [ ][ ]x;
Creación:
1. Un arreglo bidimensional vacio: double [ ][ ]x=new double[3][2]; 2. Con valores iniciales
double [ ][ ]x={{1.0,2.0},{6.0,5.0},{10.0,8.0}};
Operaciones Básicas
1. Lectura: Obtener un elemento contenido en la matriz: double r = x [1][1]=5;
2. Modificación: Actualizar al elemento: x [2][0]=4.0;
3. Presentación: Utilizar un ciclo repetitivo que recorre las filas(i); y otro ciclo anidado que recorre a las columnas(j).
for(int i=0; i<n;i++){ for(int j=0;j<n;j++){
System.out.println(x[i][j]); }
EJERCICIOS PROPUESTOS
Implementar la clase Matriz
Matriz + n: entero //dimensión de la matriz - x[ ][ ]:doublé // array bidimensional //constructores
+ Matriz(n: entero) + Matriz(x [ ][ ]double) //métodos de la clase Matriz + suma(a: Matriz,b Matriz): Matriz + resta(a: Matriz,b Matriz): Matriz
+ multiplicacion(a: Matriz,b Matriz): Matriz + productoEscalar(double,a: Matriz): Matriz + transpuesta(a: Matriz): Matriz
+ sumaDiagonal(): double +sumElemSobDiagonal():double +sumElemBajoDiagonal():double +triBaseSup(Matriz a):double +triBaseInf(Matriz a):double +triBaseIzq(Matriz a):double +triBaseDer(Matriz a):double +triVerticeSup(Matriz a):double +triVerticeInf(Matriz a):double +triVerticeIzq(Matriz a):double +triVerticeDer(Matriz a):double +Rombo(Matriz a):double +Arbol(Matriz a):double +Reloj(Matriz a):double IMPLEMENTACION DE LA CLASE MATRIZ public class Matriz { /** Miembros dato */ public int n; //dimension private double[][] x; //Array bidimensional //Constructores public Matriz(int n) { this.n=n; x=new double[n][n]; for(int i=0; i<n; i++){ for(int j=0; j<n; j++){ x[i][j]=0.0; } } } public Matriz(double[][] x) { this.x=x; n=x.length; } //Para mostrar los datos redefinimos la funcion toString //de la Clase base Object de la cual deriva implicitamente Matriz public String toString(){ String texto="\n"; for(int i=0; i<n; i++){
for(int j=0; j<n; j++){ texto+="\t "+(double)Math.round(1000*x[i][j])/100; } texto+="\n"; } return texto; } 2.4 Conjuntos
Es una colección de elementos del mismo tipo cuyo orden y cantidad de repeticiones es observada.
Entre sus principales características tenemos: Es un contenedor de objetos distintos No hay elementos duplicados
En la implementación de la estructura conjunto el ordenamiento juega un papel muy importante
TDA CONJUNTOS
Elementos: Puede ser cualquier tipo de objetos (elementos diferentes). Estructura: Tiene una estructura lineal entre los objetos del conjunto.
Dominio: Son todos los datos posibles a guardar dentro del rango definido por el usuario en relación con el tipo de aplicación de la estructura.
OPERACIONES:
- UNION : A∪B={x ∈A o x ∈B}
Utilidad: Que se reemplaza en A con la unión A y B, esto es ejecutar A← A∪B . O se puede crear un nuevo conjunto C.
Datos de Entrada: Dos conjuntos { }A, { }B.
Datos de Salida: El conjunto {}A modificado o también puede ser un nuevo conjunto {}C. Precondiciones: Que el conjunto {}A, y {}B existan.
Postcondiciones: El conjunto {}A o el {}C contiene los elementos de la unión - INTERSECCION : A∩B={x ∈A y x∈B}
Utilidad: Se reemplazará en {}A con la intersección del conjunto A y B, esto es ejecutar A← A∩B . O se puede crear un nuevo conjunto C.
Datos de Entrada: Dos conjuntos { }A, { }B.
Datos de Salida: El conjunto {}A modificado o también puede ser un nuevo conjunto {}C. Precondiciones: Que el conjunto {}A, y {}B existan.
Postcondiciones: El conjunto {}A o el {}C contiene los elementos de la intersecsión. - DIFERENCIA: A−B={x ∈A y x∉B}
Utilidad: Reemplaza en A con la diferencia A y B, esto es ejecutar A← A−B . O se puede crear un nuevo conjunto C.
Datos de Entrada: Dos conjuntos { }A, { }B.
Datos de Salida: El conjunto {}A modificado o también puede ser un nuevo conjunto {}C. Precondiciones: Que el conjunto {}A, y {}B existan.
Postcondiciones: El conjunto {}A o el {}C contiene los elementos de la diferencia del conjunto {}A, y {}B.
En algunos lenguajes de programación éstas operaciones se realizan sobre el primer conjunto o sea el conjunto A ó se
Analiza:
¿Cómo sería el proceso que se aplican los motores de búsqueda de Información en Internet?
Piensa en varias soluciones, comenta con tus compañeros y con tu profesora…..!!!
Analiza:
¿Cómo sería el proceso que se aplican los motores de búsqueda de Información en Internet?
Piensa en varias soluciones, comenta con tus compañeros y con tu profesora…..!!!
definir a éstas operaciones sin alterar al conjunto A,
devolviendo en un nuevo conjunto que podría ser el conjunto C. Manipulación de conjuntos en Java
En el api de Java encontramos, el paquete Java.util que incluye la interfaz SET, que nos permite manipular conjuntos de elementos y tiene como características las siguientes:
• Un conjunto no puede contener elementos duplicados
• Incluye métodos parecidos a los definidos en el TDA mencionado anteriormente. A continuación se muestra:
Correspondencia entre TDA CONJUNTO y la Interfaz Java.util.Set
TDA CONJUNTO Interfaz Java.util.Set
Unión addAll (collection c):boolean
Intersección retainAll(collection c):boolean Diferencia removeAll(collection c):boolean
Ejemplo de representación de la operaciones básicas(inserción y eliminación); operaciones con subconjuntos y las operaciones entre conjuntos(Unión, Intersección
y Diferencia) de la Estructura Conjunto en Java MODELADO Conjunto +a: SortedSet //Constructor +Conjunto() +getA():SortedSet +setA(a:SortedSet):void //metodos de Conjunto +inserta(e:Object):void +elimina(e:Object):void +subconjuntosup(e:Object):SortedSet +subconjuntoinf(e:Object):SortedSet
+subconjuntoentre(Object ei, Object ef):SortedSet +union(SortedSet a, SortedSet b):SortedSet +interseccion(SortedSet a, SortedSet b):SortedSet +diferencia(SortedSet a, SortedSet b):SortedSet
IMPLEMENTACION DE CONJUNTO import java.util.*; public class Conjunto { public SortedSet a; public Conjunto() { a= new TreeSet(); } public SortedSet getA() { return a; } public void setA(SortedSet a) { this.a = a; }
public void inserta(Object e){ if(a.add(e)==false){ System.out.println("Elemento :"+ e +" repetido!!..No se pudo insertar"); } } public void elimina(Object e){ if(a.remove(e)){ System.out.println("Elemento : "+e+" : ha sido eliminado"); }else{ System.out.println("No existe el elemento a eliminar"); } } public SortedSet subconjuntosup(Object e){ SortedSet b=new TreeSet(); b=a.tailSet(e); return b; } public SortedSet subconjuntoinf(Object e){ SortedSet b=new TreeSet(); b=a.headSet(e); return b; } public SortedSet subconjuntoentre(Object ei, Object ef){ SortedSet b=new TreeSet(); b=a.subSet(ei, ef); return b; } public SortedSet union(SortedSet a, SortedSet b){ a.addAll(b); return a; } public SortedSet interseccion(SortedSet a, SortedSet b){ a.retainAll(b); return a; } public SortedSet diferencia(SortedSet a, SortedSet b){ a.removeAll(b); return a; } } 2.5 Archivos o ficheros
La estructura de datos tipo archivo (ficheros) es la única estructura de datos que se almacena en memoria secundaria o externa (disco o cinta). Un archivo de datos es una estructura constituida simplemente por colecciones de datos que se pueden guardar, para uso posterior mediante la ejecución de programas adecuados. Otra característica importante de los archivos es que permite almacenar gran cantidad de información. Esta colección de datos sirve para la entrada y salida a la computadora y se maneja con un programa en contraste con archivos y registros, el tamaño de esta colección no es fija y está limitada solo por la cantidad de memoria secundaria (disco o cinta) disponible. Es decir, los archivos son dinámicos, esto es que se pueden hacer archivos de datos más grandes o más pequeños según sean las necesidades.
Los archivos no están limitados por la memoria donde están contenidas las estructuras. Cada archivo se puede manipular por un identificador.
Un archivo está compuesto por un conjunto de registros que es una colección de los elementos de información sobre una entidad particular, los diferentes elementos se conocen como campo que pueden guardar información diferente, y estos pueden a su vez contener subcampos los que están compuestos de caracteres.
Métodos de acceso a un archivo
Un método de acceso, no es más que la forma como recuperar la información del archivo, a veces se pude procesar dato por dato, en otras veces se podría acceder rápidamente a un dato sin recuperar los datos anteriores.
Existen dos métodos para acceder a un archivo de datos: acceso secuencial y acceso aleatorio.
• Acceso Secuencial
Exige el tratamiento elemento a elemento es necesario una exploración secuencial comenzando desde el primer elemento hasta llegar al elemento buscado.
• Acceso Aleatorio o Directo
Permite procesar o acceder a determinado elemento mediante una dirección en el soporte de almacenamiento.
Representación Grafica
Representación de la Estructura Archivo
1. SECUENCIAL: Entre sus principales características tenemos más sencillos de implementar, no es eficiente cuando la cantidad de datos a almacenar es grande, deben actualizarse en forma periódica para reflejar los cambios dados en la información almacenada. Ejemplo: archivo que almacena los datos de los clientes de un banco, al obtener dinero de un cajero automático.
a b c puntero elementos Acceso a un archivo secuencial Acceso directo Índice (posición)
Acceso a un archivo directo
Δ
R1 R2 R3 R
….
Rn
2. INDEXADOS: Entre sus principales características tenemos: que este tipo de archivos requiere que se conozca la dirección donde se encuentra el dato a buscar, se compone de un archivo de datos(secuencial) y un archivo de índices(guarda las llaves o clave del archivo secuencial, o sea la dirección del dato correspondiente en disco).
Tipos de archivos
Texto: Solo permiten acceso
secuencial y su unidad constitutiva es el carácter.
Acceso directo: Se puede acceder
secuencial o aleatoriamente y está compuesto por bytes.
Con tipo o Serializables: Se puede acceder secuencialmente, y solo trabaja con objetos. Implementación de un archivo tipo texto.
MODELADO: ArchivoTexto + f : File +bw : BufferedWriter +br: BufferedReader //Constructor ArchivoTexto(dir:String) ArchivoTexto(dir:String, nom:String) //Métodos del Archivo
+escribir(dato:String):void +leer():void
+info():void +lista():void +listaFiltro():void
Filtro implements FilenameFilter +extension:String
//Constructor
+Filtro(extension:String) //Redefinición método accept Archivo de Índices Llave Dirección 10008 001 10209 003 10321 006 Número de cuenta(llave)
Archivo de datos (Secuencial) 001 10008 María del Cisne
Calderón …. 002 003 10209 María Gabriela Gonzaga … 004 005
006 10321 María José Salinas … 007 008 … 300 301 … N
+accept(dir:File, name String ):boolean CLASE ARCHIVOTEXTO import java.io.*; public class ArchivoTexto { public File f=null; public BufferedWriter bw=null; public BufferedReader br=null; public ArchivoTexto(){ } public File getF() { return f; } public void setF(File f) { this.f = f; } public boolean verifica(String dir, String nom){ //Comprobar si hay un archivo con ese nombre en el directorio File fa=new File(dir); File[] lf=fa.listFiles(); boolean existe=false; for(int i=0; i<lf.length; i++){ if(lf[i].getName().equalsIgnoreCase(nom)){ fa=lf[i]; existe=true; setF(fa); break; } } return existe; } public void abrir(String da,String na){ this.f = new File(da,na); } public void escribir(String dato)throws IOException{ //*************ESCRIBIR EN EL ARCHIVO************************* //Recuerda que la filosofia de acceso a la lectura y escritura a los archivos, //siempre es la misma. Buffer, que envuelve a Reader, que a su vez envuelve //al archivo (o stream). //Para escribir utilizamos en el metodo .write() del buffer //int pos=(int)f.length(); if(f.exists()){ bw = new BufferedWriter(new FileWriter(getF(),true)); }else{ bw = new BufferedWriter(new FileWriter(getF())); } bw.write(dato+"\n"); bw.close(); } public void leer()throws IOException{ //*************LEER EL ARCHIVO********************************** //Manejar el buffer Reader es muy sencillo ya que simplemente deberemos de
//ejecutar lecturas por linea. System.out.println("El contenido del Archivo es:"); br = new BufferedReader(new FileReader(getF())); String texline=br.readLine(); while(texline!=null){ System.out.println(texline); texline = br.readLine(); } br.close(); } public void info(){ if( f.exists() ){ System.out.print( "El Archivo existente " ); System.out.println( "Nombre: "+f.getName() ); System.out.println( "Camino: "+f.getPath() ); System.out.println("Directorio padre:"+f.getParent()); System.out.print( (f.canRead() ? " se puede Leer" : "") ); System.out.println( (f.canWrite() ? " y se puede Escribir" : "") ); System.out.println( "La longitud del Archivo es: "+ f.length() +"Bytes" ); }else{ System.out.println( "El Archivo no existe." ); } } public void lista(){ System.out.println(" ******* lista de los archivos de este directorio *******"); File fa=new File("/home/usuario/Documentos"); String[] lf=fa.list(); for(int i=0; i<lf.length; i++){ System.out.println(lf[i]); } } public void listaFiltro(){ System.out.println("***** lista de los archivos de este directorio con filtro ***\n"); File fa=new File("/media/RESPALDO/"); String[] lf=fa.list(new Filtro(".odt")); for(int i=0; i<lf.length; i++){ System.out.println(lf[i]); } } } CLASE FILTRO import java.io.*; /** * * @author Ing. Mire */ public class Filtro implements FilenameFilter{ String extension; Filtro(String extension){ this.extension=extension; } public boolean accept(File dir, String name){ return name.endsWith(extension); } }
Ejemplo de manejo de un archivo tipo de acceso Aleatorio
MODELADO:
Log +Rf : RandomAccessFile //Constructor
+Log(nom: String, t: String) //Métodos Archivo Aleatorio +escribirfinal(dato:String):void
+escribirposicion(dato:String, pos: int).void +leer():void +cerrar():void +info():void import java.io.*; public class ArchivoAleatorio { public RandomAccessFile Rf; /** Creates a new instance of ArchivoAleatorio */ public ArchivoAleatorio(String nom, String t) throws IOException{ Rf = new RandomAccessFile(nom, t); } public void escribirfinal(String dato){ try{ // Nos vamos al final del fichero, Incorporamos la cadena al fichero Rf.seek( Rf.length()); Rf.writeBytes(dato); }catch (Exception e){ System.out.print("Ha ocurrido un error....El directorio no existe"); } } public void escribirposicion(String dato, int pos){ try{ Rf.seek(pos); Rf.writeBytes(dato); }catch (Exception e){ System.out.println("Fichero no existe."); } } public void leer(){ // Presentamos los datos del archivo, mediante el acceso secuencial try{ Rf.seek(0); String linea=Rf.readLine(); while(linea!=null){ System.out.println(linea); linea = Rf.readLine(); } }catch (Exception e){ System.out.println("Fichero no existe"); } } public void cerrar() throws IOException{
Rf.close(); } public void info()throws IOException{ System.out.println("El puntero esta en la posicion :"+Rf.getFilePointer()); System.out.println("El tamaño del archivo es: " + Rf.length()); System.out.println("El puntero esta en la posicion :"+Rf.getFilePointer()); } }
Ejemplo de manejo de un archivos Serializables MODELADO Clase Datos Datos #nombre:String #telefono: String #direccion:String
+Datos(String n, String t, String d); +getNombre():String
+getTelefono():String +getDireccion():String +to String(): String
Clase de Lectura ContadoInput -f:FileInputStream -fi:ObjectInputStream +abrir():void +cerrar():void +leer():Datos Clase de Escritura ContactoOutput -f:FileOutputStream -sf:ObjectOutputStream +abrir():void +cerrar():void +escribir(Datos d):void
IMPLEMENTACIÓN DE ARCHIVOS SERIALIZABLES CLASE DATOS public class Datos implements java.io.Serializable { protected String nombre; protected String telefono; protected String direccion; /** Creates a new instance of Datos */ public Datos(String n, String t, String d){ nombre = n; telefono = t; direccion = d; } public String getNombre() {
return( nombre ); } public String getTelefono() { return( telefono ); } public String getDireccion() { return( direccion ); } @Override public String toString(){ String texto="\n"; texto ="\t"+nombre+"\t"+telefono+"\t"+direccion + "\n"; return texto; } } CLASE ESCRITURA import java.io.*; public class Escritura { public FileOutputStream f; public ObjectOutputStream sf; /** Creates a new instance of Escritura */ public Escritura() { } //Abrir el fichero; public void abrir(File a) throws IOException{ f= new FileOutputStream(a,true); sf = new ObjectOutputStream(f); } //Escribir en el fichero public void escribir(Datos d) throws IOException { if (sf != null) sf.writeObject(d); } //Cerrar el fichero public void cerrar() throws IOException{ if (sf != null) sf.close(); } } CLASE LECTURA import java.io.*; public class Lectura {
/** Creates a new instance of Lectura */ private FileInputStream f;
private ObjectInputStream fi; public Lectura() {
}
public void abrir(File a) throws IOException { f = new FileInputStream(a);
fi = new ObjectInputStream(f); }
public Datos leer() throws IOException, ClassNotFoundException{ Datos da = null;
if (fi!= null){ try{
da = (Datos) fi.readObject(); }catch (EOFException eof){
System.out.print("Fin de archivo"); }
}
return da; }
public void cerrar() throws IOException{ if (fi != null){ fi.close(); } } } CLASE EJECUTORA import java.io.*; public class EjecutorArchivoSerializable { public static void main( String argv[] )throws IOException { File a=new File("/home/usuario/Documentos/agenda.odt"); Escritura bw = new Escritura(); Lectura br = new Lectura(); bw.abrir(a); bw.escribir(new Datos("Marco","2546788","Las Pitas")); bw.escribir(new Datos("Andres","2545609","Argelia")); bw.cerrar(); br.abrir(a); try{ while(br!=null){ System.out.print(br.leer()); } }catch (Exception e){ System.out.println("No hay mas objetos"); } br.cerrar(); } } EJERCICIOS PROPUESTOS
1. Generar las letras del abecedario mayúsculas y minúsculas combinadas, guardar en un archivo de texto o aleatorio y presentarlas de la siguente manera:
AaBbCcDd EeFfGgHh IiJjKkLl MmNnOoPp QqRrSsTt UuVvWwXx YyZz
2. Generar la tabla de sumar del 1 al 12 y guardar en un archivo de texto o aleatorio.
1+2=3 1+3=4 1+4=5 1+5=6 1+6=7 1+7=8 1+8=9 1+9=10 1+10=11 1+11=12 1+12=13 TABLA DEL2 2+1=3 2+2=4 2+3=5 2+4=6 2+5=7 2+6=8 2+7=9 2+8=10 2+9=11 2+10=12 2+11=13 2+12=14 … y asi sucesivamente...
3. Generar los números del fatorial hasta el 12 y guardar en un archivo de texto o aleatorio. 1! =1*=1 2! =1*2*=2 3! =1*2*3*=6 4! =1*2*3*4*=24 5! =1*2*3*4*5*=120 6! =1*2*3*4*5*6*=720 y asi sucesivamente...
3 ESTRUCTURA LISTA
3.1 Descripción Lógica de la Estructura Lista
Una lista, es una colección de elementos homogéneos, entre los elementos existe una relación lineal, en donde cada elemento indica la dirección donde se encuentra el siguiente elemento de la lista.
Representación:
Una lista se puede representar de dos formas:
Estática: su tamaño se limita en tiempo de compilación Ej.: arreglos
Dinámica: su tamaño puede crecer indefinidamente en tiempo de ejecución Ej.:
listas enlazadas simples, listas enlazadas dobles, listas circulares, pilas y colas.
Características
En cada elemento o nodo de la lista a excepción del primero, tiene un único predecesor se debe indicar donde se encuentra el siguiente elemento.
Cada elemento de la lista, a excepción del último tiene un único sucesor. Las listas son flexibles y permiten cambios en la implementación.
Partes de un nodo Campo dato o info Campo de enlace
Campo dato o info: contiene uno o varios datos y/o objetos Campo de enlace: es la referencia hacia el otro nodo de la lista. Representación de la estructura en memoria:
Por lo general un nodo de una lista se abstrae en una clase. Ejemplo:
Class Nodo{ int dato;
Nodo siguiente;
public Nodo (Nodo sig){ Siguiente = sig; }
// métodos de la clase } // fin de la clase Nodo
3.2 Operaciones
En una lista se pueden efectuar las siguientes operaciones:
Insertar: Agregar un nuevo nodo a la lista
Eliminar: Quitar un nodo de la lista
Buscar: Permite encontrar un nodo dentro de la lista
Modificar: Actualiza la información de un determinado nodo dentro de la lista
3.3 Tipos de listas
3.3.1 Listas Simplemente Enlazadas
Es una colección de elementos homogéneos cuya relación lineal es determinada por la posición del elemento en la lista.
Una lista simplemente enlazada se caracteriza por lo siguiente:
En cada nodo existe un solo enlace o referencia hacia el siguiente nodo. Solo el último nodo de la lista contendrá una referencia nula o apuntara a null. Esta dada en un solo sentido.
Java inicializa los campos de referencias de un objeto a null durante la construcción del objeto, no es necesario asignar explícitamente null a un campo de enlace.
Pero sin embargo no olvide estas asignaciones de null en su código fuente, su ausencia reduce la claridad del código.
TDA:LISTA ENLAZADA SIMPLE
Elementos: los elementos de una lista simplemente enlazada, son conocidos como nodos, que almacenan datos simples o estructurados.
Estructura: Lineal entre los nodos que forman la lista enlazada simple, cada nodo tiene un único sucesor y predecesor
Dominio: si la lista no está vacía el rango serán los elementos que tendrán las posiciones 0,1,2,3…N donde N es la cantidad de elementos de la lista.
OPERACIONES:
- INSERTAR-INICIO
Utilidad: añadir un elemento al inicio de la lista L Analiza:
Piensa en varias aplicaciones informáticas de la vida real, en donde se utilice la estructura: Lista Simplemente Enlazada, comenta con tus compañeros y con tu profesora…..!!!
Analiza:
Piensa en varias aplicaciones informáticas de la vida real, en donde se utilice la estructura: Lista Simplemente Enlazada, comenta con tus compañeros y con tu profesora…..!!!
Datos de entrada: la lista L y el nuevo elemento.
Datos de salida: la lista L con el nuevo elemento al inicio. Precondición: Ninguna
Postcondicion: La lista L contiene un elemento nuevo al inicio. - INSERTAR-FIN
Utilidad: añadir un elemento al final de la lista L Datos de entrada: la lista L y el nuevo elemento. Datos de salida: la lista L con el nuevo elemento al final. Precondición: Ninguna
Postcondicion: La lista L contiene un elemento nuevo al final. - INSERTAR-ENTRE-NODOS
Utilidad: añadir un nuevo nodo en un orden especifico dentro de la lista L Datos de entrada: la lista L ,el nuevo elemento y el nodo predecesor
Datos de salida: la lista L con el nuevo elemento insertado en el lugar que le corresponde. Precondición: La lista contenga nodos
Postcondición: La lista L contiene al elemento nuevo en el orden que le corresponde. - ELIMINAR-INICIO
Utilidad: quitar un elemento del inicio de la lista L Datos de entrada: la lista L.
Datos de salida: la lista L con un nodo menos y el valor del nodo eliminado Precondición: la lista L no este vacía
Postcondicion: La lista con un nodo menos (el del inicio) - ELIMINAR-FIN
Utilidad: quitar un elemento del final de la lista L Datos de entrada: la lista L.
Datos de salida: la lista L con un nodo menos y el valor del nodo eliminado Precondición: la lista L no este vacía
Postcondicion: La lista con un nodo menos (el del final) - ELIMINAR- ENTRE-NODOS
Utilidad: quitar un nodo de un orden específico de la lista Datos de entrada: la lista L, y el elemento a eliminar Datos de salida: la lista L con un elemento menos
Precondición: la lista L no esté vacía y que contenga el nodo a eliminar
Postcondición: La lista L contiene un elemento menos y corresponde al que se elimino - BUSCAR-NODO
Utilidad: recorrer la lista L, hasta encontrar un determinado nodo dentro de la lista L Datos de entrada: la lista L ,el elemento a buscar
Datos de salida: verdadero si se ha encontrado el nodo caso contrario falso Precondición: la lista no esté vacía
Postcondición: Ninguna - MODIFICAR-NODO
Utilidad: modificar un elemento de la lista L
Datos de entrada: la lista L ,el elemento a modificar y el nuevo valor para modificar el elemento de la lista L. Datos de salida: Ninguna
Precondición: la lista no esté vacía
Postcondición: La lista L con un elemento modificado.
Nivel físico: Implementación de operaciones de Listas Enlazadas Simples CASOS PARA LA INSERCIÓN DE NODOS:
2.- Cuando el nodo se debe insertar antes del primer nodo 3.- Cuando el nodo se debe insertar después del último nodo 4.- Cuando el nodo se debe insertar entre nodos
PASOS PARA LA SOLUCIÓN
Caso 1: Cuando la lista enlazada simple no existe 1.- Leer (valor)
2.- Se crea un nodo y se asigna su referencia a top 3.- Inicializar su campo de no enlace
Caso 2: Cuando el nodo se debe insertar antes de primero 1.- Leer (valor)
2.- Crear un nuevo nodo temporal
3.- Inicilizar el campo de no enlace del nodo temporal
4.-Asignar la referencia de inicio de la lista (top),al campo de enlace del nodo temporal 5.-Asignar la referencia del nodo temporal al inicio de la lista
Caso 3: Cuando el nodo a insertarse después del último nodo 1.- Leer (valor)
2.-Crear un nodo temporal
3.- Inicializar el campo de no enlace del nodo temporal 4.- Declarar una variable de referencia aux (auxiliar) 5.- Recorrer la lista hasta el final
6.-Asignar la referencia del nodo temporal al campo de enlace del último nodo de la lista
Caso 4 : cuando el nodo debe insertarse entre nodos 1.- Leer(valor)
2.- Leer (valor) nodo predecesor 3.-Crear un nodo temporal
4.- Inicializar el campo de no enlace del nodo temporal 5.- Declarar una variable de referencia aux(auxiliar) 6.- Recorrer la lista hasta encontrar el nodo predecesor
7.-Asignar al campo de enlace del nodo temporal la referencia del nodo sucesor 8.- Asignar la referencia del nodo temporal al campo de enlace del nodo predecesor
CASOS PARA LA ELIMINACIÓN DE NODOS:
1.- Borrar el primer nodo
2.- Borrar cualquier nodo que no sea el primero
PASOS PARA LA SOLUCIÓN Caso1: borrar el primer nodo
1.- Asignar el enlace del campo siguiente del nodo referenciado por top a top.
Caso 2 : borrar cualquier nodo que no sea el primero 1.- Leer(valor)
3.- Asignar al campo de enlace del nodo predecesor la referencia del nodo sucesor al que se desea eliminar. Si el nodo a eliminar es el último asignar null al campo de enlace del nodo predecesor.
BUSCAR UN NODO
1.- Leer (valor)
2.- Recorrer la lista hasta encontrar el valor
MODELADO:
ListaSimple - dato: Object // campo dato
- sig:ListaSimple // campo de enlace al siguiente nodo - top: ListaSimple // apuntador de cabecera de la lista simple + ListaSimple( )
+ getDato ( ) : Object +getSig ( ) : ListaSimple +setDato( dato: Object): void +setSig(sig.ListaSimple):void +esVacia( ):Boolean //Inserción de Nodos +insertaVacia(d:Object):void //Caso 1 +insertaInicio(d:Object):void //Caso 2 +insertaFinal(d:Object):void //Caso 3
+entreNodos(np: Object, d:Object):void // Caso 4 //Eliminación de Nodos
+eliminaInicio( ): void // Caso 1
+eliminaNodo( d:Object): void //Caso 2 y 3 //Búsqueda +buscarNodo( ):boolean //Modificar nodo +modificaNodo(d:Object, nd:Object):void //Varios +presenta( ):void +cuentaNodos( ):int +cuentaRepetidos(d:Object):int IMPLEMENTACIÓN EN JAVA public class ListaSimple { private Object dato; private ListaSimple sig; private ListaSimple top; public ListaSimple() { setDato(null); setSig(null); } public Object getDato() { return dato; } public void setDato(Object dato) { this.dato = dato; } public ListaSimple getSig() { return sig; }
public void setSig(ListaSimple sig) { this.sig = sig; } public boolean esVacia() { if (top == null) { return true; } else { return false; } } //Insercion de Nodos public void insertaVacia(Object d) { if (esVacia()) { top = new ListaSimple(); top.setDato(d); System.out.println("El nodo insertado es el primero"); } else { System.out.println("No se ejecuto la operacion, la lista ya contine elementos."); } } public void insertarInicio(Object d) { if (!esVacia()) { ListaSimple temp = new ListaSimple(); temp.setDato(d); temp.setSig(top); top = temp; } else { System.out.println("No puede insertarse al inicio... La lista no contienen nodos"); insertaVacia(d); } } public void insertaFinal(Object d) { if (!esVacia()) { ListaSimple temp = new ListaSimple(); temp.setDato(d); ListaSimple aux; aux = top; while (aux.getSig() != null) { aux = aux.getSig(); } aux.setSig(temp); } else { System.out.println("No se puede insertar al final...La lista esta vacia"); } } public void entreNodos(Object np, Object d) { if (!esVacia()) { ListaSimple aux; aux = top; while ((aux.getDato().equals(np) == false) && (aux.getSig() != null)) { aux = aux.getSig(); } if (aux.getDato().equals(np)) { ListaSimple temp = new ListaSimple(); temp.setDato(d); temp.setSig(aux.getSig());
aux.setSig(temp); } else { System.out.println("No se puede insertar...Nodo predecesor no existe"); } } else { System.out.println("No se puede insertar...La lista esta vacia"); } } EJERCICIOS PROPUESTOS
Implementar los métodos correspondientes a la Lista Simple: eliminación de nodos, búsqueda, modificación y varios.
En java también existe un Api propio para trabajar con listas simples, con la clase ArrayList … INVESTIGA..!!!
3.3.2 Lista Circulares
Una lista circular es aquella en donde la referencia siguiente del último nodo en vez de ser null apunta al primer nodo de la lista. El concepto se aplica tanto a listas de enlace simple como doblemente enlazadas. Se obtiene al considerar el primer nodo de la lista es el sucesor del último nodo.
Se utilizan con frecuencia en procesamiento repetitivo de nodos en un orden específico.
Características
No podemos hablar de primer y último nodo,
Para su implementación es necesario utilizar un apuntador general a la lista No existen direcciones nulas, excepto cuando la lista está vacía
Si la lista contiene un solo nodo, el campo de enlace entonces apuntara a si mismo
Es posible llegar a cualquier nodo a partir de cualquier posición donde se encuentre apuntando a la variable de referencia llamada lista
Representación
Analiza:
Piensa en varias aplicaciones informáticas de la vida real, en donde se utilice la estructura: Lista Circular, comenta con tus compañeros y con tu profesora…..!!!
aba| Analiza:
Piensa en varias aplicaciones informáticas de la vida real, en donde se utilice la estructura: Lista Circular, comenta con tus compañeros y con tu profesora…..!!!
