DESARROLLO N°01

Ejercicio 01: Invertir Cola

Clase Aplicación:
public class Aplicacion01 {
//1. recibe como parámetro una cola
//2. invertirla
Cola cola;
public Aplicacion01(){
cola = new Cola();
}

public static void main(String[] args) {

Aplicacion01 ap;
Cola a;
ap = new Aplicacion01();
a = ap.genCola(10);
ap.invertirCola(a);

public Cola genCola(int num){

int i;
Nodo p;
for(i=0;i<num;i++){
p = new Nodo(i);
cola.insertar(p);
}
return cola;
}

public void invertirCola(Cola cola){

Pila pila;
pila = new Pila();
Nodo q;
System.out.println("Elementos almacenados en la cola ");
cola.mostrar();
while(cola.cab!=null){
q = cola.extraer();
pila.push(q);
}
cola.mostrar();
System.out.println("Elementos almacenados en pila");
pila.mostrar();
while(pila.cab!=null){
q = pila.pop();
cola.insertar(q);
}
pila.mostrar();
System.out.println("Cola con elementos invertidos");
cola.mostrar();
}
}

Ejercicio 02: Agregar Cliente a cola

Clase Aplicación:
public class Aplicacion02 {
// clean code libro de programación - Code
Cola c2;

public Aplicacion02(){
c2 = new Cola();
}

public static void main(String[] args) {

Aplicacion02 ap;
ap = new Aplicacion02();
ap.insertarCola();
}

public void insertarCola(){

Nodo p;
int i;
// Cliente a;
for(i=0; i<10;i++){
if(llegoCliente()){
// a = new Cliente(i);
System.out.println("Llegó un cliente..");
// p = new Nodo(a);
// c2.insertar(p);
}else{
System.out.println("No llegó un cliente...");
}
}
System.out.println("Cola...");
c2.mostrar();
}

public boolean llegoCliente(){

boolean resul;
resul = false;
int a;
a = (int) (Math.random()*(100-1+1)+1);
if(a>=30){
resul = true;
}
return resul;
}
}

Ejercicio 03: Repartir equitativamente

Clase Aplicación:
public class Aplicacion03 {
LCDE lis;

public Aplicacion03() {
lis = new LCDE();
}

// recorrido a lo largo de la LC;

// veluar si p y su anterior y sucesor
// atributo del ndoo cant de tipo int
// si son iguales o con una diferencia unitaria
// no es así - se suman los 3 valores
// se reparte a los 3 (iguales o con una difeencia de uno)
// el recorrido termina cuando, cuando no se realizan mas respartos

public static void main(String[] args) {

Aplicacion03 ap;
ap = new Aplicacion03();
ap.genLCDE(10);
ap.evalacuaciónLCDE();
}

public void genLCDE(int a) {

int j, m;
Nodo1 p;
for (j = 0; j < a; j++) {
m = (int) (Math.random() * (25 - 15 + 1) + 15);
p = new Nodo1(m);
lis.insNodo(p);
}
System.out.println("Lista generada...");
lis.mostrar();
System.out.println("------------------------");
}

public void evalacuaciónLCDE() {

Nodo1 p;
boolean repartiendo;
p = lis.cab.sig.sig; // empieza en 1
do{
repartiendo = false;
do {
if(!cumple(p)){
System.out.println("Falso...");
evaluarNodo1(p);
}
System.out.println("Nueva lista...");
lis.mostrar();
System.out.println("------------------");
p = p.sig;
} while (p!=lis.cab.sig.sig);
}while(repartiendo);
System.out.println("Nueva lista...");
lis.mostrar();
System.out.println("------------------");
}

public boolean cumple(Nodo1 p){

boolean resu;
resu = false;
 if((p.cant == p.ant.cant && p.sig.cant == p.cant) ||(p.cant+1 == p.ant.cant && p.cant+1 ==
p.sig.cant) || (p.cant-1 == p.ant.cant && p.cant-1 == p.sig.cant)){
resu = true;
}
return resu;
}

public void evaluarNodo1(Nodo1 p) {

int a, b, c, suma;
int residuo;
System.out.println("Nodo: " + p.cant);
a = p.ant.cant;
b = p.cant;
c = p.sig.cant;
System.out.println("a: " + a + " b: " + b + " c: " + c);
suma = a + b + c;
residuo = suma % 3;
if (residuo == 0) {
p.ant.cant = (suma / 3);
p.cant = (suma / 3);
p.sig.cant = (suma / 3);
} else {
p.cant = (suma / 3);
if (residuo == 1) {
p.ant.cant = (suma / 3);
p.sig.cant = (suma / 3) + 1;
} else {
p.ant.cant = (suma / 3) + 1;
p.sig.cant = (suma / 3) + 1;
}
}
}

// if(!(iguales(a, b, c) || diferentesenuno(a, b, c))){

// resul = a+b+c;
// if(resul%3==0){
// a = resul/3;
// }
// }
//
public boolean iguales(int a, int b, int c) {
boolean resul;
resul = false;
if (a == b && a == c) {
resul = true;
}
return resul;
}

public boolean diferentesenuno(int a, int b, int c) {

boolean resul;
resul = false;
if ((a == b + 1 && c == b + 1) || (a == b - 1 && c == b - 1)) {
resul = true;
}
return resul;
}
}

DESARROLLO N°02
Ejercicio 01: Avanzar y Retroceder LCDE
Clase Aplicación:

public class Aplicacion01 {

LCDE lista;
public Aplicacion01(){
lista = new LCDE();
}

public static void main(String[] args) {

Aplicacion01 ap;
int num;
num = (int) (Math.random()*(5-(-5)+1)+(-5));
LCDE a;
ap = new Aplicacion01();
a = ap.genLCDE(10);
ap.avanzarRetroceder(num, a);
}
public LCDE genLCDE(int a) {
int j, m;
Nodo p;
for (j = 0; j < a; j++) {
m = (int) (Math.random() * (25 - 15 + 1) + 15);
p = new Nodo(m);
lista.insNodo(p);
}
System.out.println("Lista generada...");
lista.mostrar();
System.out.println("------------------------");
System.out.println("Elimnando la cabecera...");
lista.eliminarNodoLC(lista.cab);
System.out.println("Lista resultante...");
lista.mostrar();
System.out.println("------------------------");
return lista;
}
public int avanzarRetroceder(int a, LCDE lista){
int vueltas;
System.out.println("Cab inicial: "+lista.cab.cant);
if(a>0){ // avanza
vueltas = avanzar(a);
}else{ // retrocede
vueltas = retroceder(a);
}
System.out.println("Cab final: "+lista.cab.cant);
System.out.println("Num de vueltas: "+vueltas);
return vueltas;
}
public int avanzar(int a){
Nodo p;
int cont;
cont = 0;
p = lista.cab;
while (a!=0) {
lista.cab = lista.cab.sig;
a--;
if(p == lista.cab){
cont++;
}
}
 return cont;
}
public int retroceder(int a){
Nodo p;
int cont;
cont = 0;
p = lista.cab;
while (a!=0) {
lista.cab = lista.cab.ant;
a++;
if(p == lista.cab){
cont++;
}
}
return cont;
}
}

Ejercicio 02: lu y ld – mover cab

Clase Aplicación:
public final class Aplicacion02 {
LC lu;
LC ld;
public Aplicacion02(){
lu = genLC(10);
ld = genLC(10);
}

public static void main(String[] args) {

Aplicacion02 ap;
ap = new Aplicacion02();
ap.moverCabezeras(23);
}

public LC genLC(int n){

int i;
LC lis;
lis = new LC();
Nodo p;
for(i=0; i<n;i++){
p = new Nodo(i);
lis.insInicio(p);
}

System.out.println("Lista LU generada");
lis.mostrar();
System.out.println("...............");
System.out.println("Moviendo la cabezera al valor 0");
lis.cab = lis.cab.sig;
System.out.println(lis.cab.cant);
return lis;
}
public void moverCabezeras(int a){
int dig1, dig2;
dig1 = (a/10);
dig2 = (a - (dig1*10));
System.out.println("Se movera: "+dig1 +" "+dig2);
moverLC(dig1, lu);
System.out.println("Fin primera lista");
 moverLC(dig2, ld);
System.out.println("Fin segunda lista");
}

public void moverLC(int a, LC lis){

while(lis.cab.cant!=a){
lis.cab = lis.cab.sig;
}
System.out.println("Como quedaron...");
lis.mostrar();
System.out.println("................");
}
}

Ejercicio 03: convertir a Binario

Clase Aplicación:
public class Aplicacion03 {
public static void main(String[] args) {
Aplicacion03 ap;
ap = new Aplicacion03();
ap.convertirBinario(100);
}
public String convertirBinario(int num){
int a;
Pila pila;
Nodo p;
pila = new Pila();
String texto;
while(num!=0){
a = (num%2);
num = (num/2);
p = new Nodo(a);
pila.push(p);
}
texto = pilaString(pila);
System.out.println("BINARIO: "+texto);
return texto;
}

public String pilaString(Pila pila){

String texto;
texto = "";
Nodo p;
while(pila.cab!=null){
p = pila.pop();
texto = (texto + p.cant);
}
return texto;
}
}

Ejercicio 04: max – arreglo Colas - cab

Clase Aplicación:
public class Aplicacion04 {

public static void main(String[] args) {

 Aplicacion04 ap;
Cola[] colas;
ap = new Aplicacion04();
colas = ap.genArregloColas(5);
ap.mayorCab(colas);
}
public Cola[] genArregloColas(int num){
int j;
Cola[] colas;
colas = new Cola[num];
Cola cola;
Nodo p;
for (j = 0; j < colas.length; j++) {
cola = new Cola();
p = new Nodo(j);
cola.insertar(p);
colas[j] = cola;
}
System.out.println("El arreglo de colas generada...");
mostrar(colas);
return colas;
}
public void mostrar(Cola[] colas){
int i;
System.out.println("Cola...");
for (i = 0; i < colas.length; i++) {
colas[i].mostrar();
}
System.out.println("................");
}

public Nodo mayorCab(Cola[] colas){

int i, j, max;
Nodo p;
p = null;
max = 0;
for(i=0;i<colas.length;i++){
if(colas[i].cab!=null && colas[i].cab.cant >= max ){
max = colas[i].cab.cant;
}
}
System.out.println("Máximo: "+max);
for(j = 0; j<colas.length; j++){
if(colas[j].cab!=null && colas[j].cab.cant == max){
p = colas[j].extraer();
}
}
mostrar(colas);
return p;
}
}

LCDE
public class LCDE1 {
Nodo cab;
public LCDE1(){
cab = null;
}
public void insNodo(Nodo p) {
if (cab != null) {
p.sig = cab.sig;
cab.sig = p;
p.ant = cab;
p.sig.ant = p;
}
cab = p;
}

public void liberarMem() { // debe romper con la circularidad en una LCDE

Nodo p;
p = cab; // p apunta al ultimo
cab = cab.sig; // se actualiza cab, del ultimo al primero
cab.ant = null; // rompemos el enlace del ultimos con el primero
p.sig = null; // rompemmos el enlace del primero con el utlimo
liberarMem(cab); // llamamos al meotod recursivo
cab = null; // despues de hacer el llamado, al cab debe ser nulo
}

public void liberarMem(Nodo p) { // hace la liberación de la memoria

if (p != null) {
liberarMem(p.sig);
p.sig = null;
p.ant = null;
}
}

public void eliminarNodoLC(Nodo p){

if (p != p.ant) { // verifica que no haya un solo elemento
p.ant.sig = p.sig; //
if (p != p.sig) { // no sea el mismo
p.sig.ant = p.ant;
if (cab == p) {
cab = p.ant;
}
}
p.sig = null;
p.ant = null;
}else{ // significa que hay un solo nodo, por ello la cab = null;
cab = null;
}
}
public Nodo avanzar(Nodo p, int pasos){ // p hace referencia al nodo donde se empezará avanzar
int n;
n = 0;
while(n < pasos){ // termina cuando n es igual a pasos dado que no se cumple la condicion
n++;
p = p.sig;
}
return p;
}

public Nodo avanzar1(Nodo pos, int pasos){

int i;
for(i=0;i<pasos;i++){
pos = pos.sig;
}
 return pos;
}
public Nodo retroceder1(Nodo pos, int pasos){
int i;
for(i=0;i<pasos;i++){
pos = pos.ant;
}
return pos;
}

public Nodo retroceder(Nodo p, int pasos){ // p hace referencia al nodo donde se empezerá el
retroceceso
int n;
n = 0;
while(pasos < n){ // si pasos = 0, entonces no ingresa y sale con la posicion de p
n--;
p = p.ant;
}
return p;
}

public void mostrar() {

Nodo p;
if (cab != null) {
p = cab.sig;
do {
p.mostrar();
p = p.sig;
} while (p != cab.sig);
}
}

LC:
public class LC {
Nodo cab;
public LC(){
cab = null;
}
public void insInicio(Nodo p){
if(cab!=null){
p.sig = cab.sig; // ahora p apuntan al Nodo apunt x cab (ultimo nodo)
//
cab.sig = p; // ahora cab.sig apunta a p, es decir la cabeza en este punto,
// ya no debe apuntar al ultimo nodo, sino que debe apuntar
// al que será la nueva cabezera en este caso el Nodo p;
}
cab = p; // ahora cab apunta a p (entonces p, se vuelve el Nodo inicial = cab)
}

// public void insInter(Nodo p){

// Nodo q;
// q = buscarAnterior(p);
// if(q!=null){ // encontro el anterior
// System.out.println("Encontro al anterior");
//
// p.sig = q.sig;
// q.sig = p;
// if(p==cab){
// cab = p;
// System.out.println(cab.dato);
// }else{
// System.out.println("No fue la cabezera");
// }
// }
// }
//
// public void inserInter(Nodo p){
// Nodo q;
// q = buscarAnterior(p);
// if(cab!=null && q!=null){
// System.out.println("Encontró el anterior el anteior es: ");
// System.out.println(q.dato);
//
// }
// }

// recorrido indefinito hasta que suceda un acontesimiento externo.

public void recorrInfinito(){
Nodo p;
p = cab; // si se desea empezar desde el primer elemento: deberia ser: cab.sig
while(p!=p.sig){ // evento externo
p = p.sig;
}
}

// eliminar nodo: funciona para todos los casos

public void elimNodo(Nodo p){
Nodo q;
// se dee verificar que no sea el unico de la lista
// buscar el nodo anterior
// eliminar o romper con los enlaces
if(p!=null && p.sig!=null){
q = buscarAnterior(p);
if(q!=null){ // encontro el aterior
q.sig = p.sig; // asignamos la direcion del nodo 3, al nodo 1
p.sig = null; // rompemos con el enlace del nodo 2 al 3
// rompi con los enlacess necesito verificar si p, era el nodo cabezera, ya que si era así
// necesito actualizar ese valor con el anterior que seria ahora el ultimo nodo agregado que
queda en la lista
if(p== cab){
cab = p;
}
}
}else{ // sino hay un solo nodo en la lista y deseamos eliminar ese nodo entonces.
cab = null; // le damos un valor de nulo a la cabezera
}
p = null;
}

public Nodo buscarAnterior(Nodo q){

Nodo p, ant;
ant = q;
if(cab!=null && q!=null ){ // verificamos que no este vacia la lista con
// verificamos la existencia del nodo p;
// ademas de asegurarnos que
ant = cab;
p = cab.sig; // a p le asignamos la direccion del primer nodo agregado en la lista
 do{
if(p==q){
ant = p;
}
p = p.sig;
}while(p!=cab.sig);
// System.out.println(ant.dato);
} // si la lista esta vacia retorna nulo, si el nodo recibido es nulo, o solo existe un solo nodo en la lista
return ant;
}

// public Nodo buscarNodo(int dato){

// Nodo p;
// p = cab;
// Nodo buscado;
// buscado = null;
// if(cab!=null){ // verficamos que la lista no este vacia
// p = cab.sig; // empezamos el recorrido desde el primer nodo agregado a la lista
// do{
// if(p.dato ==dato){
// buscado = p;
// }
// p = p.sig;
// }while(p!= cab.sig); // miebtras sea diferente a la posicion desde la que empezamo el recorrido
en este caso el nodo
// // el primer nodo agregado a la lista
// }
// return buscado;
// }

public void mostraralter(){

Nodo p;
if(cab!=null){
p = cab;
do{
p.sig.mostrar();
p = p.sig;
}while(p!=cab);
}
}

public void liberarMem(){

Nodo p;
p = cab;
cab = cab.sig;
p.sig = null;
liberarMem(cab);
cab = null;
}
public void liberarMem( Nodo p){
if(p!=null){
liberarMem(p.sig);
p.sig = null;
}
}

public void mostrar(){

Nodo p;
if(cab!=null){
 p = cab.sig;
do{
p.mostrar();
p = p.sig;
}while(p!=cab.sig);
}
}
}

PILA:

public class Pila {

Nodo cab; // ultimo dato insertado es la ciam
public Pila(){
cab = null;
}

// inserta el nuevo nodo en la parte de arriba de la pila

public void push(Nodo p){
if(p!=null){
p.sig = cab; // p paunta a la cima de la pila
cab = p; // actualizamos la cima, es decir el nodo insertado es la nueva cima
}
}
public Nodo pop(){
Nodo p;
p = cab;
if(cab!=null){// por lo menos hay un elemento
cab = cab.sig; // la cabzera apuntara al siguiente
p.sig = null; // rompemos el enlace
}
return p;
}
// pila.mostrar es un recorrdio sore la pila, la pila no se altera.
// extraer y mostrar,
// se extrae y se muestra el contenido de la pila y queda vacia.
// pila actua como un elemento de soporte
// no se emplea, el método mostrar, ya que la pila quedaría intacta.
// pila solo es para el procesamiento de datos y posteior a ello, se vacia.
/*
'0' = 48
'1' = 49
'2' = 50
'3' = 51
'4' = 52
'5' = 53
'6' = 54
'7' = 55
'8' = 56
'9' = 57
*/
public void vaciarPila(){
while(cab!=null){
pop(); // cuando no contenga elementos la pila, p será nulo
}
}

public void mostrar(){

Nodo p;
p = cab;
 System.out.print("[ ");
while(p!=null){
p.mostrar();
p = p.sig;
}
System.out.println("]");
}

COLA:
public class Cola {
Nodo cab;
Nodo ult;

public Cola(){
this.cab = null;
this.ult = null;
}

public void insertar(Nodo p){

if(p!=null){
// si aun no existe ningun elemento:
if(cab == null){
cab = p;
}else{ // ya hay elementos
// el ultimo apunte a p, que será el nuevo elemento ultimo
ult.sig = p;
}
// asigamos la dirección de p a la variable ult de la Cola
ult = p;
}
}

public Nodo extraer(){

Nodo p;
p = cab;
if(cab!=null){
cab = cab.sig; // cab ahora apunta al Nodo sig de cab, es decir Nodo 2
p.sig = null; // rompe enlace de la cab(Nodo 1) con el Nodo 2
// verifica que no haya sido el único elemento, si es así ultimo debe ser puesto en nulo.
if(cab == null){
ult = null;
}
}
return p; // puede ser nulo, en el caso de que cab sea nula: la cola este vacia.
}

public boolean colaVacia(){

boolean resul;
resul = false;
if(cab == null){
resul = true;
}
return resul;
}

public void mostrar(){

Nodo p;
p = cab;
 System.out.print("[ ");
while(p!=null){
p.mostrar();
p = p.sig;
}
System.out.println("]");
}

public void mostrarExtraer(){

Nodo1 p, q;
p = cab;
System.out.print("[");
while(p!=null){
p = p.sig;
q = extraer();
q.mostrar();
}
System.out.println("]");
}

COLAS DE PRIORIDAD:

public class ColaPrioridad1 {

Nodo cab;
Nodo ultSargento;
Nodo ultCabo;
Nodo ultSoldado;
Nodo ultimo4;

public ColaPrioridad1() {
cab = null;
ultSargento = null;
ultCabo = null;
ultSoldado = null;
ultimo4 = null;
}

public Nodo extraer5(){

Nodo p;
p = cab;
if(cab!=null){
cab = cab.sig; // cab ahora apunta al Nodo sig de cab, es decir Nodo 2
p.sig = null; // rompe enlace de la cab(Nodo 1) con el Nodo 2
// verifica que no haya sido el único elemento, si es así ultimo debe ser puesto en nulo.
if(cab == null){
ultSargento = null;
ultCabo = null;
ultSoldado = null;
ultimo4 = null;
}
}
return p; // puede ser nulo, en el caso de que cab sea nula: la cola este vacia.
}

public void insNodo5(Nodo p) {

Nodo q;
 if (p != null) {
if (cab == null) {
cab = p;
actualizarUlt(p);
} else {
q = hayMilitaresTipo(p);
if(q!=null){
enlazarNuevoMilitar(p, q); // enlazar p despues de q
}else{ // No hay elementos del tipo
switch (p.militar.prioridad) {
case 1: // Sargento
enlazarMilitarInicial(p);
break;
case 2: // Cabo
if(ultSargento!=null){
enlazarNuevoMilitar(p, ultSargento);
}else{
enlazarMilitarInicial(p);
}
break;
case 3: // Soldado
if(ultCabo!=null){
enlazarNuevoMilitar(p, ultCabo);
}else if(ultSargento!=null){
enlazarNuevoMilitar(p, ultSargento);
}else{
enlazarMilitarInicial(p);
}
break;
case 4:
if(ultSargento!=null){
enlazarNuevoMilitar(p, ultSargento);
}else if(ultCabo!=null){
enlazarNuevoMilitar(p, ultCabo);
}else if(ultSoldado!=null){
enlazarNuevoMilitar(p, ultSoldado);
}else{
enlazarMilitarInicial(p);
}
break;
}
}
}
}
}

public void enlazarNuevoMilitar(Nodo p, Nodo q){ // q reprsenta el ultimo elmento de la porción de la

Cola
p.sig = q.sig;
q.sig = p;
actualizarUlt(p);
}

public void enlazarMilitarInicial(Nodo p){ // q reprsenta el ultimo elmento de la porción de la Cola

p.sig = cab;
cab = p;
actualizarUlt(p);
}

public void actualizarUlt(Nodo p){

 int nivel;
nivel = p.militar.prioridad;
switch (nivel) {
case 1:
ultSargento = p;
break;
case 2:
ultCabo = p;
break;
case 3:
ultSoldado = p;
break;
case 4:
ultimo4 = p;
break;
}
}

public Nodo hayMilitaresTipo(Nodo p){

Nodo q;
int nivel;
q = null;
nivel = p.militar.prioridad;
switch (nivel) {
case 1:
q = ultSargento;
break;
case 2:
q = ultCabo;
break;
case 3:
q = ultSoldado;
break;
case 4:
q = ultSoldado;
break;
}
return q;
}

public boolean colaVacia(){

boolean resul;
resul = false;
if(cab == null){
resul = true;
}
return resul;
}

// public Nodo extraer(){

// Nodo p;
// p = cab;
// if(cab!=null){
// cab = cab.sig; // cab ahora apunta al Nodo sig de cab, es decir Nodo 2
// p.sig = null; // rompe enlace de la cab(Nodo 1) con el Nodo 2
// // verifica que no haya sido el único elemento, si es así ultimo debe ser puesto en nulo.
// if(cab == null){
// ult = null;
// }
// }
// return p; // puede ser nulo, en el caso de que cab sea nula: la cola este vacia.
// }

public void mostrar(){

Nodo p;
p = cab;
while(p!=null){
p.mostrar();
p = p.sig;
}
}

DESARROLLO DE EJERCICIOS DE LISTAS CIRCULARES

Ejercicio 01: Cabinas
Clase Aplicación:
package Ejercicio011;
public class Aplicacion1 {
LC lc;
public Aplicacion1() {
lc = new LC();
}

public static void main(String[] args) {

Aplicacion1 ap;
ap = new Aplicacion1();
ap.abrirNegocio();
ap.atencionCliente();
ap.cerrarNegocio();
}

public void abrirNegocio() {

generarLista(5); // generar las 15 máquinas.
System.out.println("CABINAS LIBRES:");
lc.mostrar();
}

public void generarLista(int numero) {

Cabina c;
Nodo p;
int i;
for (i = 0; i < numero; i++) {
c = new Cabina(i + 1);
p = new Nodo(c);
lc.insNodo(p);
}
}

public void atencionCliente() {

Nodo pa;
int minAct, minDia;
pa = lc.cab;
minDia = 20;
 for (minAct = 0; minAct < minDia; minAct++) {
cabinaPorDesocupar(pa, minAct);
System.out.println("Minuto Actual: "+ minAct);
if (hayCliente()) {
System.out.println("Llego un cliente...");
if ((minDia-minAct)>=3) {
asignarCabina(pa, minDia, minAct);
}else{
System.out.println("No hay tiempo suficiente");
}
}else{
System.out.println("No llego ningun cliente...");
}
System.out.println("Actualizando Cabinas...");
lc.mostrar();
}
}

public boolean hayCliente() {

int total;
boolean llegada;
llegada = false;
total = (int) (Math.random()*((50)-(1)+1)+(1));
if(total<=40){
llegada = true;
}
return llegada;
}

public void asignarCabina(Nodo pa, int minDia, int minAct) {

Nodo q;
Cliente cl;
System.out.println("Buscando cabina disponible...");
q = cabinaLibre(pa);
if (q != null) {
System.out.println("Cabina disponible: "+ q.cabina.numero);
System.out.println("Asignando maquina...");
cl = genCliente(minDia, minAct);
q.cabina.asignarCabinaCliente(minAct, cl);
} else {
System.out.println("No hay cabina libre...");
}
}

public Cliente genCliente(int minDia, int minAct){

Cliente client;
client = new Cliente();
client.asignarCliente(minDia, minAct);
return client;
}

public Nodo cabinaLibre(Nodo pa) {

Nodo q;
Nodo res;
q = pa.sig;
 res = null;
do {
if (!q.cabina.isEstado()) {
res = q;
}
q = q.sig;
} while (pa.sig != q && res==null);
return res;
}

public void cabinaPorDesocupar(Nodo pa, int minAct) {

Nodo p;
Cabina c;
p = pa.sig;
do {
c = p.cabina;
c.desocuparCabina(minAct);
p = p.sig;
} while (p != pa.sig);
}

public void cerrarNegocio() {

double valorMin;
valorMin = (2.0 / 60);
double d;
d = calcularGanancia(valorMin);
System.out.println("RESULTADOS: ");
System.out.println("Ingreso de dinero: $" + d);
}
public double calcularGanancia(double valMim){
double d;
int con;
Nodo p;
Cabina c;
d = 0;
con = 0;
p = lc.cab;
do {
c = p.cabina;
con = con + c.getMinAcumulados();
d = d + c.gananciCabina(valMim);
p = p.sig;
} while (p != lc.cab);
System.out.println("Tiempo total: " + con);
return d;
}
}

Clase Cabina:
package Ejercicio011;
public class Cabina {
int numero;
Cliente cliente;
int minPedidos;
int minInicial;
int minAcumulados;
boolean estado;

public Cabina(int numero) {

this.numero = numero;
this.cliente = null;
this.minPedidos = 0;
this.minInicial = 0;
this.minAcumulados = 0;
this.estado = false;
}

public void desocuparCabina(int minAct){

if (minAct >= (minPedidos + minInicial)) { // significa que ya se le acabo el tiempo al
cliente en esa maquina / desocupa maq
estado = false;
minAcumulados = minAcumulados + minPedidos;
minInicial = 0;
minPedidos = 0;
}
}

public void asignarCabinaCliente(int minAct, Cliente clien) {// num aleatorio que representa
el tiempo que se le va asignar a la cabina
estado = true;
minInicial = minAct;
minPedidos = clien.getTiempo();
}

public double gananciCabina(double precio){

double ganancia;
ganancia = (precio*minAcumulados);
return ganancia;
}
public int getMinAcumulados() {
return minAcumulados;
}
public void mostrar() {
String OD;
OD = "Desocupada";
System.out.print("Nro de Cabina: " + this.numero+ " | ");
System.out.print("Tiempo de uso: " + this.minPedidos+ " | ");
System.out.print("Minuto Inicial: " + this.minInicial+ " | ");
System.out.print("Minutos Acumulados: " + this.minAcumulados+ " | ");
if (estado) {
OD = "Ocupada";
}
System.out.print("Estado: " + OD);
System.out.println(" ");
 }
}

Clase Cliente:
package Ejercicio011;
public class Cliente {
int tiempo;
boolean estado;
public Cliente() {
this.estado = false;
this.tiempo = 0;
}

public void asignarCliente(int minDia, int minAct){

int time;
time = tiempoCliente(minDia, minAct);
estado = true;
tiempo = time;
}

public int tiempoCliente(int minDia, int minAct) {

int[] tiempos;
int res;
int indice;
tiempos = new int[]{5, 3, 4, 6, 9, 12};
res = 0;
do {
indice = (int) (Math.random()*((tiempos.length - 1)-(0)+1)+(0));
res = tiempos[indice];
} while (res > (minDia - minAct));
return res;
}

public void mostrar(){

System.out.println("Tiempo del Cliente: "+this.tiempo);
System.out.println("Estado: "+this.estado);
}

Clase LC / Clase Nodo

Ejercicio 02: Cerradura

Clase Aplicación:
package Ejercicio0311;
import java.util.Scanner;
// Tareas:
// 1. establecer clave
// 2. ocultar clave
// 3. adivinar clave
public final class Aplicacion_1 {
Cerradura cerrd;

public Aplicacion_1() {
genCerradura(); // incializa la cerradura
}

public static void main(String[] args) {

Aplicacion_1 ap; //instanciar ap coomo un objeto de tipo aplicacion
Cliente c;
ap = new Aplicacion_1();
c = ap.establecerClave(); // instancia ap
ap.ocultarClave(c);
ap.adivinarClave();
// entonces antes de pasar a explicar los diferentes métodos empleados,
// explicaremos las clases que se estan usando.
}

public Cliente establecerClave(){

int i;
Cliente client;
Nodo pos;
client = generarCliente();
System.out.println("Valores actuales que se estan mostrando...");
client.cerrd.mostrarvaloresCerradura(); // muestra las cab de las list´s de la cerradura
System.out.println("------------------------");
for(i=0; i<3;i++){
pos = interactuarCerradura(i);
pos.cas.establecerClave();
}
System.out.println("SE HA ESTABLECIDO LA CLAVE...");
client.cerrd.mostrarClave();
return client;
}

public Nodo interactuarCerradura(int i){ // i es el número de la lista con la que vamos a

interactuar
Tambor tamb;
int valor;
Nodo pos;
tamb = cerrd.tamborARecorrer(i+1);
pos = tamb.obtenerCabezera();
System.out.println("Estableciendo Digito N°: " + (i + 1) + " de la clave...");
do {
valor = ingresarValor(0, 9, "¿Cuántas posiciones desea girar? ");
pos = girarTambores(pos, valor);
cerrd.moverCabezera(pos, (i+1));
System.out.println("Casilla: ");
pos.cas.mostrarValor();
} while (decSeguir("Establecer digito como clave?: (si=1) / (No=0)") == false);
return pos;
}

public void ocultarClave(Cliente client){

int i, num;
 Tambor tamb;
Nodo p;
System.out.println("OCULTANDO LA CLAVE...");
for(i=0; i<3;i++){
num = (int) (Math.random()*(9-0+1)+0);
tamb = cerrd.tamborARecorrer(i+1);
p = girarTambores(tamb.obtenerCabezera(), num); // me devuelve el valor la posicion de
lo seran las nuevas cabezeras
// lista.cab = p; // establezco el valor de las nuevas cabezeras.
client.cerrd.moverCabezera(p, (i+1)); // corre el valor de la cabezera de la cerradura (
valores que se muestran)
}
System.out.println("--- LA CLAVE HA SIDO OCULTADA ---");
client.cerrd.mostrarvaloresCerradura();
System.out.println("---------------------------------------");
}

public void adivinarClave(){

int n, aciertos;
boolean adivinó;
n = 0;
adivinó = false;
Cliente client;
client = generarCliente();
System.out.println("Adivinando clave de cerradura....");
do{
n++;
aciertos = adivinarDigitos();
if(aciertos == 3){
System.out.println("FELICIDADES LA CLAVE HA SIDO ADIVINADA ");
adivinó = true;
}else{
System.out.println("No logró adivinar la clave...");
client.cerrd.mostrarvaloresCerradura();
System.out.println("Intentos restantes: "+(3-n));
}
}while(n<3 && adivinó==false);
if(adivinó == false){
System.out.println("Ya no tiene mas intentos...");
}
}

public int adivinarDigitos(){

int cont, i; // representa el número de digitos adivinados
cont = 0;
Nodo pos;
boolean resul;
for (i = 0; i < 3; i++) {
pos = interactuarCerradura(i);
pos.cas.mostrarValor();
System.out.println(" ");
resul = pos.cas.verificarCasilla();
if (resul) {
cont = (cont + 1);
}
 }
return cont;
}
// cab en un primer momento es nulo
public void genCerradura(){
Tambor tamb1, tamb2, tamb3;
tamb1 = genTambor();
tamb2 = genTambor();
tamb3 = genTambor();
cerrd = new Cerradura(tamb1, tamb2, tamb3);
}

public Tambor genTambor(){

LC lista;
Tambor tamb;
lista = genLC(10);
tamb = new Tambor(lista); // se crea un objeto de la clase atmor, se activa su constructor
inicializando sus atributos
return tamb;
}

public Cliente generarCliente(){

String usuario;
Cliente client;
usuario = ingresoString("Nombre de Usuario: ");
client = new Cliente(usuario, cerrd);
return client;
}

public Nodo girarTambores(Nodo p, int n){ // anteriormente ya ha sido

parametrizado(permitia 0 - 9)
Nodo q;
q = p;
if(n>0){
do{
n--;
q = q.sig;
}while(q!=p && n>0);
}
return q;
}

public LC genLC(int n) {
LC lista;
int i;
Nodo p;
Casilla cas;
lista = new LC();
for (i = 0; i < n; i++) {
cas = new Casilla(i);
p = new Nodo(cas);
lista.insInicio(p);
}
return lista;
}
 public String ingresoString(String text){
Scanner scanner;
String dato;
scanner = new Scanner(System.in);
System.out.println(text);
dato = scanner.nextLine();
return dato;
}

public int ingresarValor(int a, int b, String c){

Scanner scanner;
scanner = new Scanner(System.in);
int n;
do{
System.out.println(c);
n = scanner.nextInt();
} while(n<a || n>b);
return n;
}

public boolean decSeguir(String mensaje) {

Scanner scanner;
scanner = new Scanner(System.in);
int n;
boolean seguir;
seguir = false;
do {
System.out.println(mensaje);
n = scanner.nextInt();
if (n == 1) {
seguir = true;
}
} while (n!= 1 && n!= 0);
return seguir;
}
}

Clase Cerradura:
package Ejercicio0311;

public class Cerradura {

Tambor tamb1, tamb2, tamb3;

public Cerradura(Tambor tamb1, Tambor tamb2, Tambor tamb3) {

this.tamb1 = tamb1;
this.tamb2 = tamb2;
this.tamb3 = tamb3;
}

public void mostrar(){

System.out.println("Tambor 1");
tamb1.mostrar();
System.out.println("Tambor 2");
 tamb2.mostrar();
System.out.println("Tambor 3");
tamb3.mostrar();
}

public Tambor tamborARecorrer(int i){

Tambor tamb;
if(i==1){
tamb = tamb1;
}else if(i==2){
tamb = tamb2;
}else{
tamb = tamb3;
}
return tamb;
}

public void moverCabezera(Nodo p, int numLista){

if(numLista==1){
tamb1.establecerCabezera(p);
}else if(numLista==2){
tamb2.establecerCabezera(p);
}else{
tamb3.establecerCabezera(p);
}
}

public void mostrarClave(){

int i;
Nodo p;
Nodo q;
Tambor tamb;
System.out.print("Clave: [");
for(i=0;i<3;i++){
tamb = tamborARecorrer(i+1);
p = tamb.obtenerCabezera();
q = p.sig; // empieza en el primer elemento agregado a la lista
do{
if(q.cas.isEstado()){
System.out.print(q.cas.getValor()+" | ");
}
q = q.sig;
}while(q!=p.sig);
}
System.out.println("]");
}

public void mostrarvaloresCerradura(){

Nodo p1, p2, p3;
p1 = tamb1.obtenerCabezera();
p2 = tamb2.obtenerCabezera();
p3 = tamb3.obtenerCabezera();
System.out.println("Cerradura: ["+p1.cas.getValor() + " | "+p2.cas.getValor() + " |
"+p3.cas.getValor() +"]");
}
}

Clase Casilla:
package Ejercicio0311;
public class Casilla {
int valor;
boolean estado;
public Casilla(int valor) {
this.valor = valor;
this.estado = false;
}

public void establecerClave(){

estado = true;
}

public boolean verificarCasilla(){

boolean resul;
resul = false;
if(estado == true){
resul = true;
}
return resul;
}

public void mostrarValor(){

System.out.print("[ Vlr: "+this.valor + " ]");
System.out.println(" ");
}
public void mostrar(){
System.out.print("Vlr: "+this.valor + " | ");
System.out.print("Estd: "+this.estado);
System.out.println(" ");
}

Clase Casilla:
public class Cliente {
String nombre;
Cerradura cerrd;

public Cliente(String nombre, Cerradura cerrd) {

this.nombre = nombre;
this.cerrd = cerrd;
}
public void mostrar(){
System.out.println("Nombre: "+this.nombre);
cerrd.mostrarvaloresCerradura();
}

Clase Tambor / LC / Nodo

LC lis;
 public Tambor(LC lis) {
this.lis = lis;
}
public Nodo obtenerCabezera(){
Nodo p; p = lis.cab; return p;}

public void establecerCabezera(Nodo p){

lis.cab = p;}
Public void mostrar(){…
DESARROLLO DE EJERCICIOS DE LISTAS CIRCULARES D.E.
Ejercicio 01: Juego Casillas
Clase Aplicación:
public class Aplicacion {
LCDE lis;
Jugador jugador;

public Aplicacion() {
lis = new LCDE();
jugador = new Jugador();
}

public static void main(String[] args) {

Aplicacion ap;
int n;
ap = new Aplicacion();
n = ap.iniciarJuego(); //
ap.Jugar(n);// al cual se le envia como argumento n; y que simila el proceso de jugar
ap.mostrarResultados(); //
ap.liberarMemoria();
}

public int iniciarJuego() {

int n;
n = (int) (Math.random() * (20 - 10 + 1) + 10); // (int) para truncar cualquier parte decimal
//del resultado y convertirlo en un número entero.
genLCDE(n);
System.out.println("Lista LCDE generada...");
lis.mostrar();
return n;
}

public void genLCDE(int n) {

int i, valor;
Nodo p;
char letra;
Casillero cas;
for (i = 0; i < n; i++) {
valor = (int) (Math.random() * (10 - 5 + 1) + 5);
letra = genCharAleatorio();
cas = new Casillero(valor, letra);
p = new Nodo(cas);
lis.insNodo(p);
}
}

public char genCharAleatorio(){

String opciones;
int indice;
char caracter;
opciones = "ARTGP";
indice = (int) (Math.random() * ((opciones.length() -1) - 0 + 1) + 0);
caracter = opciones.charAt(indice);
return caracter;
}

public void Jugar(int n){

int saltos;
boolean salida;
Nodo posicion;
posicion = lis.cab.sig;
salida = false;
do{
saltos = ingresarValor(n, (3*n), "N° Saltos ("+n + " a "+(3*n)+")");
posicion = lis.recorrerLCDE(posicion, saltos);
posicion = evaluarNodo(posicion);
if(posicion ==null){
salida = true;
}
System.out.println("Puntos restantes: " + jugador.getPuntos());
}while(salida != true && jugador.verificarPuntos());
System.out.println("Fin del juego");
}

public int ingresarValor(int a, int b, String c){

Scanner scanner;
scanner = new Scanner(System.in);
int n;
do{
System.out.println(c);
n = scanner.nextInt();
} while(n<a || n>b);
return n;
}

public Nodo evaluarNodo(Nodo p) {

Nodo pos;
char letra;
int n;
n = p.cas.getValor();
letra = p.cas.getLetra();
pos = p;
if(letra == 'A'){
pos = lis.recorrerLCDE(p, n);
}else if(letra == 'R'){
pos = lis.recorrerLCDE(p, -n);
}else if(letra == 'T'){
pos = null;
}else if(letra == 'G'){
 jugador.actualizarPuntos(n);
}else{ // queda la opcion p
jugador.actualizarPuntos(-n);
}
return pos;
}

public void mostrarResultados(){

System.out.println("Resultado Final: ");
jugador.mostar();
}

public void liberarMemoria(){

lis.liberarMem();
}
}

Clase Casillero:
public class Casillero {
int valor;
char letra;

public Casillero( int valor, char letra) {

this.valor = valor;
this.letra = letra;
}
Public void mostrar();

Clase Jugador:
public class Jugador {
int puntos;

public Jugador() {
this.puntos = 50;
}

public int getPuntos() {

return puntos;
}

public void actualizarPuntos(int n) {

puntos = (puntos+n);
}

public boolean verificarPuntos() {

boolean seguir;
seguir = true;
if (puntos <= 0) {
seguir = false;
}
return seguir;
}
Clase LC/ Clase Nodo: Casillero, sig, ant:

Ejercicio 02: Eliminar Nodos de un LCDE

Clase Aplicación:
public class Aplicacion {
LCDE1 lis;
public Aplicacion() {
lis = new LCDE1();
}

public static void main(String[] args) {

Aplicacion ap;
ap = new Aplicacion();
ap.prueba();
}
public void prueba(){
this.genLCDE(20);
lis.mostrar();
int n;
Nodo pos;
pos = lis.cab.sig; //empezamos en el 1

n = ingresarValor(1, (10), "N° Saltos)");

pos = lis.avanzar1(pos, n); //emplea un for
pos.mostrar(); //mostramos el Nodo
lis.eliminarNodoLC(pos); // eliminamos el nodo pos
lis.mostrar(); //mostramos la lista final
}
public void genLCDE(int n) {
int i, valor;
Nodo p;
for (i = 0; i < n; i++) {
valor = (int) (Math.random() * (10 - 5 + 1) + 5);
p = new Nodo(valor);
lis.insNodo(p);
}
}
public int ingresarValor(int a, int b, String c){
Scanner scanner;
scanner = new Scanner(System.in);
int n;
do{
System.out.println(c);
n = scanner.nextInt();
} while(n<a || n>b);
return n;
}

}
//Método para eliminar un Nodo de una LCDE:
public void eliminarNodoLC(Nodo p){
if (p != p.ant) { // verifica que no haya un solo elemento
p.ant.sig = p.sig; //
if (p != p.sig) { // no sea el mismo
p.sig.ant = p.ant;
if (cab == p) {
cab = p.ant;
 }
}
p.sig = null;
p.ant = null;
}else{ // significa que hay un solo nodo, por ello la cab = null;
cab = null;
}
}

DESARROLLO DE EJERCICIOS DE PILAS

Ejercicio 01: Sucesión de Fibonacci invertida
Clase Aplicación:
public class Aplicacion {
Pila pila;

public Aplicacion(){
pila = new Pila();
}
public static void main(String[] args) {
Aplicacion ap;
int n;
ap = new Aplicacion();
n = ap.ingresarValor(5, 25, "Ingrese el valor de n (5 a 25)");
ap.genPila1(n);
ap.mostrarResultados();
}

public void genPila1(int n) {

int i,a, b, c;
Nodo p;
b = 1;
c = 0;
for (i = 0; i < n; i++) {
a = b;
b = c;
c = a+b;
p = new Nodo(c);
pila.push(p);
}
}

public int ingresarValor(int a, int b, String c){

}
public void mostrarResultados(){
pila.mostrar();
}

Ejercicio 02: Cadena Invertida

Clase Aplicación:
public class Aplicacion {
Pila pila;

public Aplicacion(){
pila = new Pila();
}
public static void main(String[] args) {
Aplicacion ap;
String texto;
ap = new Aplicacion();
texto = ap.solicitarCadena("Ingrese la cadena de texto");
ap.apilarCaracteres(texto);
ap.mostrarCadenaInvertida();

}
public String solicitarCadena(String text){
Scanner scanner;
String dato;
scanner = new Scanner(System.in);
System.out.println(text);
dato = scanner.nextLine();
return dato;
}

public void apilarCaracteres(String texto){

int i;
Nodo p;
char letra;
for(i=0;i<texto.length(); i++){
letra = texto.charAt(i);
p = new Nodo(letra);
pila.push(p);
}
}

public void mostrarCadenaInvertida(){

System.out.println("Cadena invertida: ");
pila.extraeryMostrar();
}

Ejercicio 03: Resolver Notación en expresión posfija

Clase Aplicación:
public class Aplicacion {
Pila pila;

public Aplicacion(){
pila = new Pila();
}

public static void main(String[] args) {

Aplicacion ap;
 String texto;
ap = new Aplicacion();
texto = ap.solicitarCadena("Ingrese la expresión a resolver: ");
ap.procesarCadena(texto);
ap.mostrarResultados();

}
// 78*67/-48/3*+1-14/+
public String solicitarCadena(String text){
Scanner scanner;
String dato;
scanner = new Scanner(System.in);
System.out.println(text);
dato = scanner.nextLine();
return dato;
}

public void procesarCadena(String cadena){

int i;
boolean resul;
char caracter;
for(i=0; i<cadena.length();i++){
caracter = cadena.charAt(i);
System.out.println("carcater: "+caracter);
resul = verificarNum(caracter);
if(resul){ // caracter es un número
apilarValor(caracter);
}else{ // caracter es un operador
operarValores(caracter);
}
}

public void apilarValor(char caracter){

Nodo p;
float num;
num = caracter - '0'; //conversion por tabla ASCII 0=48
p = new Nodo(num);
pila.push(p);
pila.mostrar();
System.out.println("----------------");
}

public void operarValores(char caracter){

Nodo desapilado, p;
float a, b, c;
desapilado = pila.pop();
b = desapilado.getNum();
desapilado = pila.pop();
a = desapilado.getNum();
c = efectuarValores(a, b, caracter);
p = new Nodo(c);
pila.push(p);
pila.mostrar();
 System.out.println("------------------");
}

public float efectuarValores(float a, float b, char operador){

float c;
c = 0;
switch(operador){
case '+':
c = a + b;
break;
case '-':
c = a - b;
break;
case '*':
c = a*b;
break;
case '/':
c = a/b;
break;
}
return c;
}

public boolean verificarNum(char c){

boolean resul;
resul = false;
if(c >= '0' && c <= '9'){
resul = true;
}
return resul;
}

public void mostrarResultados(){

Nodo p;
p = pila.pop();
System.out.println("Resultado de la expresión: ");
p.mostrar();
System.out.println(" ");
}

Clase Nodo/Clase Pila

DESARROLLO DE EJERCICIOS DE COLAS

Ejercicio 01 y 02: Oficina de atención – 8hrs – remanente – 2 ventanilla
Clase Aplicación:

public final class Aplicacion1 {

LC lisVent;
Cola cola;
 public Aplicacion1(){
lisVent = new LC();
}

public static void main(String[] args) {

Aplicacion1 ap;
ap = new Aplicacion1();
ap.abrirOficina();
ap.atenderPúblico();
ap.cerrarOficina();
}

public void abrirOficina(){

cola = new Cola();
generandoVentanillas(2);
}

public void generandoVentanillas(int numero) {

Ventanilla c;
Nodo3 p;
int i;
for (i = 0; i < numero; i++) {
c = new Ventanilla((i+1));
p = new Nodo3(c);
lisVent.insNodo(p);
}
}

public void atenderPúblico(){

Nodo3 pa;
pa = lisVent.cab; // inicializo pa; sería la posición de la ventanilla 1
atendiendoNormal(pa); // le indicamos donde debe empezar atender
atenderRemanente(pa);// atiendo los que restan, teniendo en cuenta la hora
}

public void atendiendoNormal(Nodo3 pa){

int i;
for (i = 0; i< 480; i++) {
if (llegóCliente()) {
añadirClienteCola();
}
atenderCola(pa);
lisVent.actualizarTiemposVentanillas(pa);
}
}

public void atenderCola(Nodo3 pa){

Nodo3 q;
q = ventanillaLibre(pa); // busca la ventanilla libre
if (!cola.colaVacia() && q!=null) {// si q != null entonces quiere decir que hay al menos 1
ventanilla libe
Nodo p;
Cliente a;
p = cola.extraer();
 a = p.getCliente();
q.ventanilla.asignarVentanillaCliente(a);
}
}

public Nodo3 ventanillaLibre(Nodo3 pa) { // se le indica de donde debe empezar a buscar

duvuelve la ventanilla que esta libre
Nodo3 q;
Nodo3 res;
q = pa.sig;
res = null;
do {
if (q.ventanilla.isLibre()) {
res = q;
}
q = q.sig;
} while (pa.sig != q && res==null);
return res;
}

public void añadirClienteCola(){

Cliente a;
Nodo p;
a = genCliente();
p = new Nodo(a);
cola.insertar(p);
}

public Cliente genCliente(){

Cliente client;
int tAtencion;
tAtencion = (int) (Math.random()*(25-5+1)+5);
client = new Cliente(tAtencion);
return client;
}

public boolean llegóCliente() {

int total;
boolean llegada;
llegada = false;
total = (int) (Math.random()*((100)-(1)+1)+(1));
if(total<=35){
llegada = true;
}
return llegada;
}

public void atenderRemanente( Nodo3 pa){

while(!cola.colaVacia()){// mientras que la cola tenga clientes
lisVent.actualizarTiemposVentanillas(pa); // puede que despues de actualizar el tiempo,
se haya retirado el utlimo cliente
atenderCola(pa);
}
}
 public void cerrarOficina(){
System.out.println("---------- Resumen de Atención de Ventanillas ----------");
lisVent.mostrar();
System.out.println("-----------------------------------------------");
}

Clase Ventanilla:

public class Ventanilla {

Cliente cliente; int numVent; boolean libre;
int minInicial, minVentanilla, tOcupacion, numClientsAtend;
Cola1 clientesHora; // no es estático
public void setLibre(boolean libre) {
this.libre = libre;
}
public Ventanilla(int num){ // extraer de la cola y enviar a la ventanilla
this.numVent = num;
this.libre = true;
this.minInicial = 0;
this.minVentanilla = 0;
this.tOcupacion = 0;
this.numClientsAtend = 0;
this.clientesHora = new Cola1();
}

public void actualizarMinActual(){

this.minVentanilla = minVentanilla +1;
}

public boolean isLibre() {

return libre;
}

public void actualizarVentanilla(){

// minVentanilla = (mindelDía+1) - minInicial; // actualiza el tiempo
minVentanilla = minVentanilla +1;
liberarVentanilla(); // verifica si ya debe desocuparse la ventanilla
clientesPorHora();
}

public void liberarVentanilla(){ // antes de atender cliente

if(cliente!=null && cliente.finalizóCliente(minVentanilla)){
numClientsAtend = numClientsAtend +1; // incrementar clientes atendidos
actualizarUsoTota(cliente.gettAtencion()); // actualiza tiempo total de atención
cliente = null;
libre = true;
 }
}

public void asignarVentanillaCliente(Cliente a){

cliente = a;
a.establecerCliente(minVentanilla);
libre = false;// indicamos que la ventanilla esta ocupada
}

public void actualizarUsoTota(int tiempo){

tOcupacion = tOcupacion + tiempo;
}

public int tiempoDesocupado(){

int tiempo;
tiempo = minVentanilla - tOcupacion;
return tiempo;
}

public int horas(){

int horas;
horas = (int) minVentanilla / 60;
return horas;
}

public String horafinal(){

int horaInicial, dias;
String finalAtención;
dias = 0;
horaInicial = 0; // es 8
int horas;
int minutos;
horas = horas();
minutos = minVentanilla - (horas*60);
horas = horaInicial + horas;
if(horas>=24){
dias = (int) horas/24;
horas = horas - (dias*24);
}
finalAtención = dias + " días después, a las: "+horas + " horas con: "+minutos +" minutos";
return finalAtención;
}

public float promedioAtencion(){

float prom;
if(numClientsAtend!=0){
prom = (float) tOcupacion/numClientsAtend;
}else{
prom = 0;
}
return prom;
 }

public int hrsTranscurridas(){

int hTranscurridas;
if(minVentanilla % 60 == 0){
hTranscurridas = minVentanilla /60;
}else{
hTranscurridas = 0;
}
return hTranscurridas;
}

public void clientesPorHora(){

Nodo1 atendidosH;
int numAtendidos, numfinal;
numAtendidos = 0;
numfinal = 0;
Nodo1 p;
if(hrsTranscurridas()>0){ // pasó al menos una hora;
p = clientesHora.cab;
if(p==null){ // es la primera hora
numfinal = numClientsAtend;
}
while(p!=null){ // ya pasaron algunas horas
numAtendidos = numAtendidos + p.clientes; // atendidos horas antes
numfinal = numClientsAtend - numAtendidos;
p = p.sig;
}
atendidosH = new Nodo1(hrsTranscurridas(), numfinal);
clientesHora.insertar(atendidosH);
}
}

public void mostrar(){

System.out.println("Ventanilla N°: "+this.numVent);
System.out.println("- Hora de finalización: ");
System.out.println(" "+ horafinal());
System.out.println("- Tiempo total de ocupación: "+this.tOcupacion + " minutos");
System.out.println("- Tiempo de oocio: "+tiempoDesocupado()+" minutos.");
System.out.println("- Clientes atentidos: "+numClientsAtend);
System.out.println("- Clientea atendidos por hora: ");
clientesHora.mostrarExtraer();
System.out.println("- Promedio de atención: "+promedioAtencion()+" minutos por
persona.");
System.out.println("----------------------------");
}
}

Clase Cliente:
public class Cliente {
boolean atendiendo;
 int minAtencion;
int tAtencion;
int hFinalización;

public Cliente(int tAtencion){

this.atendiendo = false;
this.minAtencion = 0;
this.tAtencion = tAtencion;
this.hFinalización = 0;
}

public boolean finalizóCliente(int minActual) {

boolean resul;
resul = false;
if(hFinalización == minActual){ // finalizo
resul = true;
atendiendo = false; //ya fue atentido
}
return resul;
}

public void establecerCliente(int minActual){

int finaliza;
finaliza = minActual + tAtencion;
atendiendo = true;
hFinalización = finaliza;
minAtencion = minActual;
}

public void mostrar(){

String a;
a = "En espera";
if(atendiendo){
a = "Atendiendo";
}
System.out.println("-------------Cliente------------");
System.out.println("Inicio de atención| min: "+this.minAtencion);
System.out.println("Fin de atención| min: "+this.hFinalización);
System.out.println("Tiempo de atención:" +this.tAtencion);
System.out.println("Estado: "+a);
}

}
Clase LC: agregar:
public void actualizarTiemposVentanillas(Nodo3 pa) {
Nodo3 p;
Ventanilla c;
p = pa.sig;
do {
c = p.ventanilla;
c.actualizarVentanilla();
 p = p.sig;
} while (p != pa.sig);
}

public int clientesTotales(){

int clientestotales;
clientestotales = 0;
Nodo3 p;
Ventanilla c;
p = cab; // elemento ultimo
if (p.sig != null) { // elemento 1
do {
c = p.ventanilla;//el dato que se recibe es de ese tipo}
clientestotales = clientestotales + c.numClientsAtend;
p = p.sig;
} while (p != cab);
}
return clientestotales;
}
Clase Nodo: cliente, sig/Nodo1: (int) clientes, hor, sig /Nodo3: Ventanilla, sig
Clase Cola: Nodo / Cola1: Nodo1

DESARROLLO DE EJERCICIOS DE COLAS DE PRIORIDAD

Ejercicio 01: Peluquería Ejercito
Clase Aplicación:
public class Aplicacion {
Ventanilla Vent;
ColaPrioridad cola;
Tropa tropa;
public Aplicacion(){
Vent = new Ventanilla(1);
// tropa = new Tropa(8, 8, 8);
 }

public static void main(String[] args) {

Aplicacion ap;
ap = new Aplicacion();
// ap.prueba(30);
ap.abrirPeluqueria();
ap.atenderMilitares();
ap.cerrarPeluqueria();
}

public void prueba(int n){

cola = new ColaPrioridad();
int i;
Militar c;
Nodo p;
for (i = 0; i < n; i++) {
c = genMilitar();
p = new Nodo(c);
cola.insertarNodo(p);
}
System.out.println("------------ COLA------------");
cola.mostrar();
System.out.println("..............................");
}

public void abrirPeluqueria(){

cola = new ColaPrioridad();
tropa = new Tropa(800, 60, 20);
}

public void atenderMilitares(){

atendiendoNormal();
}

public void atendiendoNormal(){

int i;
i = 0;
while(tropa.totalMilitares()>0 && i<480){
if (llegóMilitar()) {
añadirMilitarCola();
}
atenderCola();
Vent.actualizarVentanilla();
i++;
}
}

public void atenderCola(){

if (!cola.colaVacia() && Vent.isLibre()) {// si q != null entonces quiere decir que hay al
menos 1 ventanilla libe
Nodo p;
Militar a;
p = cola.extraerNodo();
a = p.militar;
 Vent.asignarPeluqueriaMilitar(a);
}
}

public void añadirMilitarCola(){

Militar a;
Nodo p;
a = genMilitar();
p = new Nodo(a);
cola.insertarNodo(p);
}

public Militar genMilitar(){

Militar a;
int tAtencion;
int nivel;
tAtencion = (int) (Math.random()*(12-8+1)+8);
nivel = tropa.genPrioridad();
a = new Militar(nivel, tAtencion, Vent.minVentanilla);
return a;
}

public boolean llegóMilitar() {

int total;
boolean llegada;
llegada = false;
total = (int) (Math.random()*((100)-(1)+1)+(1));
if(total<=35){
llegada = true;
}
return llegada;
}

public void cerrarPeluqueria(){

System.out.println("---- Resumen del Atención de Oficina ----");
Vent.mostrar();
System.out.println("-----------------------------------------------");
}

Clase Militar:

public class Militar {

int prioridad, minLlegada, minInicAtención, tAtencion, hFinalización;
boolean atendiendo;

public Militar(int prioridad, int tAtención, int minLlegada) {

this.prioridad = prioridad;
this.atendiendo = false;
this.minInicAtención = 0;
this.hFinalización = 0;
this.tAtencion = tAtención;
 this.minLlegada = minLlegada;
}

public boolean finalizóCliente(int minActual) {

boolean resul;
resul = false;
if(hFinalización == minActual){ // finalizo
resul = true;
atendiendo = false; //ya fue atentido
}
return resul;
}

public int tiempoCola(){

int tiempoCola;
tiempoCola = minInicAtención - minLlegada;
return tiempoCola;
}
public void establecerCliente(int minActual){
int finaliza;
finaliza = minActual + tAtencion;
atendiendo = true;
hFinalización = finaliza;
minInicAtención = minActual;
}

public String rango(){

String rango;
rango = " ";
switch (prioridad){
case 1:
rango = "Sargento";
break;
case 2:
rango = "Cabo";
break;
case 3:
rango = "Soldado";
break;
}
return rango;
}
public void mostrar(){
System.out.println(rango());
}

Clase Tropa:

public class Tropa {

int numSargentos, numCabos, numSoldados;

public Tropa(int numSargentos, int numCabos, int numSoldados){

 this.numSargentos = numSargentos;
this.numCabos = numCabos;
this.numSoldados = numSoldados;
}

public int totalMilitares(){

int total;
total = (numSargentos + numCabos + numSoldados);
return total;
}

public float probaSargento(){

float prob;
prob = (( (float) numSargentos/totalMilitares())*100);
return prob;
}

public float probaCabo(){

float prob;
prob = (((float) numCabos/totalMilitares())*100);
return prob;
}

public float probaSoldado(){

float prob;
prob = (((float) numSoldados/totalMilitares())*100);
return prob;
}

public int genPrioridad(){

int nivel;
int proba;
nivel = 0;
proba = (int) (Math.random()*((100)-(1)+1)+(1));
if (proba <= probaSoldado()) {
nivel = 3;
numSoldados--;
} else if (proba <= (probaSoldado() + probaCabo())) {
nivel = 2;
numCabos--;
} else {
nivel = 1;
numSargentos--;
}
return nivel;
}

public void acomularTiempoCola(int tiempo, int nivel){

switch (nivel) {
case 1:

break;
case 2:
break;
 case 3:
break;
}
}

public int promColaMilitar(int nivel){

int prom;
prom = 0;

return prom;
}
// numsold = 0; probasoldado = 0;

Clase Ventanilla:

public class Ventanilla {

Militar militar;
int numVent, minInicial, minVentanilla, tOcupacion, numClientsAtend;
boolean libre;
Cola1 clientesHora; // no es estático

// extraer de la cola y enviar a la ventanilla

public Ventanilla(int num){
this.numVent = num;
this.libre = true;
this.minInicial = 0;
this.minVentanilla = 0;
this.tOcupacion = 0;
this.numClientsAtend = 0;
this.clientesHora = new Cola1();
}
public void actualizarMinActual(){
this.minVentanilla = minVentanilla +1;
}

public void actualizarVentanilla(){

// minVentanilla = (mindelDía+1) - minInicial; // actualiza el tiempo
minVentanilla = minVentanilla +1;
liberarVentanilla(); // verifica si ya debe desocuparse la ventanilla
clientesPorHora();
}

public void liberarVentanilla(){ // antes de atender cliente

if(militar!=null && militar.finalizóCliente(minVentanilla)){
numClientsAtend = numClientsAtend +1; // incrementar clientes atendidos
actualizarUsoTota(militar.gettAtencion()); // actualiza tiempo total de atención
militar = null;
 libre = true;
}
}

public void asignarPeluqueriaMilitar(Militar a){

militar = a;
a.establecerCliente(minVentanilla);
libre = false;// indicamos que la ventanilla esta ocupada
}

public void actualizarUsoTota(int tiempo){

tOcupacion = tOcupacion + tiempo;
}

public int tiempoDesocupado(){

int tiempo;
tiempo = minVentanilla - tOcupacion;
return tiempo;
}

public int horas(){

int horas;
horas = (int) minVentanilla / 60;
return horas;
}

public String horafinal(){ //mismo que Ventanilla - Cola

}
public float promedioAtencion(){//mismo que Ventanila - Cola
}
public int hrsTranscurridas(){//mismo que Ventanilla - Cola
}
public void clientesPorHora(){//mismo que Ventanilla - Cola
}

public void mostrar(){

System.out.println("Peluquería N°: "+this.numVent);
System.out.println("- Hora de finalización: ");
System.out.println(" "+ horafinal());
System.out.println("- a) Clientes atentidos: "+numClientsAtend);
System.out.println("- b) Clientea atendidos por hora: ");
clientesHora.mostrarExtraer();
System.out.println("- c) Promedio de atención: "+promedioAtencion()+" minutos por
persona.");
System.out.println("- d)Tiempo de oocio: "+tiempoDesocupado()+" minutos.");
System.out.println("- Tiempo total de ocupación: "+this.tOcupacion + " minutos");
// clientesporHora.extraerMostrar();
System.out.println("----------------------------");
}
}

Clase LC/Clase ColaPrioridad/Clase Nodo: militar, sig/Nodo1: (int) clientes, hora/Nodo3:

Ventanilla
1) Elaborar un método en lenguaje Java que reciba como parámetro un número entero y una
LCDE. El método deberá avanzar o retroceder la cabecera de la lista tantas posiciones como lo
indique el entero recibido como parámetro (si es positivo avanza y si es negativo retrocede),
contando la cantidad de vueltas que da sobre la lista y devolviendo dicho valor.

public class Aplicacion01 {

LCDE lista;
public Aplicacion01(){
lista = new LCDE();
}
public static void main(String[] args) {
Aplicacion01 ap;
int num;
num = (int) (Math.random()*(5-(-5)+1)+(-5));
LCDE a;
ap = new Aplicacion01();
a = ap.genLCDE(10);
ap.avanzarRetroceder(num, a);
}
public LCDE genLCDE(int a) {
int j, m;
Nodo p;
for (j = 0; j < a; j++) {
m = (int) (Math.random() * (25 - 15 + 1) + 15);
p = new Nodo(m);
lista.insNodo(p);
}
return lista;
}
public int avanzarRetroceder(int a, LCDE lista){
int vueltas;
System.out.println("Cab inicial: "+lista.cab.cant);
if(a>0){ // avanza
vueltas = avanzar(a);
}else{ // retrocede
vueltas = retroceder(a);
}
System.out.println("Cab final: "+lista.cab.cant);
System.out.println("Num de vueltas: "+vueltas);
return vueltas;
}
public int avanzar(int a){
Nodo p;
int cont;
cont = 0;
p = lista.cab;
while (a!=0) {
lista.cab = lista.cab.sig;
a--;
if(p == lista.cab){
cont++;
}
}
return cont;
}
public int retroceder(int a){
Nodo p;
 int cont;
cont = 0;
p = lista.cab;
while (a!=0) {
lista.cab = lista.cab.ant;
a++;
if(p == lista.cab){
cont++;
}
}
return cont;
}
}
2) Se tienen dos listas circulares: ld y lu; ambas listas contienen dígitos del 0 al 9 ubicados en
orden ascendente, declaradas a nivel de la clase aplicación. En el constructor se crean ambas
listas y se insertan en ella todos sus nodos, quedando la cabecera de ambas listas apuntando al
nodo con valor 0. Un método de esta clase recibe como parámetro a un valor entero de dos
dígitos, el cual deberá mover los respectivos punteros cabecera desde su lugar actual (que puede
ser cualquier valor) hasta el nodo que contenga el valor del dígito que le corresponda; es decir,
el dígito de las unidades establecerá la nueva posición para la cabecera de la lista lu y el dígito
de las decenas establecerá el lugar que señalará la cabecera de la lista ld. Se pide plantear los
Atributos de la clase Aplicación y desarrollar el método constructor y el método que mueve las
cabeceras.
public final class Aplicacion02 {
LC lu;
LC ld;
public Aplicacion02(){
lu = genLC(10);
ld = genLC(10);
}

public static void main(String[] args) {

Aplicacion02 ap;
ap = new Aplicacion02();
ap.moverCabezeras(23);
}

public LC genLC(int n){

int i;
LC lis;
lis = new LC();
Nodo p;
for(i=0; i<n;i++){
p = new Nodo(i);
lis.insInicio(p);
}
System.out.println("Lista LU generada");
lis.mostrar();
System.out.println("...............");
System.out.println("Moviendo la cabezera al valor 0");
lis.cab = lis.cab.sig;
System.out.println(lis.cab.cant);
return lis;
}
public void moverCabezeras(int a){
int dig1, dig2;
dig1 = (a/10);
 dig2 = (a - (dig1*10));
System.out.println("Se movera: "+dig1 +" "+dig2);
moverLC(dig1, lu);
System.out.println("Fin primera lista");
moverLC(dig2, ld);
System.out.println("Fin segunda lista");
}
public void moverLC(int a, LC lis){
while(lis.cab.cant!=a){
lis.cab = lis.cab.sig;
}
System.out.println("Como quedaron...");
lis.mostrar();
System.out.println("................");
}
}

3) Elaborar un método en lenguaje Java que reciba como parámetro un número entero (en base
10) y que retorne dicho número en binario colocado en una cadena de texto. Para ello, se harán
divisiones sucesivas del número entre 2, apilando el residuo de cada división, hasta que el
número sea cero, momento en el cual se comenzará a desapilar los valores de la pila para irlos
concatenando en una cadena de texto que será devuelta por el método.

public class Aplicacion03 {

public static void main(String[] args) {
Aplicacion03 ap;
ap = new Aplicacion03();
ap.convertirBinario(100);
}
public String convertirBinario(int num){
int a;
Pila pila;
Nodo p;
pila = new Pila();
String texto;
while(num!=0){
a = (num%2);
num = (num/2);
p = new Nodo(a);
pila.push(p);
}
texto = pilaString(pila);
System.out.println("BINARIO: "+texto);
return texto;
}

public String pilaString(Pila pila){

String texto;
texto = "";
Nodo p;
while(pila.cab!=null){
p = pila.pop();
texto = (texto + p.cant);
}
return texto;
}
}

4) Elaborar un método de la clase Aplicación que reciba como parámetro a un arreglo de colas y
que compare el atributo clave de todas las cabeceras de las colas del arreglo y seleccione aquella
cola cuya cabecera tiene el mayor valor en su atributo clave (búsqueda del máximo); extrayendo
el nodo de dicha cola, el cual será devuelto por el método (considerar que una o varias, o todas
las colas pueden estar vacías).

public class Aplicacion04 {

public static void main(String[] args) {
Aplicacion04 ap;
Cola[] colas;
ap = new Aplicacion04();
colas = ap.genArregloColas(5);
ap.mayorCab(colas);
}
public Cola[] genArregloColas(int num){
int j;
Cola[] colas;
colas = new Cola[num];
Cola cola;
Nodo p;
for (j = 0; j < colas.length; j++) {
cola = new Cola();
p = new Nodo(j);
cola.insertar(p);
colas[j] = cola;
}
System.out.println("El arreglo de colas generada...");
mostrar(colas);
return colas;
}

public Nodo mayorCab(Cola[] colas){

int i, j, max;
Nodo p;
p = null;
max = 0;
for(i=0;i<colas.length;i++){
if(colas[i].cab!=null && colas[i].cab.cant >= max ){
max = colas[i].cab.cant;
}
}
System.out.println("Máximo: "+max);
for(j = 0; j<colas.length; j++){
if(colas[j].cab!=null && colas[j].cab.cant == max){
p = colas[j].extraer();
}
}
mostrar(colas);
return p;
}
}
Ejercicio 01:

public Cola recorrerInorden01(Nodo r){

Cola a;

String codigo;

Nodo p;

double prom;

a = new Cola();

if (r != null) {

recorrerInorden01(r.izq);

codigo = r.cod;

prom = promedio(r);

p = new Nodo(codigo, prom);

a.insertar(p);

recorrerInorden01(r.der);

return a;

public double promedio(Nodo p){

double prom;

int i;

int sumavalores;

sumavalores = 0;

for (i = 0; p.numvalores < 10; i++) {

sumavalores = sumavalores + p.i.valor;

prom = sumavalores/p.numvalores;

return prom; }
Ejercicio 02:

//Clase ARBOL

public void insNodo(Nodo p){

if(raiz ==null){

raiz = p;

}else{

crearHijo(p, raiz);

public void crearHijo(Nodo p, Nodo r){

int izq, der;

if(p!=null){

if(profundidad(r) == 1){

r.izq = p;

}else{

izq = profundidad(r.izq);

der = profundidad(r.der);

if(izq>der){

crearHijo(r, p.der);

}else{

crearHijo(r, p.izq);

public int profundidad(Nodo p){

 int profundidad, izq, der;

profundidad = 0;

if(p!=null){

izq = profundidad(p.izq);

der = profundidad(p.der);

profundidad = 1 + izq + der;

return profundidad;

Ejercicio 03:

public Nodo extraerPila(Pila pilarecib, int valor) {

Pila pilaaux;

pilaaux = new Pila();

Nodo p, q;

p = null;

while (pilarecib.cab!=null && p == null) {

q = pilarecib.pop();

pilaaux.push(q);

if (q.codigo == valor) {

p = q;

while (pilaaux.cab!=null) {

q = pilaaux.pop();

pilarecib.push(q);

return p;}
Ejercicio 04:

public LCS concatenarLis(LCS lis1, LCS lis2 ){

LCS lis3;

lis3 = new LCS();

Nodo ult1, prim2;

ult1 = lis1.cab;

prim2 = lis2.cab.sig;

ult1.sig = prim2;

lis2.cab.sig = lis1.cab.sig;

lis3.cab = lis2.cab;

lis1.cab = null;

lis2.cab = null;

return lis3;

}
Elaborar un método en lenguaje Java que reciba como parámetro un número entero y una
LCDE. El método deberá avanzar o retroceder la cabecera de la lista tantas posiciones como lo
indique el entero recibido como parámetro (si es positivo avanza y si es negativo retrocede),
contando la cantidad de vueltas que da sobre la lista y devolviendo dicho valor.

public int avanORetro(int n, LCDE lista){

nodo p;

int i, vueltas;

primNodo prim;

prim = lista.cab;

p = lista.cab;

vueltas = 0;

if(n>0){

for(i = 0; i<n; i++){

p = p.sig;

lista.cab = p;

if(p == prim){

vueltas++;

if(n<0){

for(i = 0; i>n; i--){

p = p.ant;

lista.cab = p;

if(p == prim){

vueltas++;

}
 }

return vueltas;

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

Se tienen dos listas circulares: ld y lu; ambas listas contienen dígitos del 0 al 9 ubicados en
orden ascendente, declaradas a nivel de la clase aplicación. En el constructor se crean ambas
listas y se insertan en ella todos sus nodos, quedando la cabecera de ambas listas apuntando al
nodo con valor 0. Un método de esta clase recibe como parámetro a un valor entero de dos
dígitos, el cual deberá mover los respectivos punteros cabecera desde su lugar actual (que
puede ser cualquier valor) hasta el nodo que contenga el valor del dígito que le corresponda;
es decir, el dígito de las unidades establecerá la nueva posición para la cabecera de la lista lu y
el dígito de las decenas establecerá el lugar que señalará la cabecera de la lista ld. Se pide
plantear los Atributos de la clase Aplicación y desarrollar el método constructor y el método
que mueve las cabeceras.

listas (Contiene digitos de 0 al 9): Id, lu

metodo que recibe un entero de 2 digitos, mover la cabecera hasta el nodo que contenga el
digito correspondiente, el digito de las unidades es para la lista lu, y el de las decenas para la
lista Id

public void movCab(int n){

int recoId, recolu;

recoId = ap.ObtDec(n);

recolu = ap.ObtUnid(n);

ap.mRecorrerLu(recolu);

ap.mRecorrerId(recoId);
}

public int ObtUnid(int n){

int p;

p = n%10;

return p;

public int ObtDec(int n){

int p, dec;

p = n%10;

dec = (n-p)/10;

return dec;

public void mRecorrerLu(int numero){

int i;

Nodo p;

p = lu.cab;

i = 0;

do{

p = p.sig;

i++;

}while(numero != p.num);

lu.cab = p;

}
public void mRecorrerId(int numero){

int i;

Nodo p;

p = Id.cab;

i = 0;

do{

p = p.sig;

i++;

}while(numero != p.num);

Id.cab = p;

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

Elaborar un método en lenguaje Java que reciba como parámetro un número entero (en base
10) y que retorne dicho número en binario colocado en una cadena de texto. Para ello, se
harán divisiones sucesivas del número entre 2, apilando el residuo de cada división, hasta que
el número sea cero, momento en el cual se comenzará a desapilar los valores de la pila para
irlos concatenando en una cadena de texto que será devuelta por el método.

Public String conve(int n){

int resultado, residuo;

Pila pila;

Nodo p;

String respuesta;

resultado = n;

residuo = 0;

respuesta = "";

pila = new Pila();

 do{

residuo = resultado % 2;

p = new Nodo(residuo);

pila.push(p);

resultado = (resultado - residuo)/2;

}while(resultado>=2);

p = new Nodo(resultado);

pila.push(p);

respuesta = ConcatenarString(pila);

return respuesta;

Public String ConcatenarString(Pila pila){

String resultado;

Nodo p;

resultado = "";

while(pila.cab != null){

p = pila.pop();

resultado = resultado + p.numero();

return resultado;

----------------------------------------------------------------
Elaborar un método de la clase Aplicación que reciba como parámetro a un arreglo de colas y
que compare el atributo clave de todas las cabeceras de las colas del arreglo y seleccione
aquella cola cuya cabecera tiene el mayor valor en su atributo clave (búsqueda del máximo);
extrayendo el nodo de dicha cola, el cual será devuelto por el método (considerar que una o
varias, o todas las colas pueden estar vacías).

public Nodo CompClaveObtNodo(Cola colas){

int numeroMayor;

nodo NodoMayor;

numeroMayor = obtNumMayor(colas);

NodoMayor = ObtNodo(numeroMayor, ColaColas);

return NodoMayor;

public int ObtNumMayor(Cola colas){

Cola p;

Nodo q, nodoMayor;

int mayor;

p = colas.cab;

mayor = p.cab.clave;

while(p != null){

if(mayor<p.cab.clave){

mayor = p.cab.clave;

p = p.sig;
 }

return mayor;

public Nodo ObtNodo(int m, Cola colas){

Cola p;

Nodo q;

p = colas.cab;

do{

if(p.cab.clave == m){

q = p.extraer();

p = p.sig;

}while(q == null);

return q;

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

Elaborar un método de la clase Aplicación que reciba como parámetro a un arreglo de colas y
que compare el atributo clave de todas las cabeceras de las colas del arreglo y seleccione
aquella cola cuya cabecera tiene el mayor valor en su atributo clave (búsqueda del máximo);
extrayendo el nodo de dicha cola, el cual será devuelto por el método (considerar que una o
varias, o todas las colas pueden estar vacías).

Public Nodo extraerMayor(Cola[] colas){

int numMayor, i, indiceMayor;

Cola p;

Nodo q;
 i = 0;

numMayor = q.clave;

do{

p = cola[i];

q = p.cab;

i++;

if(numMayor<q.clave){

numMayor = q.clave;

indiceMayor = i;

}while(p != null);

p = cola[indiceMayor];

q = p.extraer();

return q;

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

Elaborar un método de la clase Aplicación en lenguaje Java que recorra una Lista Circular
Doblemente Enlazada (declarada a nivel de la clase Aplicación con el nombre de lis), evaluando
para cada nodo visitado que tanto dicho nodo como su antecesor y su sucesor tengan en su
atributo cant (de tipo int) el mismo valor (o con una diferencia unitaria); de no ser así, se
sumarán los tres valores y ese resultado se repartirá equitativamente entre los tres nodos
(quedando los tres valores iguales o con una diferencia unitaria). El recorrido terminará
cuando, al dar una vuelta por la lista, no se realicen más repartos entre nodos.

Public void evalLista(){

boolean repartos;

Nodo p;

int nAnt, nAct, nSig, repart, residuo, sumatoria;

repartos = true;

p = lis.cab;

while(p != null){

nAnt = p.ant.cant;

nAct = p.cant;

nSig = p.sig.cant;

if(nAnt != nSig && nAnt - nSig != 1){

sumatoria = nAnt + nAct + nSig;

residuo = sumatoria%3;

if(residuo == 0){

repart = sumatoria / 3;

p.ant.cant = repart;

p.cant = repart;

p.sig.cant = repart;

}else if(residuo == 1){

repart = (sumatoria-1) / 3;

p.ant.cant = repart;

p.cant = repart;

p.sig.cant = repart + 1;

}else if(residuo == 2){

repart = (sumatoria-2) / 3;

p.ant.cant = repart;

p.cant = repart + 1;

p.sig.cant = repart + 1;
 }

repartos = true;

p = p.sig;

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

Elaborar un método recursivo de la clase LES que en su trayectoria de entrada

aumente la variable stk de cada nodo de la lista en un valor aleatorio

comprendido entre 10 y 20; y en su trayectoria de salida cuente la cantidad de

nodos de la lista cuya variable stk estén por debajo del valor de la variable

stkmin

Public int recAum(Nodo p, int stkmin){

// p es la cabecera de la lista

int aleatorio, nodosStkMin;

if(p.sig == null){

nodosStkMin = 0;

}else{

aleatorio = genEntero(10,20);

p.stk = p.stk + aleatorio;

if(p.stk < stkmin){

nodosStkMin = nodosStkMin + recAum(p.sig);

}else{

nodosStkMin = recAum(p.sig);
 }

return nodosStkMin;

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

*/

if(p.stk < stkmin){

nodosStkMin++;

/*

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

Clase Bicola:

Public class Bicola(){

Nodo inicioCola;

Nodo finalCola;

Bicola(){

inicioCola = null;

finalCola = null;

}
 public Nodo extraccionFinal(){

Nodo extraido, p;

if(finalCola == null){

extraido = null;

}else{

extraido = finalCola;

finalCola = finalCola.ant;

if(finalCola == null){

inicioCola = null;

return extraido;

public Nodo insercionInicio(Bicola bicola){

Nodo extraido;

return extraido;

}
 public Nodo insercionFinal(Bicola bicola){

Nodo extraido;

return extraido;

public Nodo extraccionInicio(Bicola bicola){

Nodo extraido;

return extraido;

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

Public int metRecursivo(Nodo p){

//p es la raiz del arbol

Nodo pIzq, pDer;

int res;

if(p.izq == null && p.der == null){

res = p.valor;

}else{

return res;
}

Post Orden:

-Recorrido al sub arbol izquierdo

-Recorrido al sub arbol derecho

-Procesar nodo

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

public Nodo ejerciCuatro(Pila pila, int dato){

Nodo p, respuesta;

Pila pAuxiliar;

p = pila.cab;

pAuxiliar = new Pila();

do{

if(p.valor == dato){
 respuesta = pila.pop();

break;

}else{

pAuxiliar.push(pila.pop());

p = pila.cab;

}While(pila.cab != null);

while(pAuxiliar.cab != null){

pila.push(pAuxiliar.cab);

pAuxiliar.pop();

return respuesta;

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

Public LCS unirListas(LCS lis1, LCS lis2){

LCS lis3;

Nodo cab1, cab2, fin1, fin2, p, q;

lis3 = new LCS();

p = lis1.cab;

q = lis2.cab;

if(lis1.cab == null && lis2.cab != null){

lis3.cab = lis2.cab;

lis2.cab = null;

}else if(lis2.cab == null && lis1.cab != null){

lis3.cab = lis1.cab;
 lis1.cab = null;

}else{

cab1 = lis1.cab;

cab2 = lis2.cab;

do{

if(p.sig == lis1.cab){

fin1 = p;

p = p.sig;

}while(p != lis1.cab);

do{

if(q.sig == lis2.cab){

fin2 = q;

q = q.sig;

}while(q != lis2.cab);

fin1.sig = cab2;

fin2.sig = cab1;

lis3.cab = fin2;

lis1.cab = null;

lis2.cab = null;

return lis3;

----------------------------------------------------------------------------
Elaborar un método de la clase Aplicación que reciba como parámetros a una

pila y a un valor entero. El método deberá extraer de la pila al nodo que

contenga como código al valor entero recibido como parámetro; para lo cual

deberá desapilar en una pila auxiliar a todos los nodos que estén por encima del

nodo solicitado, para que, después de retirarlo de la pila, volver a colocarlos en

la pila original. El método retornará el nodo solicitado.

public Nodo extNodoValor(Pila pila, int entero){

Nodo p, nodoValor;

Pila pAuxiliar;

pAuxiliar = new Pila();

nodoValor = null;

while(pila.cab != null && nodoValor == null){

if(p.valor == entero){

nodoValor = p;

}else{

pAuxiliar.push(p);

while(pAuxiliar.cab != null){

p = pAuxiliar.pop();

pila.push(p);

return nodoValor;