import java.util.*; import java.io.*; import java.awt.*; import java.awt.event.*; import javax.swing.

*; class Lista { // // // // // pila - es una estructura de datos lineales, y es dinamica. porque se dice que es dinamica pila LIFO - el ultimo en entrar es el primero en salir. Programa de representacion de datos ordenados por medio de Pilas y se ejecuta en modo texto

// variables para pila int original int cima=0; int max=1000; int pila[]=new int[max]; // variables para pila string original int cimastring=0; String pilastring[]=new String[max]; // variables para cola string original String colastring[]=new String[max]; int frentestring=0; int finstring=0; // variables para cola int original int cola [] = new int [max]; int frente = 0; int fin = 0; // variables extras para pares e impares int pares=0; int impares=0; // contador int co=0; // variable para promedio (observacion) int Nota=0; // variable para errordecimal double xy; // variable para cuando utiliza (for) int n; int a; // variable para generar elementos aleatoriamente int limite=99999; // 1 cargar pila original con int public void cargarpila(int elementopila) { if (cima<max) {

cima++; pila[cima]=elementopila; } else { System.out.print("No hay espacio en la pila"); } } // 2 cargar pila original con string public void cargarpilastring(String elementopilastring) { if(cimastring<max) { cimastring++; pilastring[cimastring]=elementopilastring; } else { System.out.print("No hay espacio en la pila"); } } // 3 cargar cola original sin pedir volver a cargar public void cargarcolastring (String elementocolastring) { if(finstring == max) { System.out.println ("No se realizo ninguna accion\nLa pila esta llena"); } else { finstring++; colastring [finstring] = elementocolastring; //System.out.println ("\n elemento insertado: " + cola [fin]); System.out.println (colastring [finstring]); } } // 4 mostrar pila original public void mostrarPilaString() { int cimate=0; String pilate[]=new String[max]; while(cimastring>0) { cimate ++; System.out.println(" posicion = "+cimastring+" ); pilate[cimate]=pilastring[cimastring]; cimastring--; } while(cimate>0) { cimastring++; pilastring[cimastring]=pilate[cimate]; cimate--; //System.out.println(pila[cima]+" "); } }

"+pilastring[cimastring]

// 5 mostrar pila original public void mostrarColaString() { int frentete=0; int finte=0; String colate[]=new String[max]; if (frentestring == finstring) { System.out.print ("\n NO HAY DATOS QUE MOSTRAR....Porfavor .....Introdusca algo "); } else { while (frentestring < finstring) { frentestring++; System.out.print (" "+colastring [frentestring]); finte++; colate [finte] = colastring [frentestring]; } finstring = 0; frentestring = 0; while(frentete < finte) { frentete++; finstring++; colastring [finstring] = colate [frentete]; } } } // 6 cargar cola original sin pedir volver a cargar public void cargarcola (int elementocola) { if(fin==max) { System.out.println ("\n No se realizo ninguna accion.....La pila esta llena"); } else { fin++; cola [fin] = elementocola; } } /////////////////////////////////////////// // 7 cola mostrar cola original public void mostrarcola () { int colAux[]=new int[max]; int finAux=0; int frenteAux=0; if (frente==fin) { System.out.print ("\n NO HAY DATOS QUE MOSTRAR \n Porfavor ....... Introdusca al go "); } else

{ while (frente < fin) { frente++; System.out.print (" "+cola [frente]); finAux++; colAux [finAux] = cola [frente]; } fin = 0; frente = 0; while(frenteAux<finAux) { frenteAux++; fin++; cola[fin]=colAux[frenteAux]; } } } // 8 pila mostrar pila original public void mostrarpila() { int cimatempo=0; int pilatempo[]=new int[max]; if(cima==0) { System.out.print(" No hay elementos en la pila "); } else{ System.out.println(" .----."); while(cima>0) { cimatempo ++; System.out.println(" posicion = "+cima+" //System.out.println(" ___"); pilatempo[cimatempo]=pila[cima]; cima--; } System.out.println(" .----."); } while(cimatempo>0) { cima++; pila[cima]=pilatempo[cimatempo]; cimatempo--; } } | "+pila[cima]+" | ");

// 9 CARGAR ELEMENTOS EN COLA - DESEAS SEGUIR CARGANDO public void cargarpilayseguirpidiendocargarotravez()throws IOException { int t; int f=1; do { BufferedReader in=new BufferedReader(new InputStreamReader(System.in)); System.out.print(" introduzca un elemento = "); int a=num(); if(cima<=max)

{ cima++; pila[cima]=a; } else { System.out.println(" NO HAY ESPACIO EN LA pila "); } System.out.println("\n elija una opcion "); System.out.print("\n 1 seguir insertando \t 2 ir al menu inicio = "); t=num(); } while(t==(f)); } // 10 CARGAR ELEMENTOS EN LA COLA - DESEAS SEGUIR CARGANDO public void cargarcolayseguirpidiendocargarotravez()throws IOException { int t; int f=1; do { BufferedReader in=new BufferedReader(new InputStreamReader(System.in)); System.out.print(" introduzca un elemento = "); int a=num(); if(fin<=max) { fin++; cola[fin]=a; } else { System.out.println(" NO HAY ESPACIO EN LA COLA "); } System.out.println("\n elija una opcion "); System.out.print("\n 1 seguir insertando \t 2 ir al menu inicio = "); t=num(); } while(t==(f)); } // 11 cola - metodo para sumar y promedio final public void sumarelementosdelacola() { // variable sumador contador promedio int s=0; int contcola=0; int promcola=0; // variable pila auxiliar 1 int pilaAuxiliar1[]=new int [max]; int cimaAuxiliar1=0; // variable pila auxiliar 2 int pilaAuxiliar2[]=new int [max]; int cimaAuxiliar2=0; while(frente<fin) { cimaAuxiliar1++; frente++; contcola++;

