La Estrucutura de datos profundiza en la forma de organizar un conjunto de datos elementales con el objetivo de facilitar su manipulacion. El temario del curso es el siguiente:
1. Definiciones Basicas.
2. Estructuras líneas.
3. Estructuras recursivas.
4. Estructuras Relacionales.
5. Ordenamiento y busqueda.
Los textos de consulta se exponen a continuacion.
-> Estructuras de Datos & Algoritmos - Addison, Nesley
-> Diseño y Manejo de Estructuras - Villalobos McgrawHill
-> Estructuras de Datos - Cairo, Oswaldo
-> Estructuras de Datos - Becerra
Introduccion Estructuras de Datos
Conceptos Basicos
* Estructura*
Es la manera como se pueden organizar los datos para que puedan ser interpretados de forma lógica y ordenada.
*Dato*
Es la unidad mínima de información, por si misma no tiene significado pero al organizar de forma lógica una cantidad establecida, se logra obtener un significado coherente.
*Algoritmo*
Es un conjunto de pasos finitos ordenados con el cual obtenemos la resolución de un problema especifico.
*Programa*
Es un conjunto de instrucciones que puede interpretar un computador con el fin de realizar un proceso especifico.
*Recursividad*
Propiedad de algunos lenguajes de programación de permitir que un programa solicite su propia ejecución en el curso de su desarrollo.
*Iteratividad*
Las estructuras iterativas son aquellas que nos permiten repetir varias veces un proceso.
*Abstracción*
Consiste en aislar un elemento de su contexto o del resto de los elementos que lo acompañan.
*Clase*
Es una plantilla o un prototipo para crear objetos, por eso se dice que los objetos son instancias de clases.
*Objeto*
Se define como la unidad que en tiempo de ejecución realiza las tareas de un programa.
EFICIENCIA
Tiempos de ejecucion:
Entradas: n1,n2...n logn)
Complejidadx=1 -> 1Cont = cont + 1 -> n+1 ------> 2n + 3 Ta(n)=?; O(n)=?.If x -> n+1
Si Ta1(n) es O(f1(n)) -> Para todo c1n1 > 0 Para cualquier n > = n1 Ta1(n) <= c1*f1(n) n es 0 (f2(n)) => Para todo c1n1 > 0
Uso de memoria, datos simples y compuestos.
Mantenimiento a los programas. (reingenieria)Rapidez para hacer cambios, pra leer datos, modificacion. (reingenieria)
Consiste en tres varillas verticales y un número indeterminado de discos que determinarán la complejidad de la solución. No hay dos discos iguales, están colocados de mayor a menor en la primera varilla ascendentemente, y no se puede colocar ningún disco mayor sobre uno menor a él en ningún momento.
El juego consiste en pasar todos los discos a la tercera varilla colocados de mayor a menor ascendentemente.
Las reglas son:
Sólo se puede mover un disco cada vez.
Un disco de mayor tamaño no puede descansar sobre uno más pequeño que él mismo.
Sólo puedes desplazar el disco que se encuentre arriba en cada varilla.
Existen otras versiones del problema con un número diferente de varillas. Aunque se conocen algoritmos eficientes que resuelven el problema con 3 varillas de manera óptima, no se han encontrado aún sus contrapartidas para cualquier número (N igual o superior a 3) de ellas.
Otra manera de resolverlo es basándose en el disco más pequeño, en este caso el de hasta arriba. El movimiento inicial de este es hacia la varilla auxiliar. El disco número dos por regla, se debe mover a la varilla número tres. Luego el disco uno se mueve a la varilla tres para que quede sobre el disco dos. A continuación se mueve el disco que sigue de la varilla uno, en este caso el disco número tres, y se coloca en la varilla dos. Finalmente el disco número uno regresa de la varilla tres a la uno (sin pasar por la dos) y así sucesivamente. Es decir, el truco está en el disco más pequeño.
Este problema se suele plantear a menudo en ámbitos de programación, especialmente para explicar la recursividad.
Si origen == {0}: mover el disco 1 de pila origen a la pila destino (insertarlo arriba de la pila destino); terminar.
Si no: hanoi({0...n-1},destino, auxiliar) //mover todas las fichas menos la más grande (n) a la varilla auxiliar
mover disco n a destino //mover la ficha grande hasta la varilla final
hanoi (auxiliar, origen, destino) //mover todas las fichas restantes, {0...n-1}, encima de la ficha grande (n)
terminar
Otra manera de resolver el problema, sin utilizar la recursividad, se basa en el hecho de que para obtener la solución más corta, es necesario mover el disco más pequeño en todos los pasos impares, mientras que en los pasos pares sólo existe un movimiento posible que no lo incluye. El problema se reduce a decidir en cada paso impar a cuál de las dos pilas posibles se desplazará el disco pequeño:
El algoritmo en cuestión depende del número de discos del problema.
Si inicialmente se tiene un número impar de discos, el primer movimiento debe ser colocar el disco más pequeño en la pila destino, y en cada paso impar se le mueve a la siguiente pila a su izquierda (o a la pila destino, si está en la pila origen).
La secuencia será DESTINO, AUXILIAR, ORIGEN, DESTINO, AUXILIAR, ORIGEN, etc.
Si se tiene inicialmente un número par de discos, el primer movimiento debe ser colocar el disco más pequeño en la pila auxiliar, y en cada paso impar se le mueve a la siguiente pila a su derecha (o a la pila origen, si está en la pila destino).
La secuencia será AUXILIAR, DESTINO, ORIGEN, AUXILIAR, DESTINO, ORIGEN, etc.
Estructuras Lineales
Listas
Dato puntero ->Dato Puntero -> Dato Puntero a Null
------------------ ------------------- ---------------------------
Arreglos:
Estructura estatica, tieen un tamaño definido.
Elementos Enlazados:
Estructura dinamica, tamaño indefinido.
Operaciones :
- Insertar, Borrar, Buscar, Recorrer, Vacio, Tamaño.
public class Estructuras_Lineales
public class Principal {
public static void main (String argv[]) {
Aqui vemos el Algoritmo respectivo:
import java.util.*;
LISTAS SIMPLES Y DOBLES
Un tipo de lista enlazada más sofisticado es la lista doblemente enlazada o lista enlazadas de dos vías. Cada nodo tiene dos enlaces: uno apunta al nodo anterior, o apunta al valor NULL o a la lista vacía si es el primer nodo; y otro que apunta al siguiente nodo siguiente, o apunta al valor NULL o a la lista vacía si es el último nodo.
Aplicaciones de las listas enlazadas :
Las listas enlazadas son usadas como módulos para otras muchas estructuras de datos, tales como pilas, colas y sus variaciones.
El campo de datos de un nodo puede ser otra lista enlazada. Mediante este mecanismo, podemos construir muchas estructuras de datos enlazadas con listas; esta practica tiene su origen en el lenguaje de programación Lisp, donde las listas enlazadas son una estructura de datos primaria (aunque no la única), y ahora es una característica común en el estilo de programación funcional.
A veces, las listas enlazadas son usadas para implementar arrays asociativos, y estas en el contexto de las llamadas listas asociativas. Hay pocas ventajas en este uso de las listas enlazadas; hay mejores formas de implementar éstas estructuras, por ejemplo con árboles binarios de búsqueda equilibrados. Sin embargo, a veces una lista enlazada es dinámicamente creada fuera de un subconjunto propio de nodos semejante a un árbol, y son usadas más eficientemente para recorrer ésta serie de datos
OPERACIONES CON LISTAS SIMPLES:
1. Insertar
2. Borrar
3. Buscar
4. Recorrer
5. Vacio
6.Tamaño
OPERACIONES CON LISTAS DOBLES:
1. Buscar
2. Insertar
3. Eliminar
4. Recorrer
5. Vacio
// EN LISTAS SIMPLES:
- get_first: Obtiene el primero y regresa los datos a el nodo cabecera.
- get_last: Obtiene el ultimo y regresa los datos al nodo cola.
- IS_empty: (Vacio) Regresa informacion sobre la lista esta vacia o no?
- java.util
El siguiente código inserta un elemento a continuación de otro en una lista simple. El diagrama muestra como funciona:
De forma similar, también tenemos funciones para borrar un nodo dado ó para borrar un nodo del principio de la lista:
SIMPLES:
Insertar
ANTES / DESPUES
Pseudocodigo:
p __cab
mensaje (antes/ despues);
Si antes entonces
Mientras que p < > null Haga
Si p (dato) = " x " entonces
new (q)
leer
(q (dato)
Aant[ ]
Bdes----
EN JAVA:
Nodo inicio
public Lista ( ) {
inicio = null;
}
public boolean vacia ( ) {
return ( inicio = null );
}
public int tamaño ( ){
int n = o
Nodotemporal = inicio
While ( temporal ! = null ) {
n ++
temporal = temporal.enlace
}
return n;
}
public boolean Buscar ( string elemento ){
Nodotemporal = inicio;
while ( temporal ! = null
if elemento.equals ( temporal.dato))
return true;
else
temporal = temporal.enlace
}
return false;
}
LISTAS ENLAZADAS
-isEmpty: Determina su la lista esta vacia.
-Size: Determina el numero de elementos en la lista.
DECLARAR UN NODO
Declare ClassNodo
Declare String Name
Declare NodoNext
end declare
Declare Nodo top = null
top = new nodo
top.name= " a"
top.next = null
* Informacion
- Entero
- Real
- String
EN LISTAS DOBLES:
Insertar un nodo en la ultima posicion:
temp = new nodo
temp.name = " c "
temp.next = null
while temp2. next is not null
temp2 = temp2.next
end while
temp2. next = temp
SERIE DE FIBONACCI
Gráfica de la sucesión de Fibonacci hasta f10
En matemáticas, la sucesión de Fibonacci es la siguiente sucesión infinita de números naturales:
El primer elemento es 0, el segundo es 1 y cada elemento restante es la suma de los dos anteriores. A cada elemento de esta sucesión se le llama número de Fibonacci. Esta sucesión fue descrita en Europa por Leonardo de Pisa, matemático italiano del siglo XIII también conocido como Fibonacci. Tiene numerosas aplicaciones en ciencias de la computación, matemáticas y teoria de juegos.
an = an-1 + an-2
1 1 2 3 5 8 13 21 34 55 89 144 233 377 ...
a1 + a2 + a3 + a4 + ..... + an-1 + an = an+2 - 1
Los números de Fibonacci quedan definidos por las ecuaciones:
ALGORITMO EN JAVA
import java.io.*;
public class Fibonacci
{
public static void main (String [] args)
{
double f1=1, f2=1;
int cantidad=0;
BufferedReader teclado = new BufferedReader(new InputStreamReader(System.in));
try
{
System.out.println("Digita cuantos numeros de las serie quieres ver: ");
cantidad=Integer.parseInt(teclado.readLine());
}
catch(IOException e)
{
System.exit(0);
}
catch(NumberFormatException e1)
{
System.out.println("No Digito Un Numero!");
System.exit(0);
};
System.out.println (f1);
for(int i=0; i
System.out.println(f2);
f2+=f1;
f1 = f2 - f1;
}
}
}
ESTRUCTURAS LINEALES: PROGRAMA PARA ESCOGER CUANTAS EDADES DESEAMOS INGRESAR Y BUSCAR LA DESEADA
2. PROGRAMA " CLASS DINERO"
import java.io.*;
public class Dineroc {
public static void main(String[] args) throws IOException{
int b200,b100,b50,b20,b10,m5,m2,m1,n,r;
String cad="";
InputStreamReader dsf;
BufferedReader buffer;
dsf=new InputStreamReader(System.in);
buffer=new BufferedReader(dsf);
System.out.print("INGRESE CANTIDAD DE DINERO:");
cad=buffer.readLine();
n=Integer.parseInt(cad);
b200=n/200;
r=n%200;
b100=r/100;
r=r%100;
b50=r/50;
r=r%50;
b20=r/20;
r=r%20;
b10=r/10;
r=r%10;
m5=r/5;
r=r%5;
m2=r/2;
r=r%2;
m1=r/1;
r=r%1;
System.out.println("Billete de 200 :"+b200);
System.out.println("Billete de 100:"+b100);
System.out.println("Billete de 50:"+b50);
System.out.println("Billete de 20 :"+b20);
System.out.println("Billete de 10:"+b10);
System.out.println("moneda de 5:"+m5);
System.out.println("moneda de 2:"+m2);
System.out.println("moneda de 1:"+m1);
}
PROGRAMA SOBRE LISTAS
class Empleados implements Serializable{
private String cedula;
private String nombres;
private String apellidos;
private String cargo;
private double basico=0;
private double comision=0;
private double auxilioT=0;
Empleados siguiente;
public Empleados(String vcedula,String vnombres, String vapellidos,String vcargo,double vbasico, double vcomision, double vauxilio ){
cedula=vcedula;
nombres=vnombres;
apellidos=vapellidos;
cargo=vcargo;
basico=vbasico;
comision=vcomision;
auxilioT=vauxilio;
}
public void setCedula(String valor){
cedula=valor;
}
public String getCedula(){
return cedula;
}
public void setNombres(String valor){
nombres=valor;
}
public void setApellidos(String valor){
apellidos=valor;
}
public void setCargo(String valor){
cargo=valor;
}
public void setBasico(double valor){
basico=valor;
}
public void setComision(double valor){
comision=valor;
}
public void setAuxilioT(double valor){
auxilioT=valor;
}
public String getNombres(){
return nombres;
}
public String getApellidos(){
return apellidos;
}
public String getCargo(){
return cargo;
}
public double getBasico(){
return basico;
}
public double getComision(){
return comision;
}
public double getAuxilioT(){
return auxilioT;
}
public double getSalario(){
return basico+comision+auxilioT;
}
public void mostrar(){
System.out.println(cedula);
System.out.println(nombres);
System.out.println(apellidos);
System.out.println(cargo);
System.out.println(basico);
System.out.println(comision);
System.out.println(auxilioT);
System.out.print("Total a Pagar");
System.out.println(getSalario());
}
}
class LstaEmpleados{
Empleados datos;
Empleados inicio;
public void agregar(Empleados dato){
if(datos==null){
datos=dato;
inicio=datos;
datos.siguiente=null;
}
else{
datos.siguiente=dato;
datos=datos.siguiente;
datos.siguiente=null;
}
}
public void mostrar(){
datos=inicio;
int i=1;
while(datos!=null){
System.out.print("Empleado #");
System.out.println(i);
datos.mostrar();
datos=datos.siguiente;
i++;
}
}
public void leer(){
String ced=javax.swing.JOptionPane.showInputDia...
String nom=javax.swing.JOptionPane.showInputDia...
String apel=javax.swing.JOptionPane.showInputDi...
String cargo=javax.swing.JOptionPane.showInputD...
double Basico=Double.parseDouble(javax.swing.JO...
double comisiones=Double.parseDouble(javax.swin...
double auxilio=Double.parseDouble(javax.swing.J... de Transporte:"));
Empleados dato=new Empleados(ced, nom, apel, cargo, Basico, comisiones, auxilio);
agregar(dato);
}
public void menu(){
int op=0;
String texto="ESTRUDATOS\nDigite el numeros de la opcion que desea utilizar\n1. Agregar\n2. Mostrar\n3. Salir \n\nOpción";
do{
op=Integer.parseInt(javax.swing.JOptionP...
switch (op){
case 1: leer();
break;
case 2: mostrar();
break;
default: if(op>3 op<1) aplicacion="new">
QUE ES UNA PILA
Una Pila es en la que el modo de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out, último en entrar, primero en salir) que permite almacenar y recuperar datos. Se aplica en multitud de ocasiones en informática debido a su simplicidad y ordenación implícita en la propia estructura.
Para el manejo de los datos se cuenta con dos operaciones básicas: apilar (push), que coloca un objeto en la pila, y su operación inversa, retirar (o desapilar, pop), que retira el último elemento apilado.
En cada momento sólo se tiene acceso a la parte superior de la pila, es decir, al último objeto apilado (denominado TOS, Top of Stack en inglés). La operación retirar permite la obtención de este elemento, que es retirado de la pila permitiendo el acceso al siguiente (apilado con anterioridad), que pasa a ser el nuevo TOS.
Por analogía con objetos cotidianos, una operación apilar equivaldría a colocar un plato sobre una pila de platos, y una operación retirar a retirarlo.
Las pilas suelen emplearse en los siguientes contextos:
Evaluación de expresiones en
Reconocedores sintácticos de lenguajes independientes del contexto
Implementación de recursividad.
Una pila cuenta con 2 operaciones imprescindibles: apilar y desapilar, a las que en las implementaciones modernas de las pilas se suelen añadir más de uso habitual.
Crear: se crea la pila vacía.
Apilar: se añade un elemento a la pila.(push)
Desapilar: se elimina el elemento frontal de la pila.(pop)
Cima: devuelve el elemento que esta en la cima de la pila. (top o peek)
Vacía: devuelve cierto si la pila está vacía o falso en caso contrario.
METODOS PILAS
JAVA:
import java.io.*;
public class Metodo_Principal{
//Declaramos el metodo principal
public static void main (String args[])throws IOException {
BufferedReader entrada = new BufferedReader (new InputStreamReader(System.in));
int Espacios = 0;
char Resp, op;
String aux;
//--- Imprimir Menu ---- \\
System.out.println("\n :: XROM RELOADED :: 19/07/07 \n");
System.out.print("\t Cuantos espacios quiere en la Pila (entre 3 y 30 recomendable)? :");
Espacios = Integer.parseInt(entrada.readLine());
Pila Ejecutar = new Pila(Espacios);
System.out.println("\n\n\t --- //---- Menu Pila------\\\\---- \n");
do {
System.out.println("\n\n1.- Imprimir Pila"); // Mostrar
System.out.println("2.- Agregar Elemento a la pila"); // Push
System.out.println("3.- Quitar Elemento de la pila"); // Pop
System.out.print("\n\n Elija una Opcion : ");
aux = entrada.readLine();
op = aux.charAt(0);
//---- Elegir opcion ---\\
switch (op) {
case '1':
Ejecutar.Imprimir();
break;
case '2':
Ejecutar.Push();
break;
case '3':
Ejecutar.Pop();
break;
default:
System.out.println("opcion fuera de rango !!");
} // Fin del switch
System.out.print("Desea hacer otra operacion ?? S / N ");
aux = entrada.readLine();
Resp = aux.charAt(0);
} while (Resp == 'S' Resp == 's');
System.out.println(" Garcias por utilizar este programa.. ");
System.out.println("\t para mas informacion en :: WWW.XROMRELOADED.TK ::");
} // Fin del metodo main
} // Fin de la calse
Pila.java (Clase y Metodos)
JAVA:
// Libreria necesaria para introducir datos desde el Teclado
import java.io.*;
// Inicio de la Clase Pila
public class Pila {
//----- Atributos de la pila ------\\
public int Pila []; // Estructura de la pila
public int Top, Max , Elem; // variables para la pila
//Top : El Tope de la pila , referencia al ultimo elemento que esta en la pila
//Max : Maximo de espacios que tiene la pila
//Elem : Elemento que se agrega a la pila (Tecleado por el usuario)
public char Resp; // Variables para SubMenus.
public String aux;
//----- Contructor -------\\
public Pila (int Espacios){ // se recibe como parametro los Espacios de la pila
Pila = new int [Espacios]; // Asignamos los espacios en la Pila
Max = Pila.length - 1;
Top = -1; // Top se declara como -1 como referencia a que no existen datos en la pila
} // fin del constructor
//----- Metodos de la pila -------\\
// Metodo Imprimir
public void Imprimir () {
for (int n = 0 ; n <= Max ; n++ ) { System.out.println(n + ".- " + Pila [n]);
}
} // Fin del Metodo Imprimir
// Metodo Push
public void Push ( ) throws IOException { // Metodo para ingresar datos ...
BufferedReader entrada = new BufferedReader (new InputStreamReader(System.in));
do {
// if (1)
if(Top != Max) { // Si la pila No esta llena ....
// Se puede agregar un nuevo dato a la pila ....
System.out.print("\t Ingrese un numero entero : ");
Elem = Integer.parseInt(entrada.readLine());
Top ++; // Se incrementa Top como referencia de que se agrego un nuevo dato
Pila[Top] = Elem; // Se agrega el nuevo elemento a la pila
// if (1.1)
if (Top == Max) { // Si la pila quedo llena entoces ...
// Imprimir mensaje
System.out.print("\n La Pila a quedado llena !! ");
// con esta variable detenemos el bucle do - while
Resp = 'N';
} // Fin del if (1.1)
} else {
System.out.println("\n Pila llena !! Imposible introducir un valor a la pila");
Resp = 'N'; // detenemos el bucle
} // Fin del if (1)
// if (2)
if (Resp != 'N') {
// Si es diferente de No , entoces seguir preguntado si se desea introducir mas datos
System.out.print("Desea introducir un dato mas ??");
aux = entrada.readLine();
Resp = aux.charAt(0);
} // Fin del if (2)
} while (Resp == 'S' Resp == 's'); // Continuar ciclando simpre y cuando sea Resp = 's'
} // Fin del Metodo Push
// Metodo Pop
public void Pop () {
if(Top != -1) { // Si la pila no esta vacia entonces ....
System.out.println("Se borro el Dato : " + Pila[Top]);
// Eliminar dato
Pila[Top] = 0; // remplaza el valor por un cero (Eliminado)
Top --; // Top se reduce para decir que un elemento se borro
} else { // De lo contrario imprime .."que la pila esta vacia"
System.out.println("Pila Vacia... Imposible Eliminar");
} // fin del if
} //Fin del Metodo Pop
} // Fin de la Clase Pila
{
private Nodo tope;
public PilaLi()
{
tope = null;
}
public boolean esVacia()
{
return tope == null;
}
public void vaciar()
{
tope = null;
}
public void push(Object x)
{
tope = new Nodo(x,tope);
}
public Object info() throws Exception
{
if ( esVacia() )
throw new Exception("info");
return tope.dato;
}
public void pop() throws Exception
{
if ( esVacia() )
throw new Exception("pop");
tope = tope.siguiente;
}
}
interface Pila
{
void push(Object x);
void pop() throws Exception;
Object info() throws Exception;
boolean esVacia();
void vaciar();
}
class Nodo
{
public Object dato;
public Nodo siguiente;
public Nodo(Object elemento, Nodo sgte)
{
this.dato = elemento;
this.siguiente = sgte;
}
public Nodo(Object elemento)
{
this(elemento,null);
}
}
import java.io.*;
class test2
{
public static void convertirBase(int numero,int base)
{
Pila p = new PilaLi();
while(numero != 0)
{
p.push(new Integer( numero % base ));
numero /= base;
}
try
{
for(;;)
{
System.out.print(p.info());
p.pop();
}
} catch(Exception e) {}
}
public static void main(String arg[])
{
BufferedReader in = new BufferedReader(new
InputStreamReader(System.in));
int num,base;
boolean seguir = true;
while(seguir)
{
try
{
System.out.print("\n\tIngrese un numero : ");
num = Integer.parseInt(in.readLine());
System.out.print("\tIngrese la nueva base : ");
base = Integer.parseInt(in.readLine());
System.out.print("\tEl numero " + num + " en base " + base + " es : ");
convertirBase(num,base);
System.out.print("\n\tQuiere seguir : s/n : ");
String resp = in.readLine();
if (resp.charAt(0) == 's') seguir = true;
else seguir = false;
}
catch (Exception e)
{
System.out.println("\tError de entrada : " + e);
}
} // fin while
} // fin main
}
class TestPila
{
public static void main(String arg[])
{
Pila p = new PilaLi();
for(int i = 0; i < pilaaux =" duplicar(pila);" e =" pilaAux.tope();" pila2 =" (Pila)pila.getClass().newInstance();" pilaaux =" (Pila)pila.getClass().newInstance();" e =" pila.tope();" e =" pilaAux.tope();" pilaaux =" new" colaaux =" duplicar(cola);" e =" colaAux.primero();" cola2 =" (Cola)cola.getClass().newInstance();" e =" pilaAux.tope();">
IMPLEMENTACIONES
package pilaBasadaLista;
import pilaException.*;
import listaException.*;
import listaSimpleEnlazada.*;
public class Pila implements pilaInterface.Pila {
private Lista lista;
public Pila() {
lista = new Lista();
}
public boolean vacia() {
return lista.vacia();
}
public Object tope() throws PilaVaciaException {
if (vacia()) throw new PilaVaciaException();
try {
return lista.recupera(lista.primero());
} catch (ListaException e) {
System.err.println("Error interno de la Pila: "+e);
return null;
}
}
public void push(Object elemento) {
try {
if (vacia()) lista.inserta(lista.fin(),elemento);
else lista.inserta(lista.primero(),elemento);
} catch (ListaVaciaException e) {
System.err.println("Error interno de la Pila");
}
}
public void pop() throws PilaVaciaException{
if (vacia()) throw new PilaVaciaException();
try {
lista.suprime(lista.primero());
} catch (ListaException e) {
System.err.println("Error interno de la Pila");
}
}
} // fin class Pila
*************************************
IMPLEMENTACION CON VECTORES
package pilaContigua;
import pilaException.*;
public class Pila implements pilaInterface.Pila {
private static int max = 100;
private Object elementos[];
private int tope;
public Pila() {
elementos = new Object[max];
tope=max;
}
public boolean vacia() {
return (tope==max);
}
**********************************
public Object tope() throws PilaVaciaException {
if (vacia()) throw new PilaVaciaException();
return elementos[tope];
}
public void push(Object elemento) {
tope--;
elementos[tope]=elemento;
}
public void pop() throws PilaVaciaException{
if (vacia()) throw new PilaVaciaException();
tope++;
}
} // fin class Pila
IMPLEMENTACIÓN CON APUNTADORES
package pilaSimpleEnlazada;
import pilaException.*;
public class Pila implements pilaInterface.Pila {
class Celda {
Object elemento;
Celda sig;
}
private Celda pila;
public Pila() {
pila = null;
}
public boolean vacia() {
return (pila==null);
}
public Object tope() throws PilaVaciaException {
if (vacia()) throw new PilaVaciaException();
return pila.elemento;
}
public void push(Object elemento) {
Celda aux = new Celda();
aux.elemento = elemento;
aux.sig = pila;
pila = aux;
}
public void pop() throws PilaVaciaException{
if (vacia()) throw new PilaVaciaException();
pila = pila.sig;
}
} // fin class Pila
public class Prueba{
//creamos nuestros arrays de enterosint array1[]= {1,2,3,4,5,6,7};
//rellenamos los vectoresVectorEnteros v1=new VectorEnteros();
//creamos una pila con los 7 vectores de enteros Pila p1=new Pila(7);
//creamos varias pilas para almacenar en la cola y hacer pruebas con ellas Pila p2=new Pila(7); p2=p1;
Cola c1=new Cola();
Cola c2=new Cola();
Cola c3=new Cola();
c4.encolar(p7);
c1.imprimir();
//Clase Cola implementada como lista dinámica en la que se almacenan pilas. Observar que se cumple FIFO:
public class Cola{private Nodo primero;
public Cola(){primero = null;ultimo = null;}
public boolean vacia(){return (primero == null);}
public void encolar(Pila p)
if(vacia())primero = nuevo;
public Pila desencolar(){if(vacia())
public void imprimir(){int j=1;
if(!vacia()){
while(!vacia())
Pila p = primero.pila;
ultimo = null;
//Clase Pila implementada como array en la que se almacenan vectores de enteros. Observar que se cumple LIFOpublic
public Pila(int numElementos)
public int vacia(){return(indice =-1);}
public void push(VectorEnteros v){indice++;elementos[indice]=v;}
public VectorEnteros pop(){VectorEnteros v= elementos[indice];
public void imprimir()
}
CLASE VECTOR DE ENTEROS
import java.util.Vector;
public class VectorEnteros {
public VectorEnteros(){
public void añadir(int n[])
public void imprimir(){Enumeration e=vectorenteros.elements();
}