Práctica02 - Lab131

UNIVERSIDAD MAYOR DE SAN ANDRES
Facultad de Ciencias Puras y Naturales

Carrera de Informática
Nombres y Apellidos: Eddy Gonzalo Ortiz Machicado Cedula de Identidad: 3469141 Lp.
Materia: Lab-131 Paralelo: B
Fecha: 15/Marzo/2023 Gestión: I - 2023
Docente: Lic. Victoria Hurtado Cerruto
Tema: Estructura de Datos (Pilas)
PRACTICA N° 2
EJERCICIO 1
a) Enunciado
Dada una Pila de enteros:
a) Colocar al principio los datos únicos y luego los repetidos.
b) Diagrama de Clases
Entero
- entero: int
+ entero()
+ entero(entero)
+ getters()
+ setters()
+ leerE():void
+ mostrarE():void
PilaEnteros + leerE(): void
+ mostrarE():void
- n: int
- tope: int
- v[]: Entero
+ PilaEnteros()
+ esVacia(): boolean
+ esLlena(): boolean
+ adicionar(it:entero): void
+ eliminar: Entero
+ llenar():void
+ mostrar(): void
+ vaciar(z: PilaEnteros):void
c) Código Java
Main
public class Main {
public static void main(String[] args) {

Scanner teclado = new Scanner(System.in);
PilaEnteros pe = new PilaEnteros();
// CARGAR PILA DE ENTEROS

cargarPilaE(pe);
System.out.println("PILA ORIGINAL");
pe.mostrar();
// a) Dada una Pila de enteros colocar al principio los datos unicos

y luego los repetidos.
System.out.println("\n.....................................................
................................");
System.out.println(".................................... SOLUCION 1
.....................................");
solucion1(pe);
pe.mostrar();
System.out.println(".......................................................
..............................");

private static void cargarPilaE(PilaEnteros pe) {
pe.adicionar(new Entero(2));
}
// SOLUCION 1
private static void solucion1(PilaEnteros PE) {
PilaEnteros aux1 = new PilaEnteros();
PilaEnteros R = new PilaEnteros();
while (! PE.esVacia()) {
Entero elem1 =PE.eliminar();
while(! PE.esVacia()) {
Entero elem2=PE.eliminar();
if(elem1.getEntero() == elem2.getEntero()) {
R.adicionar(elem2);
}
else {
aux2.adicionar(elem2);
}
}
PE.vaciar(aux2);
}
PE.vaciar(aux1);
agruparRepetidos(PE,R);
}
// AGRUPAR ENTEROS REPETIDOS
private static PilaEnteros agruparRepetidos(PilaEnteros PE, PilaEnteros R)
{
PilaEnteros Q = new PilaEnteros();
while (!R.esVacia()) {
Entero elem1=R.eliminar();
while (!PE.esVacia()) {
Entero elem2=PE.eliminar();
if(elem1.getEntero()==elem2.getEntero()) {
Q.adicionar(elem2);
}
else {
}
}
PE.vaciar(aux1);
}
R.vaciar(aux2);
R.vaciar(Q);
PE.vaciar(ordenarRepetidos(R));
return PE;
}
// ORDENAR ENTEROS REPETIDOS

private static PilaEnteros ordenarRepetidos(PilaEnteros Q) {
PilaEnteros aux = new PilaEnteros();
while (!Q.esVacia()) {
Entero e1=Q.eliminar();
while (!Q.esVacia()) {
Entero e2=Q.eliminar();
if(e1.getEntero()==e2.getEntero()) {
R.adicionar(e2);
}
else {
aux.adicionar(e2);
}
}
R.adicionar(e1);
Q.vaciar(aux);
}
Q.vaciar(R);
return Q;
}
}
Clase Pilas
public class PilaEnteros {

private int max;
private Entero v[];
private int tope;
PilaEnteros(){
tope = 0;
max = 100;
v = new Entero[max+1];
}
boolean esVacia (){

if (tope == 0) {
return (true);
}
else {
return (false);
}
}
boolean esLlena (){

if (tope == (max)) {
return (true);
}
else {
return (false);
}
}
int nroElem (){

return (tope);
}
void adicionar (Entero elem){

if (!esLlena ()){
tope++;
v [tope] = elem;
}
else {
System.out.println ("Pila llena!!! ");
}
}
Entero eliminar (){

Entero elem = new Entero();
if (!esVacia ()){
elem = v [tope];
tope--;
}
else {
System.out.println ("Pila vacia");
}
return (elem);
}
void mostrar (){

if (esVacia ()) {
}
else{
System.out.println ("\n Entero(s) de la Pila ");
System.out.println("*******************************************************
******************************");
PilaEnteros aux = new PilaEnteros ();
while (!esVacia ()){
Entero elem = eliminar ();
aux.adicionar (elem);
elem.mostrarL();
}
vaciar(aux);
******************************");
}
}
void llenar(int n) {
for(int i=1; i<=n;i++) {
elem.leerL();
adicionar(elem);
}
}
void vaciar (PilaEnteros a){

while (!a.esVacia ()) {
adicionar (a.eliminar ());
}
}
}
d) Prueba de Corrida
EJERCICIO 2
a) Enunciado
Dada una Pila de Telas <marca, color, precio> se pide:
a) Cual es el color que predomina
b) A cuanto asciende el costo de las telas
c) Mostrar la Marca de las telas de colo (Z);
Tela
- marca: String
- color: String
- precio: double
+ entero()
+ entero(entero)
+ getters()
+ setters()
PilaTelas + leerE():void
+ mostrarE():void
- n: int + leerE(): void
- tope: int + mostrarE():void
- v[]: Tela
+ PilaEnteros()
+ eliminar: Entero
+ llenar():void
+ mostrar(): void
+ vaciar(z: PilaTelas):void
c) Codigo JAVA
Main
public class Main {

PilaTelas pt = new PilaTelas();
//CARGAR PILA DE TELAS

cargarPilaT(pt);
pt.mostrar();
// Dada una Pila de Telas <marca, color, precio> se pide:
// a) Cual es el color que predomina
................................");
System.out.println(".................................... SOLUCION A
.....................................");
solucionA(pt);
..............................");
// b) A cuanto asciende el costo de las telas
................................");
System.out.println(".................................... SOLUCION B
.....................................");
solucionB(pt);
..............................");
// c) Mostrar la Marca de las telas de colo (Z);
................................");
System.out.println(".................................... SOLUCION C
.....................................");
System.out.print("Buscar COLOR (Z) ---> ");
String z = teclado.nextLine();
solucionC(pt,z);
..............................");
}
// CARGAR PILA TELAS

private static void cargarPilaT(PilaTelas pt) {
pt.adicionar(new Tela("Asatex","Blanco",125.50));
pt.adicionar(new Tela("Casemir","Negro",220));
pt.adicionar(new Tela("Aldecor","Negro",360));
pt.adicionar(new Tela("Asatex","Plomo",225));
pt.adicionar(new Tela("Cansedo","Rosado",155));
pt.adicionar(new Tela("Asatex","Blanco",134));
pt.adicionar(new Tela("Telas.es","Negro",260));
pt.adicionar(new Tela("Casemir","Rosado",380));
pt.adicionar(new Tela("Globaltex","Blanco",236.50));
pt.adicionar(new Tela("Asatex","Negro",456.5));
pt.adicionar(new Tela("Asatex","Blanco",400.5));
pt.adicionar(new Tela("Casemir","Negro",560.5));
}
// SOLUCION A
private static void solucionA(PilaTelas PT) {
int mayorColor = obtenerColorPredomina(PT);
PilaTelas auxZ = new PilaTelas();
while (!PT.esVacia()) {
Tela elem = PT.eliminar();
int coCO = contadorColor(PT, elem.getColor());
if(coCO == mayorColor) {
elem.mostrarT();
}
auxZ.adicionar(elem);
}
PT.vaciar(auxZ);
}
// FUNCION OBTENER MAYOR

private static int obtenerColorPredomina(PilaTelas PT) {
int mayor = Integer.MIN_VALUE;
PilaTelas aux = new PilaTelas();
int coCO = contadorColor(PT, elem.getColor());
if(coCO > mayor) {
mayor = coCO;
}
aux.adicionar(elem);
}
PT.vaciar(aux);
return mayor;
}
// FUNCION CONTAR COLOR

private static int contadorColor(PilaTelas PT, String color) {
int contador = 0;
if(elem.getColor() == color) {
contador++;
}
}
PT.vaciar(aux);
return contador;
}
// SOLUCION B
private static void solucionB(PilaTelas PT) {
double contador = 0;
contador=contador+elem.getPrecio();
}
PT.vaciar(aux);
System.out.println("Costo Total (Telas)"+"\n"+"TOTAL: "+contador+"
bs.");
}
// SOLUCION C
private static void solucionC(PilaTelas PT, String Z) {
if(elem.getColor().equalsIgnoreCase(Z)) {
System.out.println("MARCA: "+elem.getMarca());
}
}
PT.vaciar(aux);
}
}
Clase Tela
public class Tela {
private String marca;
private String color;
private double precio;
// Constructor por defecto

public Tela() {
this.marca = "";
this.color = "";
this.precio = 0;
}
// Constructor con parae

public Tela(String marca, String color, double precio) {
super();
this.marca = marca;
this.color = color;
this.precio = precio;
}
// Getters y Setters
public String getMarca() {
return marca;
}
public void setMarca(String marca) {

this.marca = marca;
}
public String getColor() {

return color;
}
public void setColor(String color) {

this.color = color;
}
public double getPrecio() {

return precio;
}
public void setPrecio(double precio) {

this.precio = precio;
}
//To String
@Override
public String toString() {
return "Tela [marca=" + marca + ", color=" + color + ", precio=" +
precio + "]";
}
// Metodo leer Tela

public void leerT() {
System.out.println("----------------> LEER-TELA <-----------------"
);
System.out.print("Marca ---> ");

this.marca = teclado.nextLine();
System.out.print("Color ---> ");

this.color = teclado.nextLine();
System.out.print("Precio ---> ");

this.precio = teclado.nextDouble();
}
// Metodo mostrar Tela

public void mostrarT() {
//System.out.println("----------------> MOSTRAR-TELA <---------------
--" );
//System.out.println("*****************************************************
***************************" );
System.out.println(toString());
}
}
Clase PilaTelas
public class PilaTelas {

private int max;
private Tela v[];
private int tope;
PilaTelas(){
tope = 0;
max = 100;
v = new Tela[max+1];
}
boolean esVacia (){

if (tope == 0) {
return (true);
}
else {
return (false);
}
}
boolean esLlena (){

return (true);
}
else {
return (false);
}
}
int nroElem (){

return (tope);
}
void adicionar (Tela elem){

if (!esLlena ()){
tope++;
v [tope] = elem;
}
else {
}
}
Tela eliminar (){

Tela elem = new Tela();
if (!esVacia ()){
elem = v [tope];
tope--;
}
else {
}
return (elem);
}
void mostrar (){

if (esVacia ()) {
}
else{
System.out.println ("\n Tela(s) de la Pila ");
******************************");
PilaTelas aux = new PilaTelas ();
Tela elem = eliminar ();
elem.mostrarT();
}
vaciar(aux);
******************************");
}
}
Tela elem = new Tela();
elem.leerT();
adicionar(elem);
}
}
void vaciar (PilaTelas a){

}
}
}
a) Enunciado
Dada dos pilas con numeros enteros, se pide generar otra pila de modo que a un par le siga un impar.
* Nota las pilas deben tener el mismo numero de elementos
A: 3, 1, 8, 2, 6, 4
B: 5, 8, 4, 7, 9,10
Salida: 8, 3, 2, 1, 6, 5, 4, 7, 8, 9, 4, 10
Entero
- entero: int
+ entero()
+ entero(entero)
+ getters()
+ setters()
+ leerE():void
+ mostrarE():void
PilaEnteros + leerE(): void
+ mostrarE():void
- n: int
- tope: int
- v[]: Entero
+ PilaEnteros()
+ eliminar: Entero
+ llenar():void
+ mostrar(): void
+ vaciar(z: PilaEnteros):void
c) Codigo JAVA
Main
public class Main {

PilaEnteros A = new PilaEnteros();
PilaEnteros B = new PilaEnteros();

cargarPilaE(A,B);
System.out.println("PILA A");
A.mostrar();
System.out.println("PILA B");
B.mostrar();
/* Dada dos pilas con numeros enteros, se pide generar otra pila de
modo que a un par le siga un impar.
* Nota las pilas deben tener el mismo numero de elementos*/
................................");
System.out.println(".................................... SOLUCION 1
.....................................");
solucion1(A,B);
................................");

private static void cargarPilaE(PilaEnteros A, PilaEnteros B) {
A.adicionar(new Entero(4));
B.adicionar(new Entero(10));
}
// MOSTRAR PILA
private static void mostrarPila(PilaEnteros B) {
PilaEnteros aux = new PilaEnteros();
PilaEnteros v = new PilaEnteros();
v.vaciar(B);
System.out.print("[");
while(!v.esVacia()) {
Entero elem = v.eliminar();
System.out.print(elem.getEntero()+", ");
}
v.vaciar(aux);
System.out.print("]");
}
// SOLUCION 1
private static void solucion1(PilaEnteros A, PilaEnteros B) {
System.out.println("SALIDA");
mostrarPila(seleccionarParImpar(A, B));
}
//SELECCIONAR PAR IMPAR

private static PilaEnteros seleccionarParImpar(PilaEnteros A, PilaEnteros
B) {
PilaEnteros impar = new PilaEnteros();
PilaEnteros par = new PilaEnteros();
while(!A.esVacia()) {
Entero elem1=A.eliminar();
if(elem1.getEntero()%2==0){
par.adicionar(elem1);
}
else {
impar.adicionar(elem1);
}
}
while(!B.esVacia()) {
Entero elem2=B.eliminar();
if(elem2.getEntero()%2==0){
par.adicionar(elem2);
}
else {
impar.adicionar(elem2);
}
}
A.vaciar(par);
B.vaciar(impar);
return (intercalarP(A, B));
}
//FUNCION INTERCALAR
private static PilaEnteros intercalarP(PilaEnteros par, PilaEnteros impar)
{
int n=(par.nroElem()+impar.nroElem());
for(int i=0;i<=(n);i++) {
if(i%2==0) {
par.vaciar(aux1);
while (!par.esVacia()) {
Entero elemP=par.eliminar();
R.adicionar(elemP);
aux1.vaciar(par);
}
}
else {
impar.vaciar(aux2);
while (!impar.esVacia()) {
Entero elemI=impar.eliminar();
R.adicionar(elemI);
aux2.vaciar(impar);
}
}
}
return R;
}
}
Clase Entero
public class Entero {

private int entero;
// Constructor por defecto

public Entero() {
this.entero = entero;
}
// Constructor con parametros

public Entero(int entero) {
super();
}
// Getters y Settesr
public int getEntero() {
return entero;
}
public void setEntero(int entero) {

}
//To String
@Override
public String toString() {
return "Entero [entero=" + entero + "]";
}
// Metodo leer Entero

public void leerL() {
System.out.println("---------------> LEER-ENTERO <----------------"
);
System.out.print("Entero ---> ");
this.entero = teclado.nextInt();
}
// Metodo mostrar Entero

public void mostrarL() {
//System.out.println("---------------> MOSTRAR-ENTERO <--------------
--" );
//System.out.println("*****************************************************
***************************" );
System.out.println(toString());
}
}
Clase PilaEnteros
public class PilaEnteros {

private int max;
private Entero v[];
private int tope;
PilaEnteros(){
tope = 0;
max = 100;
v = new Entero[max+1];
}
boolean esVacia (){

if (tope == 0) {
return (true);
}
else {
return (false);
}
}
boolean esLlena (){

return (true);
}
else {
return (false);
}
}
int nroElem (){

return (tope);
}
void adicionar (Entero elem){

if (!esLlena ()){
tope++;
v [tope] = elem;
}
else {
}
}
Entero eliminar (){

if (!esVacia ()){
elem = v [tope];
tope--;
}
else {
}
return (elem);
}
void mostrar (){

if (esVacia ()) {
}
else{
System.out.println ("\n Entero(s) de la Pila ");
******************************");
PilaEnteros aux = new PilaEnteros ();
Entero elem = eliminar ();
elem.mostrarL();
}
vaciar(aux);
******************************");
}
}
elem.leerL();
adicionar(elem);
}
}
void vaciar (PilaEnteros a){

}
}
}