s=s+cola[frente]; pilaAuxiliar1[cimaAuxiliar1]=cola[frente]; } frente=0; fin=0; promcola=s/contcola; System.out.println("\n los elementos sumados de la cola = "+s); System.out.println(" el promedio final de la cola " +promcola); System.out.println("\n Restaurando los valores de la cola ... "); while(cimaAuxiliar1>0) { cimaAuxiliar2++; pilaAuxiliar2[cima]=pilaAuxiliar1[cimaAuxiliar1]; cimaAuxiliar1--; } while(fin==max) { fin++; cola[frente]=pilaAuxiliar2[cimaAuxiliar2]; cimaAuxiliar2--; } } // 12 metodo para sumar pila y promedio final public void sumarElementosDeLaPila() { // variable pila auxiliar int Pa[]=new int [max]; int cimaA=0; // variables sumador contado promedio int s=0; int contpila=0; int prompila=0; while(cima>0) { cimaA++; contpila++; Pa[cimaA]=pila[cima]; s=s+pila[cima]; cima--; } prompila=s/contpila; System.out.println("\n los elementos sumados de la pila son = "+s); System.out.println(" el promedio final de la pila es = "+prompila); System.out.println("\n Restaurando los valores de la pila original"); while(cimaA>0) { cima++; pila[cima]=Pa[cimaA]; cimaA--; } } // 13 pila generar elementos aleatoriamente public void generarPilaAleatoriamente()throws IOException { BufferedReader in=new BufferedReader(new InputStreamReader(System.in)); for(int i=1;i<=n;i++) { if (cima<max)

{ cima++; pila[cima]=(int)(Math.random()*100 +1); //pila[cima]=(int)(Math.random()*limite+1); } else { System.out.print("No hay espacio en la pila"); } Nota=pila[cima]; this.aprobadoReprobado(); } } // 13 cola generar elementos aleatoriamente public void generarColaAleatoriamente()throws IOException { BufferedReader in=new BufferedReader(new InputStreamReader(System.in)); for(int i=1;i<=n;i++) { if(fin==max) { System.out.println ("\n No se realizo ninguna accion.....La cola esta llena"); } else { fin++; cola[fin]=(int)(Math.random()*100+1); //cola[fin]=(int)(Math.random()*limite+1); Nota=cola[fin]; this.aprobadoReprobado(); } } } // 14 observacion Reprobado, 2da 3ra Mesa, 1ra 2da 3ra Mesa, Eximido en la mater ia public void aprobadoReprobado () { if(Nota<40) { System.out.println(" El estudiante esta Reprobado con = "+Nota); } else { if(Nota<=50) { System.out.println(" El estudiante esta en 2da 3ra Mesa con = "+Nota); } else { if(Nota<=79) { System.out.println(" El estudiante esta 1ra 2da 3ra Mesa con = "+Nota); } else { if(Nota>=80) {

System.out.println(" El estudiante esta Eximido con = "+Nota); } } } } } // 15 pila - buscar un elemento con variable string public void buscarUnElementoStringEnPilaString() throws IOException { int cimaa=0; String NombreNN; BufferedReader in=new BufferedReader (new InputStreamReader (System.in)); System.out.print(" INGRESE EL NOMBRE = "); String a=in.readLine(); if(cimastring>0) { do { cimaa++; if(pilastring[cimaa].equals(a)) { NombreNN=pilastring[cimaa]; System.out.println(" el nombre fue encontrado es "+NombreNN); } cimastring--; } while(!(cimastring==0)); do { cimastring++; cimaa--; } while(!(cimaa==0)); } else { System.out.println("LA PILA ESTA VACIA, NO SE PUEDE BUSCAR DATOS"); } }

//////////////////////////////////////////////////////////////////////////////// public void dividir() throws IOException {int pilapar[]=new int[max]; int pilaimpar[]=new int[max]; int cima2=0; int cimaA=0; int cimaB=0; BufferedReader in=new BufferedReader(new InputStreamReader(System.in)); //int E=Integer.parseInt(in.readLine()); do { cima2++; if((pila[cima2])%2==0) {

cimaA ++; pilapar[cimaA]=pila[cima2]; cimaA --; } else { cimaB ++; pilaimpar[cimaB]=pila[cima2]; cimaB --; } } while(cima2!=cima); { int pilaaux[]=new int[max]; int cimaaux=0; while(cima>0) { System.out.println("Elemento par: "+pilaaux[cimaaux]); cimaaux++; pilaaux[cimaaux]=pila[cimaA]; cima--; } while(cimaaux>0) {System.out.println("Elemento impar: "+pila[cimaA]); cima++; pila[cima]=pilaaux[cimaaux]; cimaaux--; } } } ////metodo para buscar int k; public void buscar(int B) { int cimaaux=0; int pilaaux[]=new int[1000]; boolean sw=false; //int k; while((cima>0)||(sw=false)) { if(B==pila[cima]) { sw=true; k=cima; } cimaaux++; pilaaux[cimaaux]=pila[cima]; cima--; } while(cimaaux>0) { cima++; pila[cima]=pilaaux[cimaaux];

