Estructuras Lineales





Listas


Conjunto de elementos llamados nodos.


------------------

Dato puntero

------------------



------------------ ------------------- ---------------------------
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 void insertar (String Elemento);

public boolean eliminar (string elemento);

public string eliminar();

public booelan buscar(string elemento);

public string recorrer(); public boolean vacio();

public int tamaño();


}



PRINCIPAL . JAVA
package invent;import util.Lectura;
public class Principal {
public static void main (String argv[]) {
int opcion;
Lista lista = new Lista();
Lista aux=new Lista();
for(;;){
System.out.println("\n MENU PRINCIPAL");
System.out.println(" ==============");
System.out.println(" 1.Adicionar un elemento");
System.out.println(" 2.Generar listado de inventario");
System.out.println(" 3.Generar listado de subtotales de todo el inventario"); System.out.println(" 4.Modificar un valor");
System.out.println(" 5.Modificar la existencia");
System.out.println(" 6.Salir");
System.out.println("Digite Opcion : ");
opcion=Lectura.datoInt();
switch(opcion){
case 1:
lista.adicionar();
break;
case 2:
while (aux!= null){
aux.Lista_nodo();
aux = aux.sig;
break;
}
case 3:{
} case 4:{
}
case 5:{
}
case 6: System.exit(0);
default : System.out.println("\nDigito Opcion Errada");
}
}
}
}
LISTA . JAVA
package invent;import util.*;
public class Lista {
int codg_elemento; Lista aux;
Lista aux_a;
int aux1;
String nombre_elemento;
long valor_elemento;
int existencias;
Lista sig;
static Lista cab= null;
static Lista ult=null;
public void adicionar(){
Lista nuevo;
if (cab==null){
cab=new Lista();
cab.cargar();
cab.sig= null;
ult=cab;
}else{
nuevo=new Lista();
nuevo.cargar();
if (cab.codg_elemento>nuevo.codg_elemento){
nuevo.sig=cab;
cab=nuevo;
}else{
if (ult.codg_elemento
ult=nuevo;
ult.sig=null;
}else{
aux=cab;
while (aux!=null){
if (nuevo.codg_elemento
break;
aux_a=aux;
aux=aux.sig; }
nuevo.sig=aux;
aux_a.sig=nuevo;
}
}
}
}
public void cargar(){
System.out.println("Digite codigo del elemento:");
codg_elemento=Lectura.datoInt();
System.out.println("Digite nombre del elemento:");
nombre_elemento=Lectura.datoCadena();
System.out.println("Digite valor del elemento:");
valor_elemento=Lectura.datoLong();
System.out.println("Digite existencia:");
existencias=Lectura.datoInt(); }
public void Lista_nodo(){
System.out.println("Codigo del elemento="+codg_elemento);
System.out.println("Nombre elemento="+nombre_elemento);
}
}
PROGRAMA ALUMNOS
1- El programa pide el nombre del alumno y tres calificaciones para luego calcular su promedio. Se puede agregar cualquier cantidad de elementos a la lista.
Aqui vemos el Algoritmo respectivo:

import java.util.*;
public class ListaAlumnos{
static double prom;
public static void main( String args[] ){
Scanner leer = new Scanner(System.in);
NodoLista4 nodo = new NodoLista4();
int op;
ArrayList lista = new ArrayList(); do{
System.out.println( "Ingrese el nombre del alumno:" );
nodo.nom = leer.next();
System.out.println( "Ingrese la primera calificación:" );
nodo.calif1 = leer.nextInt();
System.out.println( "Ingrese la segunda calificación:" );
nodo.calif2 = leer.nextInt();
System.out.println( "Ingrese la tercera calificación:" );
nodo.calif3 = leer.nextInt();
lista.add("Nombre del alumno:\n"+nodo.nom);
lista.add("Calificación 1:\n"+nodo.calif1);
lista.add("Calificación 2:\n"+nodo.calif2);
lista.add("Calificación 3\n"+nodo.calif3);
promedio(nodo.calif1, nodo.calif2, nodo.calif3);
lista.add("Su promedio es:\n"+prom);
System.out.println( "¿Desea ingresar otro alumno?" );
System.out.println( "1.-Si\t 2.-No" ); op = leer.nextInt(); }
while(op != 2);
List lista2 = new ArrayList(lista);
Iterator it = lista2.iterator();
while (it.hasNext()){
System.out.println(it.next()+"");
}
} private static double promedio(int calif1, int calif2, int calif3){
int suma = calif1 + calif2 + calif3;
prom = suma/3; return prom;
}
}

LISTAS SIMPLES Y DOBLES

Listas simples enlazadas :





La lista enlazada básica es la lista enlazada simple la cual tiene un enlace por nodo. Este enlace apunta al siguiente nodo en la lista, o al valor NULL o a la lista vacía, si es el último nodo.







Lista Doblemente Enlazada :





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:

PUBLIC VOID ( INSERTAR) ( STRING ELEMENTO);
PUBLIC BOOLEAN ELIMINAR ( STRING ELEMENTO);
PUBLIC STRING ELIMINAR ();
PUBLIC BOOLEAN BUSCAR ( STRING ELEMENTO);
PUBLIC STRING RECORRER();
PUBLIC BOOLEAN VACIO();
PUBLIC INT TAMAÑO ();
// EN LISTAS DOBLES:
FUNCIONES:


- 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.
Una sucesión de Fibonacci es aquella cuya ley de recurrencia es:

an = an-1 + an-2
Es decir, cada término de la sucesión se obtiene sumando los dos anteriores. Para empezar a construirla necesitamos, por tanto, dos números de partida, a1 y a2. De esta forma, a3 sería a2 + a1 ; a4 sería a3 + a2 y así sucesivamente. La más conocida es la que tiene a1 = 1 y a2 = 1, cuyos términos son:

1 1 2 3 5 8 13 21 34 55 89 144 233 377 ...
números que son conocidos como Números de Fibonacci.Los términos de cualquier sucesión de Fibonacci tienen la particularidad de que el cociente entre dos términos consecutivos se aproxima al Número de Oro (1.6180339887499...), es decir, el límite de los cocientes an+1/an tiende al Número de Oro cuando n tiende a infinito.Además, las series de Fibonacci cumplen otras curiosas propiedades, como por ejemplo, que la suma de n términos es igual al término n+2 menos uno:

a1 + a2 + a3 + a4 + ..... + an-1 + an = an+2 - 1
Definición formal

Los números de Fibonacci quedan definidos por las ecuaciones:

(1) f=0
(
2) f=1
(
3) fn=fn-1+fn-2 para n= 2,3,4,5,.......
Esto produce los números
* F0= 0
* F1= 1
* F2= 1
* F3= 2
* F4= 3
* F5= 5
* F6= 8
y así sucesivamente hasta el infinito.







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

public class problema1
{public static void main(String[] args)
{System.out.print("¿Cuántas edades desea ingresar?");
int n=Leer.datoInt();
int[] edades=new int[n];
int i;
for(i=0;i
{
System.out.println("ingrese edad No "+(i+1)+":");
edades[i]=Leer.datoInt();
}System.out.println("\nbuscar edad\n");
System.out.print("ingrese edad a buscar:");
int E=Leer.datoInt();
boolean encontrado=false;for(i=0;i
if (edades[i]==E){System.out.println("edad encontrada en el indice:"+i);
encontrado=true;}
}if (encontrado==false)System.out.println("no se encuentra la edad buscada en el array");
System.out.println("\nEdades almacenadas\n");
for(i=0;i
System.out.println("edades["+i+"]:"+edades[i]);
}
}
}




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

import java.io.Serializable;

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 notación postfija (notación polaca inversa).
Reconocedores sintácticos de
lenguajes independientes del contexto
Implementación de
recursividad.



OPERACIONES:



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

Metodo_Principal.java (Metodo Principal)
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
2- PROGRAMA_PILAS
class PilaLi implements 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{
public static void main(String[]args){
//creamos nuestros arrays de enterosint array1[]= {1,2,3,4,5,6,7};
int array2[]= {1,2,3,4
array3[]= {1,2};
int array4[]= {1,2,3,4,5,6,7,8,9,10};
int array5[]= {1};
int array6[]= {1,2,3,4,5};
int array7[]= {1,2,3,4,5,6};
//rellenamos los vectoresVectorEnteros v1=new VectorEnteros();
v1.añadir(array1);
VectorEnteros v2=new VectorEnteros();
v2.añadir(array2);
VectorEnteros v3=new VectorEnteros();
v3.añadir(array3);
VectorEnteros v4=new VectorEnteros();
v4.añadir(array4);
VectorEnteros v5=new VectorEnteros();
v5.añadir(array5);
VectorEnteros v6=new VectorEnteros();
v6.añadir(array6);
VectorEnteros v7=new VectorEnteros();
v7.añadir(array7);
//creamos una pila con los 7 vectores de enteros Pila p1=new Pila(7);
p1.push(v1);
p1.push(v2);
p1.push(v3);
p1.push(v4);
p1.push(v5);
p1.push(v6);
p1.push(v7);
//creamos varias pilas para almacenar en la cola y hacer pruebas con ellas Pila p2=new Pila(7); p2=p1;
Pila p3=new Pila(7);
p3=p1;
Pila p4=new Pila(7);
p4=p1;
Pila p5=new Pila(7);
p5=p1;
Pila p6=new Pila(7);
p6=p1;
Pila p7=new Pila(4);
//cambiamos el orden y el tamañop7.push(v4);
p7.push(v2);p7.push(v3);
p7.push(v1);
Cola c1=new Cola();
c1.encolar(p1);
c1.encolar(p7);
c1.encolar(p3);
c1.encolar(p7);
Cola c2=new Cola();
c2.encolar(p7);
c2.encolar(p6);
c2.encolar(p5);
Cola c3=new Cola();
Cola c4=new Cola();
c4.encolar(p7);
c1.desencolar();
c1.imprimir();
c2.imprimir();
c3.imprimir();
c4.imprimir();
}
}
//Fin clase

//Clase Cola implementada como lista dinámica en la que se almacenan pilas. Observar que se cumple FIFO:

public class Cola{private Nodo primero;
private Nodo ultimo;
public Cola(){primero = null;ultimo = null;}
public boolean vacia(){return (primero == null);}
public void encolar(Pila p)
{Nodo nuevo = new Nodo(p,null);
if(vacia())primero = nuevo;
lseultimo.siguiente = nuevo;
ultimo = nuevo;}
public Pila desencolar(){if(vacia())
{System.err.println(”No hay elementos en la cola\n”);
return null;}
else{Pila p = primero.pila;primero = primero.siguiente;
if(vacia()){ultimo = null;}
return p;
}
}
public void imprimir(){int j=1;
if(!vacia()){
System.out.println(”CONTENIDO DE LA COLA\n”);
while(!vacia())
{System.out.println(”Pila “+j+”: \n”);
Pila p = primero.pila;
primero = primero.siguiente;
ultimo = null;
p.imprimir();
j++;}
System.out.println(”\n”);
}else
{System.out.println(”ESTA COLA ESTÁ VACÍA”);
System.out.println(”\n\n”);}
}
}
//Fin clase

//Clase Pila implementada como array en la que se almacenan vectores de enteros. Observar que se cumple LIFOpublic
class Pila{private int numElementos;private VectorEnteros elementos[];
private int indice;
public Pila(int numElementos)
{this.numElementos=numElementos;indice=-1;
elementos= new VectorEnteros[numElementos];
for(int i=0;
i
i++){elementos[i]=new VectorEnteros();}
}
public int vacia(){return(indice =-1);}
public int llena(){return (indice=numElementos-1);}
public void push(VectorEnteros v){indice++;elementos[indice]=v;}
public VectorEnteros pop(){VectorEnteros v= elementos[indice];
indice–;return v;}
public void imprimir()
{int j=0;
for (int i=elementos.length-1;
i>=0;i–){System.out.print(”Vector “+(j+1)+”\t”);
elementos[i].imprimir();j++;
}System.out.println(”");
}
}
//Fin clase

CLASE VECTOR DE ENTEROS

import java.util.Vector;
import java.util.Enumeration;
public class VectorEnteros {
//vector que va a guardar los enterosprivate Vector vectorenteros;
/*Por simplicidad creamos un array que contenga inicialmente los enteros que queremos guardar.Si queremos modificar el vector, solo hay que modificar el array correspondiente en la
clase Prueba*/private int numeros[];
public VectorEnteros(){
//Creo el vectorvectorenteros=new Vector();}
public void añadir(int n[])
{numeros=n;for (int i=0;
i<>
i++){Integer num=new Integer(numeros[i]);
vectorenteros.addElement(num);}
}
public void imprimir(){Enumeration e=vectorenteros.elements();
while(e.hasMoreElements()){
//Hay que hacer cambio de tipoInteger entero=(Integer)e.nextElement();
System.out.print(entero+” “);
}System.out.println(”");
}
}
//Fin clase



OPERACIONES PILAS

package pilas;
import java.util.Vector;
public class Pila {
private int size;
private Vector elementos;
public Pila() {
super();
elementos = new Vector();
size = 0;
} public boolean pilaVacia () {
if (size==0) {
return true;
}
return false;
}
public void apilar ( Tipo o ) {
elementos.add(size, o);
size++; }
public Tipo desapilar () {
try {
if(pilaVacia())
throw new ErrorPilaVacia();
else {
return elementos.get(--size); } } catch(ErrorPilaVacia error) {
System.out.println("ERROR: la pila esta vacía"); return null;
}
}
public int getSize() {
return size; } }
@SuppressWarnings("serial")class ErrorPilaVacia extends
Exception { public ErrorPilaVacia() {
super(); }}
package pilas;
public class Test {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
Pila pila;
pila = new Pila();
System.out.println("Elementos en pila: " + pila.getSize());
pila.apilar("Uno");
System.out.println("Elementos en pila: " + pila.getSize());
pila.apilar("Dos");
System.out.println("Elementos en pila: " + pila.getSize());
System.out.println("Extraigo.........: " + pila.desapilar().toString());
System.out.println("Elementos en pila: " + pila.getSize());
System.out.println("Extraigo.........: " + pila.desapilar().toString());
System.out.println("Elementos en pila: " + pila.getSize());
pila = new Pila();
System.out.println("Elementos en pila: " + pila.getSize());
pila.apilar(1);
System.out.println("Elementos en pila: " + pila.getSize());
pila.apilar(2);
System.out.println("Elementos en pila: " + pila.getSize());
System.out.println("Extraigo.........: " + pila.desapilar().toString());
System.out.println("Elementos en pila: " + pila.getSize());
System.out.println("Extraigo.........: " + pila.desapilar().toString());
System.out.println("Elementos en pila: " + pila.getSize());

QUE ES UNA COLA

Una cola es un tipo especial de lista abierta en la que sólo se pueden insertar nodos en uno de los extremos de la lista y sólo se pueden eliminar nodos en el otro.

Además, las escrituras de datos siempre son inserciones de nodos, y las lecturas siempre eliminan el nodo leído.

Este tipo de lista es conocido como lista FIFO (First In First Out), el primero en entrar es el primero en salir.

Un ejemplo de la vida Real es una cola, una fila, como para comprar un boleto para el cine.
Los nuevos compradores sólo pueden colocarse al final de la cola, y sólo el primero de la cola puede comprar la entrada.


OPERACIONES:


Crear: se crea la cola vacía.
Encolar (añadir, entrar, push): se añade un elemento a la cola. Se añade al final de esta.
Desencolar (sacar, salir, pop): se elimina el elemento frontal de la cola, es decir, el primer elemento que entró.
Frente (consultar, front): se devuelve el elemento frontal de la cola, es decir, el primero elemento que entró.


Cola.java(Clase y Metodos de la Cola)


import java.io.*;

//Declaramos la clase calculatorTest
public class ejecutar_cola{


//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 Cola (entre 3 y 30 recomendable)? :");
Espacios =
Integer.parseInt(entrada.readLine());

Cola Ejecutar = new Cola(Espacios);

//--- Imprimir Menu ---- \\

System.out.println("\n\n\t ------------ //-------- Menu Cola Simple --------\\\\------------ \n ");

do {

System.out.println("\n\n1.- Imprimir Cola"); // Mostrar
System.out.println("2.- Agregar Elemento a la Cola"); // Push
System.out.println("3.- Quitar Elemento de la Cola"); // 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');


} // Fin del metodo main

} // Fin de la calse