Universidad Mariano Gálvez de Guatemala

Ingeniería en Sistemas
Programación 3

Tarea 02 Lista, Pilas,

Colas

Estudiante: Carné:

Manuel Alejandro Sazo Linares 7690-20-13585

Moses Daniel Melchor Morales 7690-18-4545

Sección: “B”

Guatemala 3 de marzo de 2023

Ejercicios 8.3
A continuación, se le presentara el código para la realización del código en el
Programa NetBeans.

Numero 1:
package listaenlaze;
import java.util.Scanner;

public class Principal {

public static void main(String[] args) {
// TODO Auto-generated method stub
Lista l=new Lista();
int menu=0,aux;
do{
menu=leerInt("----Menu----"
+ "\n0.Salir"
+ "\n1.Agregar Entero a la Lista"
+ "\n2.Imprimir Lista"
+ "\n3.Agregar un valor absoluto despues del Nodo");

switch(menu){
case 0:{
System.out.println("Programa Terminado");
break;
}
case 1:{
l.agregarNodo(leerInt("Ingrese el valor a agregar a la lista"));
break;
}
case 2:{
l.imprimir();
break;
}
case 3:{
aux=leerInt("Ingrese la posicion despues de la cual se agregara el valor
absoluto");
if(aux>=l.cont()||aux<1){//Se limita el ingreso para tener dos valores entre los
cuales ingresar el nuevo dato
System.out.println("Valor fuera del rango de la lista");
 }else{
l.agregarValor(aux);
System.out.println("Valor agregado a la lista");
}
break;
}
}
}while(menu!=0);
}
public static int leerInt(String texto){
Scanner leer= new Scanner(System.in);
System.out.println(texto);
return leer.nextInt();
}
}

Numero 2:
package listaenlaze;
public class Nodo {
private Nodo siguiente;
private int info;

public Nodo(int info) {

this.info = info;
}

public Nodo(Nodo siguiente, int info) {

this.siguiente = siguiente;
this.info = info;
}
public Nodo getSiguiente() {
return siguiente;
}
public void setSiguiente(Nodo siguiente) {
this.siguiente = siguiente;
}
public int getInfo() {
return info;
}
public void setInfo(int info) {
this.info = info;
}
}

Numero 3:
package listaenlaze;
public class Lista {
private Nodo inicio;
private Nodo fin;

public Lista(){
inicio=fin=null;
}

public void imprimir(){

Nodo aux=inicio;
int cont=1;
while(aux!=null){
System.out.println(cont+" "+aux.getInfo());
cont++;
aux=aux.getSiguiente();
}
}

public void agregarNodo(int valor){//Funcion basica para agregar un valor al final

de un lista simple
Nodo nuevo= new Nodo(valor);
if(fin!=null){
fin.setSiguiente(nuevo);
}else{
inicio=nuevo;
}
fin=nuevo;
}

public void agregarValor(int pos){

int cont=1;
Nodo aux=inicio;
Nodo aux2=inicio.getSiguiente();
if(pos<cont()&&pos>1){//Se controla que el numero ingresado sea valido para la
ejecucion de la aplicacion.
while(aux2!=null){//se controla en base a la cual se mas posible llegue a ser un
valor nulo
if(cont==pos){//si se encuentra un valor igual al especificado se rompe el ciclo
break;
}
cont++;
aux=aux2;
 aux2=aux2.getSiguiente();
}
if(cont==pos&&aux2!=null){//Si los valores son iguales se agrega el valor
absoluto entre los dos nodos.
Nodo nuevo=new Nodo(Math.abs(aux.getInfo()-aux2.getInfo()));
aux.setSiguiente(nuevo);
nuevo.setSiguiente(aux2);
}
}
}

public int cont(){//Realiza el calculo del numero total de valores de la lista

Nodo aux=inicio;
int cont=0;
while(aux!=null){
cont++;
aux=aux.getSiguiente();
}
return cont;
}
}
Ejercicios 8.6
A continuación, se le presentara el código para la realización del código en el
Programa NetBeans.

Numero 1:
package listareal;

import java.util.Scanner;

public class Principal {

public static void main(String[] args)
{
Scanner lectura=new Scanner(System.in);
Lista coleccion=new Lista();
int n=5, dato;
System.out.println("Ejercicio 1- Listas Simples\n");
for(int i=0;i<n;i++)
{
System.out.println("Ingrese el elemento "+(i+1)+" de la lista");
dato=lectura.nextInt();
coleccion.agregarInicio(dato);
}
System.out.println("Lista ingresada:");
coleccion.imprimir();

System.out.println("\nLista ordenada de mayor a menor");

coleccion.ordenarMayorMenor(n);

coleccion.promedio();
coleccion.repeticiones(n);
}
}
Numero 2:
package listareal;

public class Nodo {

//Declaración de atributos
private int dato;
private Nodo siguiente;
//Constructor Nodo null
public Nodo(int dato)
{
this.dato=dato;
this.siguiente=null;
}
//Constructor Nodo con parametro
public Nodo(int dato, Nodo siguiente)
{
this.dato=dato;
this.siguiente=siguiente;
}

//Metodos getters and setters

public int getDato() {
return dato;
}

public void setDato(int dato) {

this.dato = dato;
}

public Nodo getSiguiente() {

return siguiente;
}

public void setSiguiente(Nodo siguiente) {

this.siguiente = siguiente;
}
}
Numero 3:
package listareal;

public class Lista {

private Nodo inicio;
private Nodo fin;

public Lista()
{
inicio=fin=null;
}
//Metodo para agregar inicio
public void agregarInicio(int info)
{
Nodo nuevo=new Nodo(info, inicio);
if(inicio==null)
{
inicio=fin=nuevo;
}
inicio=nuevo;
}

//Metodo para agregar fin

public void agregarFin(int info)
{
Nodo nuevo=new Nodo(info, null);
if(inicio==null)
{
inicio=fin=nuevo;
}
else
{
fin.setSiguiente(nuevo);
fin=nuevo;
}
}

//Metodo para imprimir

public void imprimir()
{
Nodo aux=inicio;
while(aux!=null)
{
System.out.println(aux.getDato());
aux=aux.getSiguiente();
}
}

//Metodo para eliminar el nodo

public void eliminarNodo(int numero)
{
if(inicio!=null)
{
if((inicio==fin)&&(inicio.getDato()==numero))
 {
inicio=fin=null;
}
else if(inicio.getDato()==numero)
{
inicio=inicio.getSiguiente();
}
else
{
Nodo anterior=inicio;
Nodo siguiente=inicio.getSiguiente();
while((siguiente!=null)&&(siguiente.getDato()!=numero))
{
anterior=siguiente;
siguiente=siguiente.getSiguiente();
}
if(siguiente!=null)
{
anterior.setSiguiente(siguiente.getSiguiente());
if(siguiente==fin)
{
fin=anterior;
}
}
}
}
}

//Metodo ordenar de mayor a menor

public void ordenarMayorMenor(int info)
{
int aux;
Nodo recorrer=inicio;
int array[]=new int [info];
for(int i=0;i<info;i++)
{
array[i]=recorrer.getDato();
recorrer=recorrer.getSiguiente();
}
for(int k=0;k<info;k++)
{
for(int j=k+1;j<info;j++)
{
 if(array[k]<array[j])
{
aux=array[k];
array[k]=array[j];
array[j]=aux;
}
}
}
Lista nueva=new Lista();
for(int f=0;f<info;f++)
{
nueva.agregarFin(array[f]);
}
nueva.imprimir();
}

//Metodo para calcular el promedio de la lista

public void promedio()
{
Nodo aux=inicio;
int suma=0;
double promedio;
while(aux!=null)
{
suma= suma+ aux.getDato();
aux=aux.getSiguiente();
}
promedio=suma/5;
System.out.println("El promedio de la lista es:"+promedio);
}

//Metodo para obtener el numero que más se repite y su frecuencia de repeticion

public void repeticiones(int inf)
{
int frecTemp, frecModa=0, moda=-1;
Nodo recorrer=inicio;
int array[]=new int [inf];
for(int i=0;i<inf;i++)
{
array[i]=recorrer.getDato();
recorrer=recorrer.getSiguiente();
}
for(int i=0;i<array.length-1;i++)
 {
frecTemp=1;
for(int j=i+1;j<array.length;j++)
{
if(array[i]==array[j])
frecTemp++;
}
if(frecTemp>frecModa)
{
frecModa=frecTemp;
moda=array[i];
}
}
System.out.println("El elemento más repetido en la lista es: "+moda+", con una
frecuencia de: "+frecModa);
}
}

Video de Referencia para el Uso del Código

8.3 y 8.6
https://youtu.be/ewHO9odvwrg

Ejercicios 9.2
Numero 1:

package main;

import java.util.Scanner;
import java.util.Stack;

/**
*
* @author sanli
*/
public class Main {
 public static void main(String[] args) {
Stack<String> pila = new Stack<String>();

Scanner scanner = new Scanner(System.in);

System.out.print("Ingrese los elementos de la pila separados por espacios: ");
String entrada = scanner.nextLine();
String[] elementos = entrada.split(" ");

for (String elemento : elementos) {

pila.push(elemento);
}

mostrarPila(pila);
}

public static void mostrarPila(Stack<String> pila) {

Stack<String> pilaAuxiliar = new Stack<String>();

while (!pila.isEmpty()) {
String elemento = pila.pop();
pilaAuxiliar.push(elemento);
}

while (!pilaAuxiliar.isEmpty()) {
String elemento = pilaAuxiliar.pop();
System.out.println(elemento);
pila.push(elemento);
}
}
}

Video de Referencia para el Uso del Código

9.2
https://youtu.be/lT8Qvjy5MII
Ejercicios 9.3
Video de Referencia para el Uso del Código 9.3
URL: https://youtu.be/Kv9nZJiQCVY
import java.util.Stack;
public class tests {
// Funcion que convierte una expresion matematica en notacion infija a notacion postfija
public static String convertirInfijaPostfija(String infija) {
StringBuilder postfija = new StringBuilder(); // StringBuilder para construir la cadena de salida
Stack<Character> pila = new Stack<>(); // Pila para almacenar los operadores
// Recorre cada caracter de la expresion infija
for (int i = 0; i < infija.length(); i++) {
char c = infija.charAt(i);
// Si el caracter es un operando, se anade a la salida
if (Character.isLetterOrDigit(c)) {
postfija.append(c);
}
// Si el caracter es un parentesis de apertura, se anade a la pila
else if (c == '(') {
pila.push(c);
}
// Si el caracter es un parentesis de cierre, se sacan los operadores de la pila y se anaden a la salida
// hasta encontrar el parentesis de apertura correspondiente
else if (c == ')') {
while (!pila.isEmpty() && pila.peek() != '(') {
postfija.append(pila.pop());
}
if (!pila.isEmpty() && pila.peek() == '(') {
pila.pop(); // saca el parentesis de apertura de la pila
}
}

// Si el caracter es un operador, se sacan los operadores de la pila y se anaden a la salida

// mientras tengan mayor o igual precedencia que el operador actual
else {
while (!pila.isEmpty() && precedencia(pila.peek()) >= precedencia(c)) {
postfija.append(pila.pop());
}
pila.push(c); // anade el operador actual a la pila
}
}

// Saca los operadores restantes de la pila y los anade a la salida

while (!pila.isEmpty()) {
postfija.append(pila.pop());
 }

return postfija.toString(); // devuelve la cadena en notacion postfija

}

// Funcion que devuelve la precedencia de un operador

public static int precedencia(char operador) {
switch (operador) {
case '+':
case '-':
return 1;
case '*':
case '/':
return 2;
case '^':
return 3;
default:
return -1;
}
}

// Ejemplo de uso
public static void main(String[] args) {
String infija = "(x-y)/(z+w) – (z+y)^x";
String postfija = convertirInfijaPostfija(infija);
System.out.println(postfija); // Salida esperada: "abc*+def^/g*-"
}

14.7 buscarmin() método recursivo

public void buscarmin(Nodo nodo, int valor) {

if (nodo.izq != null) {
buscarmin(nodo.izq, valor);
}
if (nodo.valor <= valor) {
System.out.println(valor);
}
if (nodo.der != null) {
buscarmin(nodo.der, valor);
}
}

14.7 buscarmax() método recursivo

public void buscarmin(Nodo nodo, int valor) {
if (nodo.izq != null) {
buscarmin(nodo.izq, valor);
}
if (nodo.valor >= valor) {
System.out.println(valor);
}
if (nodo.der != null) {
buscarmin(nodo.der, valor);
}
}