cimaaux--; } if(sw==true) { System.out.println("el elemento es este"+k); } else { System.out.println("el elemento no existe"); } } public void eliminar() { int cimaaux=0; int cima1=0; int P1[]=new int[1000]; int cima2=0; int P2[]=new int[1000]; if(cima1%2==0) { int a=(cima1); while(cima1>0) { if(cima1==(a/2)||cima1==(a/2)+1) { System.out.println ("elemento eliminado "+P1[cima1]); cima1--; } else {cima2++; P2[cima2]=P1[cima1]; cima1--; } } } else { int b=(cima1+1); while(cima1>0) { if(cima1==(b/2)) { System.out.println ("elemento eliminado "+P1[cima1]); cima1--; } else { cima2++; P2[cima2]=P1[cima1]; cima1--; } } } while(cima2>0)

{ cima1++; P1[cima1]=P2[cima2]; cima2--; } } public void ordenarDatosDeLaPila()throws IOException { int pilaauxiliar[]=new int[max]; int cimaauxiliar=0; int aux1=0; int aux2=0; BufferedReader in=new BufferedReader (new InputStreamReader(System.in)); if(cima==0){ System.out.println(" Pila vacia"); } else{ while(cima>0){ if(pila[cima]>=pilaauxiliar[cimaauxiliar]) { aux1=pila[cima]; //cima--; //pila[cima]=aux2; pilaauxiliar[cimaauxiliar]=aux1; } cima--; } } /*else{ for (int i=0; i<=cima-1; i++) { for (int j=i+1; j<=cima-1; j++) { if (pila[i]>=pila[j]) { int aux=pila[i]; pila[i]=pila[j]; pila[j]=aux; } } } }*/ }

// 16 cola - invertir cola

public void invertircola() { int pilainvertir[]=new int[max]; int cimainvertir=0; while(frente<fin) { frente ++; cimainvertir ++; pilainvertir[cimainvertir]=cola[frente]; } frente=0; fin=0; while(cimainvertir>0) { fin ++; //System.out.print(" "+pilainvertir[cimainvertir]); cola[fin]=pilainvertir[cimainvertir]; //System.out.print(" "+cola[fin]); cimainvertir--; } System.out.println(" La cola ya fue invertida ...... solo imprima la cola "); // restaurar valores aumentar ese codigo } // 17 pila invertir pila public void invertirpila() { int cimatemp=0; int cimaaux=0; int pilatemp[]=new int[max]; int pilaaux[]=new int[max]; while(cima>0) { cimatemp ++; pilatemp[cimatemp]=pila[cima]; cima--; } while(cimatemp>0) { cimaaux++; pilaaux[cimaaux]=pilatemp[cimatemp]; cimatemp--; } while(cimaaux>0) { cima++; pila[cima]=pilaaux[cimaaux]; cimaaux--; } System.out.println(" La pila ya fue invertida ...... solo imprima la pila "); } // 18 pila - eliminar uno por uno public void borrarpilaunoporuno() { if(cima>0) { System.out.println("\n El elemento [ " +pila[cima]+" ] de la posicion [ "+cima+" ] esta eliminado");

cima--; } else { System.out.println(" La pila esta vaca ..... No hay elementos a eliminar "); } } // 19 pila - eliminar pila entera // pila pares - pila impares - pila original public void borrarTodaLaPila() { int cimap=0; int cimai=0; if(cima>0) { cima=0; cimap=0; cimai=0; System.out.println(" ACABA DE ELIMINAR TODOS LOS ELEMENTOS LA PILA "); } else { System.out.println("NO EXISTE ELEMENTOS EN LA PILA"); } } // 20 pila - buscar y eliminar el elemento public void borrarUnElementoDeLaPila(int eleborrar) { int cimatemporal=0; int pilatemporal[]=new int[max]; int sw=0; BufferedReader in=new BufferedReader(new InputStreamReader(System.in)); while(cima>0) { if(pila[cima]==eleborrar) { cima--; sw=1; } else { cimatemporal ++; pilatemporal[cimatemporal]=pila[cima]; cima--; } } while(cimatemporal>0) { cima++; pila[cima]=pilatemporal[cimatemporal]; cimatemporal--; } if(sw==0) { System.out.println("el elemento"+eleborrar+"no existe dentro de la Pila"); } else {

System.out.println("El elemento esta eliminado"); } } // 21 cola - metodo para saber cantidad de pares e impares public void paresdimpares() { while (frente<fin) { frente ++; if (cola[frente]%2==0) { pares ++; } else { impares ++; } } frente=0; System.out.println ("\n los pares son = "+pares); System.out.println (" los impares son = "+impares); } // 22 cola - metodo para trasladar de cola a pila public void pasarDeColaApila() { if(frente==fin) { System.out.println("NO HAY ELEMENTOS"); } else { while(frente<fin) { cima++; frente++; pila[cima]=cola[frente]; } System.out.println("\n los elementos fueron pasados solo imprima la pila"); frente=0; fin=0; } } // 22 cola - metodo para trasladar de cola a pila public void pasarDePilaAcola() { while(cima>0) { fin++; cola[fin]=pila[cima]; cima--; } System.out.println("\n los elementos fueron pasados solo imprima la pila"); } // 23 cola - metodo para buscar un elemento // y ve cuantas veces se repite

public void buscarUnElementoEnLaCola(int x) { int s=0; int sw=0; // variable pila auxiliar 1 int cimaaux1=0; int pilaaux1[]=new int[max]; BufferedReader in=new BufferedReader(new InputStreamReader(System.in)); if(frente==fin) { System.out.println("NO HAY ELEMNTOS"); } else { while (frente<fin) { if(cola[fin]==x) { System.out.println("el elemento es:"+x); sw=1; s=s+sw; } cimaaux1++; pilaaux1[cimaaux1]=cola[fin]; fin--; } System.out.println(" elemento encontrado [ "+s+" ] veces:"); } fin=0; frente=0; } // 24 cola - metodo eliminar o borrar cola public void borracolasinutilizarfo() { if(frente==fin) { System.out.println("NO HAY ELEMENTOS"); } else { while(fin>0) { fin--; } } } // 25 cola - MOSTRAR CUANTOS PARES E IMPARES public void mostrarcuantospareseimpares() { while (frente<fin) { frente++; if (cola[frente]%2==0) { pares++; } else {

impares++; } } frente=0; System.out.println ("\n ELEMENTOS PARES = "+pares); System.out.println ("\n ELEMENTOS IMPARES = "+impares); } // 26 cola - METODO PARA BORRAR (PUBLIC) public void borracolasinutilizarfor() { if(fin>frente) { frente++; } else { frente=0; fin=0; System.out.println("no hay nada para borrar"); } }

