Colas
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);
}
}
------------------------------------------------------------------------------------------------------------
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
despues hacer clase ListaSimple
por ultimo esta principal clase EjemploListaSimple
DESCARGAR ABAJO LOS PROGRAMAS, COLAS, COLA CIRCULAR, PILA, LISTAS, LISTA ENCADENADA:
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
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 sòlo 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, lógica, y manejo de ventanas swing sencillas, usa la técnica 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 método inserta al final de arreglo mientras este no este lleno
public void AgregarPais(pais np){
if(!full()){
i++;
p[i]=np;
}
}
// Este método elimina el último país insertado
public void EliminaPais(){
if(!free()){
ImpPais(p[i]);
i--;
Imp("País 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:
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 método inserta al final de arreglo mientras este no este lleno
public void AgregarPais(pais np){
if(!full()){
i++;
p[i]=np;
}
}
// Este método elimina el último país insertado
public void EliminaPais(){
if(!free()){
ImpPais(p[i]);
i--;
Imp("País 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:
hola buenas tardes me podrán 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 débito en donde las formas de pago se manejen como polimorfismos
ResponderEliminaryo tengo uno similar nose si te interese
EliminarCompártelo anda quiero verlo
Eliminarhola. 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.
ResponderEliminareste 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 Opción");
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);
}
}
yo creo k estas mal en eso del ciclo for que utilizas en el inicio, y falto declarar el tope de la pila,
ResponderEliminarYo creo le falta los setters y getters
EliminarHola please ayundeme con un programa que tenga nodo, pila y tenga animaciones porfi y que haga push y pop, ya sea una lista de hopital o algun listado que se vea como van saliendo y como van entrando porfis se los agradecere, soy pesima en P.O.O.
ResponderEliminarHOLA ALGUIEN ME PUEDE AYUDAR A DAR DE BAJAS UNA PILA DINAMICA.. ES QUE NO SE COMO EMPEZAR
ResponderEliminarbuen día
ResponderEliminarMe pudieran ayudar con el método reemplazar para el código de pilas
Se los agradecería
como creo un programa que me deje introducir parentesis y que me diga si los que habren son los que cierran
ResponderEliminarHola que tal, tengo un problema con un programa en jdk
ResponderEliminarTengo que realizar una interfaz grafica de usuario con ventana AWT/SWING que solicite un usuario y una contraseña, un mensaje con la hora que ingreso y si alguno de los datos insertados es incorrecto debe mostrare un msj de error
necesito ayuda, necesito un solo programa que tenga pila cola y cola circular intente hacerlo pero no me sale pls ayuda :´v
ResponderEliminar