Está en la página 1de 38

Cola que almacena 10 numeros en vectory realiza funciones de dar de altas

numeros introducidos, eliminar, mostrar ,salir.

import java.io.*;

public class Colas {


public static class ClaseColas { // Declaracion de la clase de Colas
static int max=10; // Tamano maximo de la Cola
static int cola[]= new int[max]; // Declaracion del arreglo
static int frente, fin; // Indicadores de inicio y fin de la Cola

ClaseColas() { // Constructor que inicializa el frente y el final de la Cola


frente=0; fin=0;
System.out.println("Cola inicializada !!!");
}

public static void Insertar(int dato) {


if(fin==max) { // Esta llena la Cola?
System.out.println("\nCola llena !!!");
return;
}
cola[fin++]=dato;
System.out.println("Dato insertado !!!");
}

public static void Eliminar() {


System.out.println("\n\n<<< ELIMINAR >>>");
if(frente==fin) { // Esta vacia la Cola?
System.out.println("\nCola vacia !!!");
return;
}
System.out.println("Elemento eliminado: "+cola[frente++]);
}

public static void Mostrar() {


int i=0;
System.out.println("\n\n<<< MOSTRAR >>>");
if(frente==fin) System.out.println("\nCola vacia !!!");
for(i=frente; i<fin; i++) {
System.out.println("cola["+i+"]="+" "+cola[i]);
}
System.out.println("\nFrente= "+frente);
System.out.println("Final = "+fin);
System.out.println("Max = "+max);
}
}

static ClaseColas Cola=new ClaseColas(); // Declaracion del objeto Cola

// Funcion principal
public static void main(String args[]) throws IOException {
int op=0;
do {
System.out.println("\n\n<<< COLAS >>>");
System.out.println("1.- Altas");
System.out.println("2.- Eliminar");
System.out.println("3.- Mostrar");
System.out.println("0.- Salir");
System.out.print("Opcion? ---> ");
op=getInt();

switch(op) {
case 1 : Altas(); break;
case 2 : Cola.Eliminar(); break;
case 3 : Cola.Mostrar(); break;
}
}while(op!=0);
}

public static void Altas() throws IOException {


int elemento=0;
System.out.println("\n\n<<< ALTAS >>>");
System.out.print("Elemento a insertar? ---> ");
elemento=getInt();
Cola.Insertar(elemento); // Invocar el metodo Insertar del objeto Cola
}

// Funcion para capturar una cadena desde el teclado


public static String getString() throws IOException {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String s = br.readLine();
return s;
}

// Funcion para capturar un entero desde el teclado


public static int getInt() throws IOException {
String s = getString();
return Integer.parseInt(s);
}
}

Cola circular

Cola que almacena 5 numeros y muestra el primero y el ultimo

import java.io.*;