// cola - PASAR SOLO ELEMENTOS PRIMOS DE COLA A LISTA public void pasar() { boolean z=false; int y=0; NodoListas n; for(int i=1;i<=fin;i++) { z=primo(cola[i]); if(z==true) { y=cola[i]; n=new NodoListas (y); if(cabeza==null) { cabeza=n; } else { n.siguiente=cabeza; cabeza=n; } } } fin=0; } // cola - IMPRIMIR SOLO LOS PRIMOS public void imprimir1() { int y,S=0; boolean z=false; NodoListas np; np=cabeza; while(np!=null)

{ y=np.dato; z=primo(y);//CAMVIAR SOLO PARA LLAMAR A LOS DIFERENTES METODO if(z==true) { S=S+np.dato; System.out.print(" "+np.dato); //Tambien puede ser variable (y) } if(z==false) { cima++; pila[cima]=np.dato; // System.out.print(" no es primo"+y); } np=np.siguiente; } System.out.print(" Suma de primos; "+S); } // cola - actualizar entero //////////////////////////////////////////////////////////////////////////////// public void actualizarUnElementoEnCola(int buscarcola)throws IOException { int nuevo; int colAux[]=new int[max]; int finAux=0; int frenteAux=0; BufferedReader in=new BufferedReader (new InputStreamReader(System.in)); while(fin>frente) { frente++; finAux++; if(buscarcola==cola[frente]) { System.out.print(" Digite el nombre del nuevo valor = "); nuevo=Integer.parseInt(in.readLine()); cola[frente]=nuevo; } colAux[finAux]=cola[frente]; } fin = 0; frente = 0; while(finAux>frenteAux) { frenteAux++; fin++; cola[fin]=colAux[frenteAux]; } } // pila - actualizar un elemento public void actualizarUnElementoEnPila(int buscar) throws IOException { int cimatemporal=0; int pilatemporal[]=new int[max]; int M; BufferedReader in=new BufferedReader(new InputStreamReader(System.in));

while(cima>0) { if(pila[cima]==buscar) { System.out.print(" introduzca el elemento a actualizar = "); M=Integer.parseInt(in.readLine()); pila[cima]=M; } else { cimatemporal ++; pilatemporal[cimatemporal]=pila[cima]; cima--; } } while(cimatemporal>0) { cima++; pila[cima]=pilatemporal[cimatemporal]; cimatemporal--; } } //3//METODO SACAR EL FRENTE //////////////////////////////////////////////////////////////////////////////// public void siguiente() { if (frente==fin) {System.out.println("YA NO PUEDES SACAR ELEMENTOS:\nNo hay nadie en la cola...") ; } else { while(frente<fin) { frente++; cola[frente]=cola[frente+1]; } System.out.println (" EL SIGUIENTE: "); fin=frente-1; frente=0; } } ///4 METODO SACAR EL FIN //////////////////////////////////////////////////////////////////////////////// public void yano()throws IOException { if(fin==frente) { System.out.println("TODAVIA HAY LUGAR... "); } else { System.out.print("POR MOTIVOS DE ESPACIO "+cola[fin]+" FUE RETIRADO"); fin--; } }

/* public void sumar() { int S=0,P; do{ P=(pila2[cima2]+pila3[cima3]); S=P+S; cima2--; cima3--; } while((cima2&cima3)!=0); System.out.println(" "+S); } */

// listas listas listas /////////////// NodoListas cabeza; NodoListas recicler; NodoListas borrados; int contadorborrar=0; // LISTA lista lista public void ListaSimple(NodoListas n) { cabeza=n; } // 27 lista - imprimir la lista original public void imprimirlistaoriginal() { NodoListas n; n=cabeza; System.out.print("\n Los elementos de la primera Lista son \n"); while(n!=null) { System.out.print(" "+n.dato); n=n.siguiente; } } // 28 lista agregar al final public void agregarAlFinal(NodoListas n) { if(cabeza==null) { cabeza=n; } else

{ NodoListas punt; punt=cabeza; while(punt.siguiente!=null) { punt=punt.siguiente; } punt.siguiente=n; } }

// 29 lista agregar al inicio public void agregarAlInicio(NodoListas n) { if(cabeza==null) { cabeza=n; } else { n.siguiente=cabeza; cabeza=n; } } // 30 buscar un elemento en lista y borrar public void buscarEnListaYborrar(int pos) { int cont,band; if(pos>cantidadElementosEnLista()) { System.out.println("No existe esa posicion"); } else { NodoListas punt; punt=cabeza; cont=1; band=0; if(pos==1) { cabeza=cabeza.siguiente; } else { while(band==0) { cont=cont+1; if(cont==pos) { punt.siguiente=punt.siguiente.siguiente; band=1; } punt=punt.siguiente; } } } }

// 31 busca el mayor de la lista public void mayorEnLaLista()//throws IOException { System.out.println("Los elementos de la primera Lista"); int numeromayor=0; int p=0; int c=0; NodoListas n; n=cabeza; while(n!=null) { c++; if(numeromayor<n.dato) { numeromayor=n.dato; p=c; } } n=n.siguiente; System.out.println(" el mayor numero es "+numeromayor+" anos esta en "+p); } // 32 pasar lista para a pila y lista impar a cola public void pasarListaParPilaUnoImparColaDos()throws IOException { BufferedReader in=new BufferedReader (new InputStreamReader(System.in)); NodoListas n; n=cabeza; while(n!=null) { if((n.dato%2)==0) { cima++; pila[cima]=n.dato; } else { fin++; cola[fin]=n.dato; } n=n.siguiente; } } // A lista cantidad de elementos en lista public int cantidadElementosEnLista() { NodoListas n; n=cabeza; int c=0; while(n!=null) { c=c+1; n=n.siguiente; } return c; }