Práctica02 - Lab131

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Práctica02 - Lab131

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD MAYOR DE SAN ANDRES

Facultad de Ciencias Puras y Naturales

public class Main {

public static void main(String[] args) {

// CARGAR PILA DE ENTEROS

// a) Dada una Pila de enteros colocar al principio los datos unicos

// CARGAR PILA DE ENTEROS

// ORDENAR ENTEROS REPETIDOS

public class PilaEnteros {

boolean esVacia (){

boolean esLlena (){

int nroElem (){

void adicionar (Entero elem){

Entero eliminar (){

void mostrar (){

void vaciar (PilaEnteros a){

public static void main(String[] args) {

PilaTelas pt = new PilaTelas();

//CARGAR PILA DE TELAS

// Dada una Pila de Telas <marca, color, precio> se pide:

// a) Cual es el color que predomina

// b) A cuanto asciende el costo de las telas

// c) Mostrar la Marca de las telas de colo (Z);

// CARGAR PILA TELAS

// FUNCION OBTENER MAYOR

// FUNCION CONTAR COLOR

// Constructor por defecto

// Constructor con parae

public void setMarca(String marca) {

public String getColor() {

public void setColor(String color) {

public double getPrecio() {

public void setPrecio(double precio) {

// Metodo leer Tela

System.out.print("Marca ---> ");

System.out.print("Color ---> ");

System.out.print("Precio ---> ");

// Metodo mostrar Tela

public class PilaTelas {

boolean esVacia (){

boolean esLlena (){

int nroElem (){

void adicionar (Tela elem){

Tela eliminar (){

void mostrar (){

void vaciar (PilaTelas a){

public static void main(String[] args) {

// CARGAR PILA DE ENTEROS

// CARGAR PILA DE ENTEROS

//SELECCIONAR PAR IMPAR

public class Entero {

// Constructor por defecto

// Constructor con parametros

public void setEntero(int entero) {

// Metodo leer Entero

// Metodo mostrar Entero

public class PilaEnteros {

boolean esVacia (){

boolean esLlena (){

int nroElem (){

void adicionar (Entero elem){

Entero eliminar (){

void mostrar (){

void vaciar (PilaEnteros a){