public class ColaCircular {

public static class ClaseColaCircular { // Declaracion de la clase de la Cola Circular

static int max=5; // Tamano maximo de la Cola Circular

static int colacirc[]=new int[max]; // Declaracion del arreglo para almacenar la Cola Circular

static int frente, fin; // Inidicadores del inicio y final de la Cola Circular

ClaseColaCircular() { // Constructor que inicializa el frente y el final de la Cola Circular

frente=-1; fin=-1;

System.out.println("Cola circular inicializada !!!");

public static void Mostrar() {

int i=0;

System.out.println("\n\n<<< MOSTRAR COLA CIRCULAR >>>");

if(frente==-1) {

System.out.println("\nCola Circular vacia !!!");

}
else {

i=frente;

do {

System.out.println("colacircssss["+i+"]="+colacirc[i]);

i++;

if(i==max && frente>fin) i=0; // Reiniciar en cero (dar la vuelta)

}while(i!=fin+1);

System.out.println("frente="+frente);

System.out.println("fin="+fin);

System.out.println("max="+max);

public static void Insertar(int dato) {

if((fin==max-1 && frente==0) || (fin+1==frente)) {

System.out.println("\nCola Circular llena !!!");

return;

if(fin==max-1 && frente!=0) fin=0; else fin++;

colacirc[fin]=dato;

if(frente==-1) frente=0;

public static void Eliminar() {

System.out.println("\n\n<<< ELIMINAR DATO >>>");


if(frente==-1) {

System.out.println("Cola Circular vacia !!!");

return;

System.out.println("Dato eliminado = "+colacirc[frente]);//elimina en el vector

if(frente==fin) { //el primer fuente

frente=-1; fin=-1; //si frente igual a fin vacios mostrar -1

return;

if(frente==max) frente=0; else frente++;

// Declaracion del objeto ColaCircular

static ClaseColaCircular ColaCircular=new ClaseColaCircular();

// Funcion principal

public static void main(String args[]) throws IOException {

int op=0;

do {

System.out.println("\n\n<<< COLAS CIRCULARES >>>");

System.out.println("1.- Insertar");

System.out.println("2.- Eliminar");

System.out.println("3.- Mostrar");

System.out.println("0.- Salir");

System.out.print("Opcion? ---> ");

op=getInt();

switch(op) {
case 1 : Altas(); break;

case 2 : ColaCircular.Eliminar(); break;

case 3 : ColaCircular.Mostrar(); break;

}while(op!=0);

public static void Altas() throws IOException {

int dato;

System.out.println("\n\n<<< ALTAS >>>");

System.out.print("Dato a insertar? ---> ");

dato=getInt();

ColaCircular.Insertar(dato); //Invocar el metodo Insertar del objeto ColaCircular

// Funcion para capturar una cadena desde el teclado

public static String getString() throws IOException {

InputStreamReader isr = new InputStreamReader(System.in);

BufferedReader br = new BufferedReader(isr);

String s = br.readLine();

return s;

// Funcion para capturar un entero desde el teclado

public static int getInt() throws IOException {

String s = getString();

return Integer.parseInt(s);

}
------------------------------------------------------------------------------------------------------------

pila

pila que almacena 10 numeros con funciones pop, push,mostrar, salir.

import java.io.*;

public class Pilas {

public static class ClasePila { // Declaracion de la clase de la Pila

private int max=10; // Tamano maximo de la pila

private int pila[] = new int [max]; // Arreglo para almacenar la pila

private int top; // Indica la cantidad de datos en la pila

public ClasePila() { // Constructor

top=0;

System.out.println("Pila creada !!!");

public void Push(int dato) {

if(top==max) // Esta llena la Pila?

System.out.println("Pila llena !!!");

return;

for(int i=0; i<top; i++) {

if(pila[i]==dato) { // Ya existe el dato?

System.out.println("Duplicado !!!");
return;

if(dato<pila[i]) { // Alta al principio o intermedia

for(int j=top;j>i;j--)

pila[j]=pila[j-1];

pila[i]=dato;

top++;

System.out.println("Dato insertado al principio o intermedio !!!");

return;

pila[top++]=dato; // Alta al final

System.out.println("Dato insertado al final !!!");

return;

public void Pop(int dato) {

if(top==0) { // Esta vacia la Pila?

System.out.println("Pila vacia !!!");

return;

for(int i=0;i<top;i++) {

if(pila[i]==dato) {

for(int j=i; j<top-1; j++)

pila[j]=pila[j+1];

top--;

System.out.println("Dato eliminado !!!");

return;

}
}

System.out.println("Dato inexistente !!!");

public void Mostrar() {

System.out.println("\n\n<<< MOSTRAR LA PILA >>>");

if(top==0) System.out.println("Pila vacia !!!");

for(int i=0;i<top;i++)

System.out.println("pila["+i+"]="+pila[i]);

System.out.println("top="+top);

System.out.println("max="+max);

static ClasePila Pila=new ClasePila(); // Declaracion del objeto Pila

// Funcion principal

public static void main(String args[]) throws IOException {

int op=0;

do {

op=0;

System.out.println("\n\n<<< PILAS >>>");

System.out.println("1.-Push");

System.out.println("2.-Pop");

System.out.println("3.-Mostrar Pila");

System.out.println("0.-Salir");

//op=Integer.parseInt(JOptionPane.showInputDialog("Opcion? "));
System.out.print("Opcion? ---> ");

op=getInt();

switch(op) {

case 1 : Altas(); break;

case 2 : Bajas(); break;

case 3 : Pila.Mostrar(); break;

}while(op!=0);

public static void Altas() throws IOException {

int dato=0;

System.out.println("\n\n<<< ALTAS >>>");

System.out.print("\nAnote el dato que desea insertar ---> ");

dato=getInt();

Pila.Push(dato); // Invocar el metodo Push del objeto Pila

public static void Bajas() throws IOException {

int dato=0;

System.out.println("\n\n<<< BAJAS >>>");

System.out.print("\nAnote el dato que desea eliminar ---> ");

dato=getInt();

Pila.Pop(dato); // Invocar el metodo Pop del objeto Pila

// Funcion para capturar una cadena desde el teclado

public static String getString() throws IOException {


InputStreamReader isr = new InputStreamReader(System.in);

BufferedReader br = new BufferedReader(isr);

String s = br.readLine();

return s;

// Funcion para capturar un entero desde el teclado

public static int getInt() throws IOException {

String s = getString();

return Integer.parseInt(s);

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

Listas

import java.io.*;
public class Listas {
public static class ClaseListas { // Declaracion de la clase de Listas
static char dato[]=new char[100]; //Declaracion del arreglo para los datos de tipo char
static int sn[]=new int[100]; //Declaracion del arreglo para el indicador del sig. nodo
static int apui, top; // Apuntador inicial y Cantidad de datos en la Lista
ClaseListas() { // Constructor de la ClaseListas
apui=-1;
top=0;
System.out.println("Lista enlazada inicializada !!!");
System.out.println("apui="+apui);
System.out.println("top ="+top);
}
public static void Mostrar() {
int i=0;
System.out.println("\n\n<<< MOSTRAR ESTRUCTURA >>>");
if(apui==-1) System.out.println("\nLista enlazada vacia !!!\n");
System.out.println("posicion dato sn");
System.out.println("---------------------------");
for(i=0;i<top;i++) {
System.out.println(i+" | "+dato[i]+" | "+sn[i]);
}
System.out.println("\napui="+apui);
System.out.println("top="+top);
}
public static void Insertar(char elemento) {
int i=0, ant=0;
if(apui==-1) { //Alta en Lista vacia
System.out.println("Insertar dato en lista vacia ...");
apui=top;
dato[top]=elemento;
sn[top]=-1;
top++;
return;
}
i=apui;
do {
if(dato[i]==elemento) {
System.out.println("Duplicado !!!");
return;
}
if(elemento<dato[i]) {
if(i==apui) { //Alta al principio
System.out.println("Insertando el dato menor de todos ...");
dato[top]=elemento;
sn[top]=apui;
apui=top;
top++;
return;
} else {
System.out.println("Alta intermedia ...");
dato[top]=elemento;
sn[top]=sn[ant];
sn[ant]=top;
top++;
return;
}
}
ant=i;
i=sn[i];
}while(i!=-1);
System.out.println("Alta al final ...");
dato[top]=elemento;
sn[top]=-1;
sn[ant]=top;
top++;
return;
}
}
// Declaracion del objeto Lista
static ClaseListas Lista=new ClaseListas();
//Funcion principal
public static void main(String args[]) throws IOException {
int op=0;
do {
System.out.println("\n\n<<< LISTAS ENLAZADAS >>>");
System.out.println("1.- Altas");
System.out.println("2.- Mostrar estructura");
System.out.print("Opcion? ---> ");
op=getInt();
switch(op) {
case 1 : Altas(); break;
case 2 : Lista.Mostrar(); break;
}
}while(op!=0);
}
public static void Altas() throws IOException {
char dato;
System.out.println("\n\n<<< ALTAS >>>");
System.out.print("Dato a insertar ---> ");
dato=getChar();
Lista.Insertar(dato); //Invocar el metodo Insertar del objeto Lista
}
//Funcion para capturar una cadena desde el teclado
public static String getString() throws IOException {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String s = br.readLine();
return s;
}

// Funcion para capturar un entero desde el teclado


public static int getInt() throws IOException {
String s = getString();
return Integer.parseInt(s);
}
//Funcion para capturar un caracter desde el teclado
public static char getChar() throws IOException {
String s=getString();
return s.charAt(0);
}
}
------------------------------------------------------------------------------------------------------------

Lista encadenada

import java.io.*;

public class Listas_Objetos {

public static class ClaseLista {

public static class ClaseNodo {

char dato; // Dato del nodo (NO debe declararse "static")

ClaseNodo sn; // Apuntador al siguiente nodo (NO debe declararse "static")

static ClaseNodo inicial;

public static void Inicializar() {

inicial=new ClaseNodo();

inicial=null;

public static void Eliminar(char d) throws IOException {

ClaseNodo i=inicial, anterior=i;

if(i==null) {

System.out.println("Lista vacia !!!");


getch();

return;

while(i!=null) {

if(d==i.dato) {

if(i==inicial) {

inicial=i.sn;

System.out.println("\nBaja al principio...");

getch();

return;

anterior.sn=i.sn;

System.out.println("\nBaja intermedia o al final ...");

getch();

return;

anterior=i;

i=i.sn;

System.out.println("\nNo existe ese dato !!!");

getch();

return;

public static void Insertar(char d) throws IOException {

ClaseNodo i=inicial, nuevo_nodo, anterior=i;

if(i==null) {

nuevo_nodo=new ClaseNodo();
nuevo_nodo.dato=d;

nuevo_nodo.sn=null;

inicial=nuevo_nodo;

System.out.println("\nAlta a lista vacia...");

getch();

return;

while(i!=null) {

if(d==i.dato) {

System.out.println("\nDuplicado !!!");

getch();

return;

if(d<i.dato) {

if(i==inicial) {

nuevo_nodo=new ClaseNodo();

nuevo_nodo.dato=d;

nuevo_nodo.sn=inicial;

inicial=nuevo_nodo;

System.out.println("\nAlta al principio...");

getch();

return;

nuevo_nodo=new ClaseNodo();

nuevo_nodo.dato=d;

nuevo_nodo.sn=anterior.sn;

anterior.sn=nuevo_nodo;

System.out.println("\nAlta intermedia...");

getch();
return;

anterior=i;

i=i.sn;

nuevo_nodo=new ClaseNodo();

nuevo_nodo.dato=d;

nuevo_nodo.sn=null;

anterior.sn=nuevo_nodo;

System.out.println("\nAlta al final...");

getch();

return;

public static void Recorrido() throws IOException {

ClaseNodo i=inicial;

clrscr();

System.out.println("\n<<< RECORRIDO DE UNA LISTA ENCADENADA >>>\n\n");

if(i==null) {

System.out.println("\nLista vacia");

while(i!=null) {

System.out.print(i.dato+"->");

i = i.sn;

System.out.println("null");

getch();

}
static ClaseLista Lista=new ClaseLista(); // Declaracion global del objeto Lista

public static void main(String args[]) throws IOException {

int op=0;

Lista.Inicializar(); // Inicializar la Lista Enlazada

do {

clrscr();

System.out.println("\n\n<<< LISTAS ENCADENADAS CON OBJETOS >>>");

System.out.print("\n1.- Altas");

System.out.print("\n2.- Bajas");

System.out.print("\n3.- Recorrido");

System.out.print("\n0.- Salir");

System.out.print("\nOpcion? ---> ");

op=getInt();

switch(op) {

case 1 : Altas(); break;

case 2 : Bajas(); break;

case 3 : Lista.Recorrido(); break;

}while(op!=0);

public static void Bajas() throws IOException {

char dato;

clrscr();

System.out.println("\n<<< BAJAS >>>");


System.out.print("\nAnote el dato a eliminar ---> ");

dato=getChar();

Lista.Eliminar(dato);

public static void Altas() throws IOException {

char dato;

clrscr();

System.out.println("\n\n<<< ALTAS >>>");

System.out.print("\nAnote el dato a insertar ---> ");

dato=getChar();

Lista.Insertar(dato);

public static void clrscr() {

for(int i=0;i<26;i++)

System.out.println(" ");

//Funcion para capturar una cadena desde el teclado

public static String getString() throws IOException {

InputStreamReader isr = new InputStreamReader(System.in);

BufferedReader br = new BufferedReader(isr);

String s = br.readLine();

return s;

// Funcion para capturar un entero desde el teclado

public static int getInt() throws IOException {


String s = getString();

return Integer.parseInt(s);

//Funcion para capturar un caracter desde el teclado

public static char getChar() throws IOException {

String s=getString();

return s.charAt(0);

// Rutina para hacer una pausa

public static void getch() throws IOException {

String s;

System.out.print("\n<<< Oprima cualquier tecla para continuar >>>");

s=getString();

return;

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

Lista simple en java

primero hacer clase Nodo

class Nodo{
int numero;
Nodo sgte;
Nodo(int x){
numero = x;
sgte = null;
}
}

despues hacer clase ListaSimple

class ListaSimple {

private Nodo primero;


private int numNodos;

ListaSimple(){
primero = null;
numNodos = 0;
}

public void insertarNodo (int pos, int n){


Nodo num = new Nodo (n);
if((pos > 0) && (pos <= (numNodos+1))){
if(pos == 1){
if(primero == null)
primero = num;
if(primero != null){
num.sgte = primero;
primero = num;
}
numNodos++;
}else if(pos > 1){
if(pos < (numNodos+1)){
Nodo mov = primero;
int i;
for(i=2; i < pos; i++)
mov = mov.sgte;
num.sgte = mov.sgte;
mov.sgte = num;
}

if(pos == (numNodos+1)){
Nodo mov = primero;
int i;
for(i=2; i < pos; i++)
mov = mov.sgte;
mov.sgte = num;
}
numNodos++;
}
}else
System.out.println("[Insertar]>Nodo no Existe");

}
public void insertarCabezalista (int x){
Nodo aux = new Nodo (x);
if(primero == null)
primero = aux;
else{
aux.sgte = primero;
primero = aux;
}
numNodos++;
}

public void insertarFinalLista (int x){


Nodo nuevo = new Nodo (x);
if (primero == null){
primero = nuevo;
}else{
Nodo aux = primero;
while(aux.sgte != null)
aux = aux.sgte;
aux.sgte = nuevo;
}
numNodos++;
}

public void eliminarNodoP (int pos){


Nodo elim = primero;
if(elim == null) //Cuando la lista esta vacia.
System.out.println("[Eliminar]>Lista Vacia");
else if((pos>0) && (pos<=numNodos)){
if(pos == 1){
if(numNodos == 1){ //Cuando se tiene que eliminar el primer
Nodo(numNodos==1).
primero = null;
numNodos = 0;
}
if(numNodos > 1){ //Cuando se tiene que eliminar el primer
Nodo(numNodos>1).
primero = elim.sgte;
numNodos--;
}
}else if(pos > 1){ //Cuando se tiene que eliminar un Nodo que no es
el Primero.
int i;
for(i=2; (elim != null) && (i < pos); i++)
elim = elim.sgte;
elim.sgte = elim.sgte.sgte;
numNodos--;
}

}else
System.out.println("[Eliminar]>Nodo no Existe");

public void eliminarTodo(){


numNodos = 0;
primero = null;
}

public void eliminarPrimero(){


Nodo prim = primero;

if(numNodos == 1)
primero = null;
else{
primero = prim.sgte;
prim.sgte = prim.sgte.sgte;
}

System.out.println("Primero Nodo borrado con exito");


numNodos--;
}

public void eliminarUltimoNodo(){


if(primero != null)
primero = null;
else{
Nodo aux = primero;
while(aux.sgte.sgte != null)
aux = aux.sgte;
aux.sgte = null;
}
}

public Nodo mostrarUltimoNodo(){


if(primero != null){
Nodo aux = primero;
while(aux.sgte != null)
aux = aux.sgte;
return aux;
}
return null;
}

public Nodo mostrarNodoAnterior(Nodo p){


if(primero == p)
return null;
else{
Nodo aux = primero;
while(aux.sgte != p)
aux = aux.sgte;
return aux;
}
}

public void reemplazarNodo(int pos, int n){


int i;
if((pos0)){
Nodo aux = primero;
for(i=1; (aux != null) && (i < pos); i++)
aux = aux.sgte;
aux.numero = n;
}else
System.out.println("[Reemplazar]>Nodo no Existe");
}

public int contadorNodos (){


return numNodos;
/*
Nodo count = primero;
int i=0;
while(count != null){
count = count.sgte;
i++;
}
return i;
*/
}

public void mostrarLista(){


Nodo aux = primero;
int i=1;
System.out.println("- Mostrar -");
while(aux != null){
System.out.println("Nodo N "+i+": "+aux.numero);
aux=aux.sgte;
i++;
}
}

public void mostrarListaInversa(){


Nodo mov = primero;
int i, j;
//La idea fundamental es que siempre se muestre el ultimo Nodo
//Decrementando el limite en cada ciclo.
System.out.println("- Mostrar Inverso-");
for(i=numNodos; i>0; i--){
for(j=1; j
mov = mov.sgte;
}
System.out.println("Nodo N "+i+": "+mov.numero);
mov = primero;
}

public Nodo retornaNodo (int pos){


Nodo mov = primero;
int i;
if((pos numNodos))
pos = 1;
for(i=1; i
mov = mov.sgte;
return mov;
}

public void eliminarNodoN (Nodo pos){


Nodo elim = primero;
Nodo ult = mostrarUltimoNodo();

if(elim == null)
System.out.println("Lista Vacia");
else if(pos == elim){
primero = primero.sgte;
}else{
while(((pos != elim.sgte) && (elim != null)))
elim = elim.sgte;
if(elim.sgte != null)
elim.sgte = elim.sgte.sgte;
else
System.out.println("Nodo no Existe");
}
numNodos--;
}

public void mostrarInvertidoR (Nodo f){


if(f.sgte != null){
oAsc(f.sgte);
}
System.out.println(f.numero);
}
/*
public void oAsc (Nodo f){
if(f.sgte != null){
if(f.numero > f.sgte.numero)
System.out.println("No ASC");
else
oAsc(f.sgte);
}else
System.out.println("ASC");
}
*/
public boolean oAsc (Nodo f){
if(f.sgte != null){
boolean status;
status = oAsc(f.sgte);
if(f.numero > f.sgte.numero)
return false;
else
return status;
}else
return true;
}

public void insertarNumListaOrd (int n){ // Considerando que una


lista esta ordenada
Nodo num = new Nodo (n); // en forma ASC agregue un
Nodo manteniendo el orden
Nodo i = primero;
while((n > i.numero) && (i.sgte != null))
i = i.sgte;
if(n <= primero.numero){
num.sgte = primero;
primero = num;
numNodos++;
}else if (n <= i.numero){
num.sgte = i;
mostrarNodoAnterior(i).sgte = num;
numNodos++;
}else{
i.sgte = num;
numNodos++;
}

public void eliminarNodosR (){ // Eliminar los nodos que tengan


numeros repetidos
Nodo i, j;
for(i = primero; i != null; i = i.sgte){
for(j = i.sgte; j != null; j = j.sgte){
if(i.numero == j.numero){
mostrarNodoAnterior(j).sgte = j.sgte;
numNodos--;
}
}
}
}

por ultimo esta principal clase EjemploListaSimple

public class EjemploListaSimple {

public static void main(String[] args) {


ListaSimple p = new ListaSimple();

//p.insertarCabezalista(1);
//p.insertarCabezalista(5);
//p.insertarCabezalista(7);
//p.insertarFinalLista(6);
//p.insertarFinalLista(4);
p.insertarNodo(1,2);
p.insertarNodo(2,4);
p.insertarNodo(3,6);
p.insertarNodo(4,8);

System.out.println("Nodos Existentes: "+p.contadorNodos());


p.mostrarLista();

if(p.oAsc(p.retornaNodo(0))){
p.insertarNumListaOrd(1);
p.insertarNumListaOrd(3);
p.insertarNumListaOrd(5);
p.insertarNumListaOrd(7);
p.insertarNumListaOrd(9); //metodo util slo si la lista esta
ordenada ASC
}
//p.eliminarNodo(2);

if(p.oAsc(p.retornaNodo(0)))
System.out.println("ASC");
if(!p.oAsc(p.retornaNodo(0)))
System.out.println("NO ASC");

//p.eliminarNodoN(p.retornaNodo(1));

p.eliminarNodosR();

System.out.println("Nodos Existentes: "+p.contadorNodos());


p.mostrarLista();
p.mostrarListaInversa();
}
}

DESCARGAR ABAJO LOS PROGRAMAS, COLAS, COLA CIRCULAR, PILA, LISTAS, LISTA
ENCADENADA:

Cola lineal
El siguiente programa utiliza estructura de datos, lgica, y manejo de ventanas swing sencillas, usa
la tcnica FIFO, y metodos gets y sets.
Hacer un programa en java que dado cualquir numero de paises se almacenen, y tenga funcion de
agregar pais, eliminar pais, mostrar y salir.
Para que funcione recuerda que solo tienes que correr (Run) la clase principal que contiene
el public static void main(String []args)
Primera clase con metodos get y sets:

class pais{
private String nombre;
private String capital;
private int habitantes;

public pais(String n, String c, int h){


nombre=n;
capital=c;
habitantes=h;
}

public pais(){
}

public void setNombre(String n){


nombre=n;
}

public void setCapital(String c){


capital=c;
}

public void setHabitantes(int h){


habitantes=h;
}

public String getNombre(){


return nombre;
}

public String getCapital(){


return capital;
}

public int getHabitantes(){


return habitantes;
}
}
Segunda clase con la logica y estructura FIFO:

import javax.swing.*;
public class paises {
private pais p[];
private int i;

public void Imp(String Men){


JOptionPane.showMessageDialog(null, Men);
}

public paises(int tamano){


p= new pais[tamano];
i=-1;
}

public boolean free(){


return i==-1;
}

public boolean full(){


return i==p.length-1;
}

// Este mtodo inserta al final de arreglo mientras este no este lleno


public void AgregarPais(pais np){
if(!full()){
i++;
p[i]=np;
}
}

// Este mtodo elimina el ltimo pas insertado


public void EliminaPais(){
if(!free()){
ImpPais(p[i]);
i--;
Imp("Pas eliminado");
}
}

public void ImpPais(pais PI){


Imp("Nombre: "+PI.getNombre()+"\n"+
"Capital: "+PI.getCapital()+"\n"+
"Habitantes: "+PI.getHabitantes());
}

// Imprime los paises del vector


public void Imprime(){
if(free())
Imp("no hay paises capturados");
else{
int R=0;
do
ImpPais(p[R++]);
while(R<=i);
}
}

Tercera clase:

import javax.swing.*;

public class principal {


private static paises p;

public static int LeeInt(String Men){


return Integer.parseInt(JOptionPane.showInputDialog(Men));
}

public static String LeeCad(String Men){


return JOptionPane.showInputDialog(Men);
}

public static void crearVector(){


p=new paises(LeeInt("Dar numero paises que se controlan en el vector"));
}

public static pais capturaRegistro(){


pais regNue=new pais();
regNue.setNombre(LeeCad("Dar Nombre:"));
regNue.setCapital(LeeCad("Dar Capital:"));
regNue.setHabitantes(LeeInt("Dar No. habitantes:"));
return regNue;
}

public static void addPais(){


if(p.full())
JOptionPane.showMessageDialog(null, "Vector Lleno...");
else{
pais a=capturaRegistro();
p.AgregarPais(a);
p.Imp("Registro almacenado...");
}
}

public static void Elimina(){


if(p.free())
p.Imp("Vector vacio...");
else
p.EliminaPais();
}

public static void run(){


int opc;
crearVector();
do{
opc=Opcion();
switch(opc){
case 1: addPais(); break;
case 2: Elimina(); break;
case 3: p.Imprime(); break;
//case 4: p.modificar(); break;
//case 5: p.buscar(); break;
}
}while(opc!=4);
}

public static int Opcion(){


String cad="Menu \n\n";
cad=cad+"1.- Agregar Pais\n";
cad=cad+"2.- Eliminar Pais\n";
cad=cad+"3.- Listar Paises\n";
//cad=cad+"4.- Modificar\n";
//cad=cad+"5.- Buscar\n";
cad=cad+"4.- Salir\n";
return LeeInt(cad);
}
public static void main(String []args){
run();
System.exit(0);
}

DESCARGAR PROGRAMA COLA LINEAL:

Enviar por correo electrnicoEscribe un blogCompartir con TwitterCompartir con


FacebookCompartir en Pinterest

6 comentarios:

1.

Unknown9 de noviembre de 2015, 15:46

hola buenas tardes me podrn ayudar a realizar un programa en donde sea ventas de
equipo de computo que tengas formas de pago con efectivo, tarjeta de credito y
tarjeta de dbito en donde las formas de pago se manejen como polimorfismos

Responder

Respuestas

1.

Kevin Jaret Ramirez Pilo4 de diciembre de 2016, 13:26

yo tengo uno similar nose si te interese

Responder

2.

Annimo10 de junio de 2016, 15:06

hola. alguien que pueda ayudarme y decirme que le hace falta a mi codigo para que
corra? consiste eh hacer un menu de pila el cual muestre Ingresar, borrar y mostrar
los datos de la pila.
este es mi codigo.
package bloque1;

import java.util.Scanner;

public class menu_pila {

public static void main(String[] args) {

int opcion=0;
int dato;
int vect[]= new int [10];
for(int i=0; i>=9;){
Scanner teclado= new Scanner(System.in);
do{

System.out.println("1.Insertar Datos en la pila");


System.out.println("2.Eliminar Datos en la pila");
System.out.println("3.Mostrar Datos de la pila");
System.out.println("4.Salir");
System.out.println("Precione su Opcin");
opcion=teclado.nextInt();

if(opcion==1){

System.out.print("Ingrese un dato:");
dato=teclado.nextInt();
vect[i]=dato;

}else if(opcion==2){

System.out.println("Se elimino un dato:");


dato=teclado.nextInt();
vect[i]=0;

}else if(opcion==3){

dato=teclado.nextInt();
System.out.println("la pila tiene los siguientes datos:"+vect[i]);

}while(opcion!=4);

}
}

También podría gustarte