// 33 sumar los elementos de la lista public void sumarElementosDeLista() { int s=0; int Contador1=0; int promedio1=0; // llama al metodo A (cantidadElementoEnLista) if(cantidadElementosEnLista()>0) { NodoListas n; n=cabeza; while(n!=null) { Contador1++; s=s+n.dato; n=n.siguiente; } promedio1=s/Contador1; System.out.println(" La suma es: "+s); System.out.println(" el promedio es: "+promedio1); } } // 34 lista separa datos por posicion public void separarParEimparPorPosicion() { int c=0; int canti=cantidadElementosEnLista(); if(canti>0) { NodoListas n; n=cabeza; while(n!=null) { c++; if((c%2)==1) { cima++; pila[cima]=n.dato; //agregarAlFinal(new NodoListas(n.dato,n.nombre,n.sueldo)); } else { fin ++; cola[fin]=n.dato; } n=n.siguiente; } } } // 35 cola - pasar de cola a lista solo multiplos de 3 public void pasarColaAlistaMultiplosDtres() { // variable cola auxiliar int colaAuxi[]=new int [max]; int finAuxi=0; int frenteAuxi=0; while(frente<fin)

{ frente++; if(cola[frente]%3==0) { //n=new NodoListas(n); //n=new agregarAlFinal(n); //insertar(); //insertar(new agregarAlFinal(cola[frente])); //insertar(new agregarAlInicio(cola[frente])); //System.out.print(" "+cola[frente]); agregarAlFinal(new NodoListas(cola[frente])); } else { finAuxi ++; colaAuxi[finAuxi]=cola[frente]; } } System.out.print("\n Los multiplos de 3 fueron pasados \n"); fin=0; frente=0; System.out.print("\n los no multiplos pasados a una cola auxiliar "); System.out.print("\n Y a la vez restaurando valores a la cola original "); while(frenteAuxi<finAuxi) { frenteAuxi ++; fin ++; System.out.print(" "+colaAuxi[frenteAuxi]); cola[fin]=colaAuxi[frenteAuxi]; } } // 35 cola - pasar de cola a lista solo multiplos de 3 public void pasarPilaAlista() { while(cima>0) { agregarAlFinal(new NodoListas(pila[cima])); cima --; } } // 36 lista - pasar de lista a pila /*el ultimo elemento de la lista en la posicion uno de la pila y el primer elemento de la lista en la posicion ultima de la pila*/ public void pasarListaApilaInvirtiendoSusElementos() { // variable pila auxiliar int pilaAuxili[]=new int [max]; int cimaAuxili=0;

if(cabeza==null) { System.out.println(" la lista esta vacia .... cargar datos por favor"); } else { NodoListas M; M=cabeza; while(M!=null) { cimaAuxili ++; pilaAuxili[cimaAuxili]=M.dato; //System.out.println(" "+cimaAuxili+" "+pilaAuxili[cimaAuxili]); M=M.siguiente; } } while(cimaAuxili>0) { cima++; pila[cima]=pilaAuxili[cimaAuxili]; cimaAuxili --; } System.out.println("\n elementos pasados correctamente .... imprima la pila "); } // lista pasar factorial lista a pila public void pasarFactorialDeListaApila() { if(cabeza==null) { System.out.println("\n LA LISTA ESTA VACIA "); } else { NodoListas n; n=cabeza; while(n!=null) { int f=1; for (int i=1;i<=n.dato;i++) { f=f*i; } cima++; pila[cima]=f; n=n.siguiente; } System.out.println("\n elementos pasados ..... imprima la pila "); } } // lista pasar factorial lista a pila public void pasarFactorialDeListaAcola() { if(cabeza==null) { System.out.println("\n LA LISTA ESTA VACIA "); } else {

NodoListas n; n=cabeza; while(n!=null) { int f=1; for (int i=1;i<=n.dato;i++) { f=f*i; } fin++; cola[fin]=f; n=n.siguiente; } System.out.println("\n elementos pasados ..... imprima la pila "); } } public void recicla(NodoListas n) { if(recicler==null){ recicler=n; } else{ n.siguiente=recicler; recicler=n; } } public void mostrarrecicler() { NodoListas reci; reci=recicler; //read(); while(reci!=null) { System.out.println(" "+reci.dato); reci=reci.siguiente; } } /*/ metodo borrar public void borrar1(int pos) { contadorborrar=0; int cont,band; if(pos>cantidadElementosEnLista()) { System.out.println("- NO EXISTE ESA POSICION -"); } else{ NodoListas n; n=cabeza; cont=1; band=0; if(pos==1) { contadorborrar=1; cabeza=cabeza.siguiente;

} else { while(band==0) { cont=cont+1; if(cont==pos) { contadorborrar=1; n.siguiente=n.siguiente.siguiente; band=1; } n=n.siguiente; } } } if(contadorborrar==1) { //read2(); System.out.println("- FUE BORRADO EXITOSAMENTE -"); } }

////////borrar pos posicion////////////////// public void borrarPorPosicion(int pos) { int cont; int band; if(pos>cantidadElementosEnLista()) { System.out.println("NO EXISTE ESA POSICION EN LA LISTA"); } else{ NodoListas punt; punt=cabeza; cont=1; band=0; if(pos==1) { //////Me manda al metodo de borrados el nodo eliminado// agregarBorrados(new NodoListas(punt.ci,punt.nombre,punt.apellido,punt.nacionalid ad,punt.sexo,punt.clase,punt.costo,punt.habitacion,punt.fecha)); /////////////////////////////////////////////////////// cabeza=cabeza.siguiente; } else { while(band==0) { cont=cont+1; if(pos==cont) { //////Me manda al metodo de borrados el nodo eliminado// agregarBorrados(new NodoListas(punt.siguiente.ci,punt.siguiente.nombre,punt.sigu iente.apellido,punt.siguiente.nacionalidad,punt.siguiente.sexo,punt.siguiente.cl

ase,punt.siguiente.costo,punt.siguiente.habitacion,punt.siguiente.fecha)); /////////////////////////////////////////////////////// punt.siguiente=punt.siguiente.siguiente; band=1; } punt=punt.siguiente; } } } }*/

// B METODO PARA NUMEROS PRIMOS public static boolean primo(int num) { int cont = 0; for(int i =1; i < num; i++) { if (num % i == 0) { cont++; } } if (cont < 2) { return true; } else { return false; } } // C metodo para promedio public static boolean promedio(int prome) { boolean Prom=false; if(prome%3==0) { Prom=true; } return Prom; } // D METODO PARA ELEMENTOS PARES public static boolean par(int num) { boolean p = false; if (num % 2 == 0) { p=true; } return p; } // E METODO PARA MULTIPLOS DE 3 , 5 y 7 public static boolean multiploEspecial(int num) { boolean aux = false;

if (num % 5 == // if (num % 3 // if (num % 5 // if (num % 7 { aux = !aux; } return aux; }

0 || == 0 == 0 == 0

num % 7 == 0) ) // para multiplos de 3 ) // para multiplos de 5 ) // para multiplos de 7

// F METODO - ERROR AL introducir letras public String letras()throws IOException { BufferedReader in=new BufferedReader(new InputStreamReader(System.in)); char a; char b; int t; int c; int y; String x; do { c=0; t=0; x=in.readLine(); String pert=x.replace(" ",""); y=pert.length(); for(int i=1; i<=y; i++) { a=65; b=pert.charAt(c); for(int j=65; j<=90; j++) { if(a==b) { t++; } a++; } c++; } c=0; for(int i=1; i<=y; i++) { a=97; b=pert.charAt(c); for (int j=97; j<=122; j++) { if(a==b) { t++; } a++; } c++; } c=1; if(t<y) { System.out.println("------------------------------------------------------------

------------"); System.out.println("- NO SE ACEPTA NROS ENTEROS NI SIMBOLOS QUE NO PERTENEZCAN A L ALFABETO -"); System.out.println("-----------------------------------------------------------------------"); } } while(!(t==y)); co=0; return x; } // G error al introducir numeros public int num()throws IOException { BufferedReader in=new BufferedReader (new InputStreamReader(System.in)); int x=0; int c=0; do { try { x=Integer.parseInt(in.readLine()); if(x>0) { } else { x=x*-1; } c=100; } catch(NumberFormatException e) { System.out.println("\n \7 - ERROR - "); System.out.println("********VUELVA A INTRODUCIR LO QUE SE PIDE POR FAVOR******** "); c++; } } while (!(c==100)); return x; }

// carnet de identidad maximo 7 numeros public int num2()throws IOException { BufferedReader in=new BufferedReader (new InputStreamReader(System.in)); int x=0; int c=0; int nibe; do{ try { do{ System.out.println("********RECUERDE QUE SON 7 DIGITOS POR FAVOR********"); System.out.print("C.I.:");x=Integer.parseInt(in.readLine()); String cos=String.valueOf(x); nibe=cos.length();

}while(!(nibe==7)); if(x>0) {} else { x=x*-1; } c=100; } catch(NumberFormatException a) { System.out.println("\7 ------- "); System.out.println("\7 - ERROR - "); System.out.println("\7 ------- "); System.out.println("********INTRODUZCA EL CARNET DE IDENTIDAD********"); c++; } }while (!(c==100)); return x; } // numero double ( con decimales ( 0,50 ..... )) public double num3()throws IOException { BufferedReader in=new BufferedReader (new InputStreamReader(System.in)); int co=0; do{ try{ do{ /*System.out.println("introdusca el tamao mayor a 50cm y menor a 3m");*/ xy=Double.parseDouble(in.readLine()); co=50; }while(!(xy<=3&&xy>=0.50)); }catch (NumberFormatException e) { System.out.println("---------------------------------------"); System.out.println("-\7 ERROR NO INTRODUSCA LETRAS NI COMAS -"); System.out.println("-\7 INTRODUSCA LA ESTATURA -"); System.out.println("---------------------------------------"); co++; } }while(!(co==50)); return xy; } /////////////////////////////// public void read() { char co; char ca; char cu; cu=177; ca=176; co=178; System.out.println("\t\t\t\5\5\6\6\6\6\6\3\3\3\3\3\3\3\3\3\3\3\3\3\3\6\6\6\6\6\5 \5"); System.out.println("\t\t\t\4\4 CARGANDO BASE DE DATOS \4\4"); System.out.println("\t\t\t\5\5\6\6\6\6\6\3\3\3\3\3\3\3\3\3\3\3\3\3\3\6\6\6\6\6\5

\5"); System.out.println(); System.out.println("-----------------------------------------------------------------------------"); System.out.print("- "); Thread t= Thread.currentThread(); try{ for(int j=1; j<=16; j++) { t.sleep(30); System.out.print(""+co); } for (int n=1;n<=10;n++){ t.sleep(40); System.out.print(""+cu); } for (int n=1;n<=20;n++){ t.sleep(28); System.out.print(""+cu); } for (int nr=1;nr<=28;nr++){ t.sleep(24); System.out.print(""+ca); } } catch(InterruptedException e){ } System.out.print(" -\n"); System.out.println("-----------------------------------------------------------------------------"); System.out.println(); } ////////////////////////////// public void read2() { char co1; char ca1; char cu1; cu1=177; ca1=176; co1=178; System.out.println(); System.out.println("-----------------------------------------------------------------------------"); System.out.print("- "); Thread t= Thread.currentThread(); try{ for(int j=1; j<=16; j++) { t.sleep(10); System.out.print(""+co1); } for (int n=1;n<=10;n++){ t.sleep(20); System.out.print(""+cu1); } for (int n=1;n<=20;n++){ t.sleep(8); System.out.print(""+cu1); }

for (int nr=1;nr<=28;nr++){ t.sleep(4); System.out.print(""+ca1); } } catch(InterruptedException e){ } System.out.print(" -\n"); System.out.println("-----------------------------------------------------------------------------"); System.out.println(); System.out.println("\t\t\t \5\5\6\6\6\6\6\3\3\3\3\3\3\3\3\6\6\6\6\6\5\5"); System.out.println("\t\t\t \4\4 PROCESO COMPLETO \4\4"); System.out.println("\t\t\t \5\5\6\6\6\6\6\3\3\3\3\3\3\3\3\6\6\6\6\6\5\5"); System.out.println(); System.out.println(); } /////////////////////////////////// public void Reloj () { { Thread t= Thread.currentThread(); t.setName ("cuenta regresiba"); System.out.println("Hora : "+t); System.out.println(); System.out.print(" LOADING .... "); try{ for (int n=1;n>0;n--){ t.sleep(1000); System.out.print("\7 I"); System.out.print("\7 N"); System.out.print("\7 I"); System.out.print("\7 C"); System.out.print("\7 I"); System.out.print("\7 A"); System.out.print("\7 N"); System.out.print("\7 D"); System.out.print("\7 O"); System.out.print("\t"); System.out.print("\t"); System.out.print("\7 P"); System.out.print("\7 R"); System.out.print("\7 O"); System.out.print("\7 G"); System.out.print("\7 R"); System.out.print("\7 A"); System.out.print("\7 M"); System.out.print("\7 A"); System.out.print(""); } } catch(InterruptedException e) { } } }

/// METODO TRY CATCH public int error()throws java.io.IOException { BufferedReader in=new BufferedReader (new InputStreamReader(System.in)); int x=0; try { x=Integer.parseInt(in.readLine()); } catch(NumberFormatException e) { System.out.println("\7\7 ERROR.!!!! DEBE INTRODUCIR SOLO NUMEROS :\7\7 "); System.out.println(); } return x; } // metodo principal - Funcion principal public static void main(String Args[])throws IOException { int dat=0; Lista obj=new Lista();// Declaracion del objeto BufferedReader in=new BufferedReader (new InputStreamReader(System.in)); int op; do { System.out.println(); System.out.println(" 1.System.out.println(" 2.System.out.println(" 3.System.out.println(" 4.System.out.println(" 5.System.out.println(" 6.System.out.println(" 7.System.out.println(" 8.System.out.println(" 9.System.out.println("10.System.out.println("11.System.out.println("12.); System.out.println("13.System.out.println("14.System.out.println("15.System.out.println("16.System.out.println("17.System.out.println("18.System.out.println("19.System.out.println("20.System.out.println("21.System.out.println("22.System.out.println("23.System.out.println("24.-

cargar pila int"); mostrar pila int"); invertir pila int"); borrar pila uno por uno int "); cargar cola con opciones"); mostrar cola int "); cargar cola int"); pasar de cola a lista multiplos de 3"); mostrar lista original int "); pasar de cola a pila int "); borrar elemento en cola uno por uno int "); busca un elemento en cola y ve cuantas veces se repite" sumar elementos de la pila int"); cargar pila string"); buscar elemento string en pila string"); mostrar pila string"); cola generar aleatoriamente"); sumar elementos de la cola int"); pila generar aleatoriamente "); buscar un elemento en la pila y eliminar"); mostrar cuantos pares e impares hay en cola"); invertir cola int"); pasar de lista a pila con sus elementos invertidos"); agregar al final lista ");

System.out.println("25.- cargar cola string "); System.out.println("26.- mostrar cola string "); System.out.println("27.- cargar pila int con opciones "); System.out.println("28.- borrar toda la pila "); System.out.println("29.- agregar al inicio lista "); System.out.println("30.- pasar lista par a pila y lista impar a cola "); System.out.println("31.- mayor de la lista "); System.out.println("32.- sumar los elementos de la lista"); System.out.println("33.- separar por posicion par e impar a pila y cola"); System.out.println("34.- buscar posicion en la lista y borrar"); System.out.println("35.- pasar de pila a lista int"); System.out.println("36.- pasar de pila a cola int "); System.out.println("37.- pasar factorial de lista a pila "); System.out.println("38.- pasar factorial de lista a cola "); System.out.println("39.- actualizar datos en la pila "); System.out.println("40.- actualizar datos en la cola "); System.out.print(" INTRODUZCA UNA OPCION = "); //Reloj u= new Reloj(); //obj.Reloj(); //obj.read(); op=obj.num(); switch(op) { // pila cargar pila case 1:{ System.out.print("\n Introducir un elemento = "); int ele=obj.num(); obj.cargarpila(ele); break;} // pila mostrar pila case 2:{ //System.out.print("\n Los elementos de la pila original son = \n"); obj.mostrarpila(); break;} // pila invertir pila case 3:{ System.out.print("\n La pila invertida es = \n"); obj.invertirpila(); break;} // pila borrar pila uno por uno case 4:{ obj.borrarpilaunoporuno(); break;} // cola cargar cola y seguir pidiendo cargar otra vez case 5:{ obj.cargarcolayseguirpidiendocargarotravez(); break;} // cola mostrar cola case 6:{ System.out.print("\n Los elementos de la cola original son = "); obj.mostrarcola(); break;} // cola cargar cola case 7:{ System.out.print("\n Introducir un elemento = "); int elemento=obj.num(); obj.cargarcola(elemento); break;} // cola pasar cola a lista solo multiplos de tres

case 8:{ obj.pasarColaAlistaMultiplosDtres(); break;} // lista mostrar lista case 9:{ obj.imprimirlistaoriginal(); break;} // cola pasar de cola a pila case 10:{ obj.pasarDeColaApila(); break;} // cola borrar cola sin utilizar for case 11:{ obj.borracolasinutilizarfor(); break;} // cola buscar un elemento en la cola case 12:{ System.out.print("\n introdusca elemento a buscar = "); int A=obj.num(); obj.buscarUnElementoEnLaCola(A); break;} // pila sumar elementos de la pila case 13:{ obj.sumarElementosDeLaPila(); break;} // pila string cargar pila string case 14:{ System.out.print("\n Introducir un nombre = "); String elementostring=obj.letras().toUpperCase(); obj.cargarpilastring(elementostring); break;} // pila string buscar un elemento en pila string case 15:{ obj.buscarUnElementoStringEnPilaString(); break;} // pila string mostrar pila string case 16:{ obj.mostrarPilaString(); break;} // cola generar elementos aleatoriamente case 17:{ System.out.print("\n Introducir cantidad de elementos = "); obj.n=obj.num(); obj.generarColaAleatoriamente(); break;} case 18:{ obj.sumarelementosdelacola(); break;} // pila generar elementos aleatoriamente case 19:{ System.out.print("\n Introducir cantidad de elementos = "); obj.n=obj.num(); obj.generarPilaAleatoriamente(); break;} // pila borrar un elemento de la pila case 20:{ System.out.print("\n Introducir cantidad de elementos = "); int n=obj.num(); obj.borrarUnElementoDeLaPila(n); break;}

// mostrar cuantos pares e impares case 21:{ System.out.println(" "); obj.mostrarcuantospareseimpares(); break;} // cola invertir cola case 22:{ System.out.println(" "); obj.invertircola(); break;} // lista pasar lista a pila con sus elementos invertidos case 23:{ System.out.println(" "); obj.pasarListaApilaInvirtiendoSusElementos(); break;} // lista agregar al final case 24:{ System.out.print("\n LISTA:ingrese un elemento: "); dat=obj.num(); obj.agregarAlFinal(new NodoListas(dat)); break;} // cola cargar cola string case 25:{ System.out.print("\n Introducir un elemento = "); String elementstring=obj.letras(); obj.cargarcolastring(elementstring); break;} // cola string mostrar cola string case 26:{ obj.mostrarColaString(); break;} // pila Cargar pila y seguir pidiendo cargar otra vez case 27:{ obj.cargarpilayseguirpidiendocargarotravez(); break;} // pila borrar toda la pila case 28:{ System.out.print(" toda la pila fue eliminada "); obj.borrarTodaLaPila(); break;} // lista Agregar al inicio case 29:{ System.out.print("\n LISTA:INGRESE UNA elemento = "); dat=obj.num(); obj.agregarAlInicio(new NodoListas(dat)); break;} // lista pasar lista par a pila y lista impar a cola case 30:{ obj.pasarListaParPilaUnoImparColaDos(); break;} // lista el mayor de la lista case 31:{ obj.mayorEnLaLista(); break;} // lista sumar los datos de la lista case 32:{ obj.sumarElementosDeLista(); break;} case 33:{ obj.separarParEimparPorPosicion();

break;} // lista buscar un dato en lista y borrar case 34:{ System.out.print("\n LISTA:INGRESE UN elemento a buscar y eliminar = "); int J=obj.num(); obj.buscarEnListaYborrar(J); break;} // pila pasar de pila a lista case 35:{ obj.pasarPilaAlista(); break;} // pila pasar de pila a cola case 36:{ obj.pasarDePilaAcola(); break;} case 37:{ obj.pasarFactorialDeListaApila(); break;} case 38:{ obj.pasarFactorialDeListaAcola(); break;} case 39:{ System.out.print("\n introdusca elemento a actualizar = "); int buscadoPila=obj.num(); obj.actualizarUnElementoEnPila(buscadoPila); break;} case 40:{ System.out.print("\n introdusca elemento a actualizar = "); int buscadoCola=obj.num(); obj.actualizarUnElementoEnCola(buscadoCola); break;} } } while(op!=41); } } // CREANDO CLASE DE LA LISTA class NodoListas { int dato; NodoListas siguiente; //public NodoListas siguiente; public NodoListas(int dat) { siguiente=null; dato=dat; } } /* Despues de bastantes comeduras de cabeza y de pruebas porfin lo he conseguido XD D lo he hecho por el metodo de la burbuja. Aqui os dejo el codigo por si a alguien le interesa... He definido size (osea el numero de elementos) al principio asi con tal solo mo dificar el 5 por el numero que se quiera, serian los numeros que se quieren comp

arar. He modificado el codigo otra vez para que los ordene de mayor a menor y de menor a mayor. Cdigo: #include <stdio.h> #define size 5 void main(void) { int vector[size]; int menor,mayor,temporal; printf("Introduce los %d valores para ordenar:\n",size); for(mayor=0; mayor<size; mayor++) { printf("[N%d]: ",mayor+1); scanf("%d", &vector[mayor]); } for(mayor=0; mayor<(size-1); mayor++) { for (menor=mayor+1; menor<size; menor++) { if(vector[menor]<vector[mayor]) { temporal=vector[menor]; vector[menor]=vector[mayor]; vector[mayor]=temporal; } } } printf("Los numeros ordenados de menor a mayor quedarian:\n"); for(mayor=0; mayor<size ; mayor++) { printf("%d ", vector[mayor]); } printf("\nLos numeros ordenados de mayor a menor quedarian:\n"); for(menor=size-1; menor>=0 ; menor--) { printf("%d ", vector[menor]); } mayor=vector[size-1]; menor=vector[0]; printf("\nEl numero mayor es %i",mayor); printf("\nEl numero menor es %i",menor); http://foro.elhacker.net/programacion_cc/programa_ordenar_numero_mayormenor-t234 758.0.html#ixzz1WXJ4gcrU */