TAREA 4 LISTAS SIMPLES

NOMBRE: PEPITO PEREZ CI: 1234567 L.P.

MATERIA: LABORATORIO INF-131 PARALELO: “Z”

public class NodoS {
Object dato;
NodoS sig; NodoS()
{ dato = null;
sig = null;
}
public Object getDato() {
return dato;
}
public void setDato(Object d) {
this.dato = d;
}
public NodoS getSig() {
return sig;
}
public void setSig(NodoS sig) {
this.sig = sig;
}
}

import java.util.Scanner;
public class LSNormal {
private NodoS Cabecera;
Scanner lee = new Scanner(System.in);
public LSNormal() {
Cabecera = null;
}
public void adiInicio(Object x) {
NodoS nuevo = new NodoS();
nuevo.setDato(x);
if (getCabecera() == null) {
// la lista vacia
setCabecera(nuevo);
} else {
// la lista tiene datos
nuevo.setSig(Cabecera);
setCabecera(nuevo);
}
}
public void adiFin(Object x) {
NodoS nuevo = new NodoS();
nuevo.setDato(x);
if (getCabecera() == null) {
// lista vacia setCabecera(nuevo); }
else {
// lista con datos
NodoS p = getCabecera();
while (p.getSig() != null) {
p = p.getSig();
}
p.setSig(nuevo);
 }
}
void adicionarFinal(NodoS x) {
if(getCabecera()==null) {
//lista vacia setCabecera(x); }else
{
//lista con datos NodoS p=getCabecera();
while(p.getSig()!=null) {
p=p.getSig();

}
p.setSig(x);
}
}
public void mostrar() {
NodoS p = getCabecera(); while (p != null) {
System.out.print(p.getDato());
System.out.println();
p = p.getSig();
}
System.out.println();
}
public int nroNodos() {
int cont = 0;
NodoS p = getCabecera(); while (p != null) {
cont++;
p = p.getSig();
}
return cont;
}
// adicionarInicio
public void llenar1(int n) {
for (int i = 0; i <n; i++) {
int x=lee.nextInt();
adiInicio(x);
}
}
// adicionarFinal
public void llenar2(int n) {
for (int i = 0; i <n; i++) {
int x=lee.nextInt();
adiFin(x);
}
}
public NodoS eliInicio() {
NodoS eli=getCabecera(); if(getCabecera()!=null) {
setCabecera(getCabecera().getSig());
eli.setSig(null);
}
return eli;
}
public NodoS getCabecera() {
 return Cabecera;
}
public void setCabecera(NodoS Cabecera) {
this.Cabecera = Cabecera;
}
}
public class LSCircular {
private NodoS Cabecera;

LSCircular() {
Cabecera = null;
}
//adicionarFinal

void adiFin(Object x) {
NodoS nuevo =new NodoS();
nuevo.setDato(x); if(getCabecera()==null) {
//lista vacia nuevo.setSig(nuevo);
setCabecera(nuevo); }else {
//lista con datos
NodoS p=getCabecera();
while(p.getSig()!=getCabecera()) {
p=p.getSig();
}
p.setSig(nuevo);
nuevo.setSig(getCabecera());

}
}
void adicionarFinal(NodoS x) {
if(getCabecera()==null) {
//lista vacia
x.setSig(x);
setCabecera(x); }else {
//lista con datos
NodoS p=getCabecera();
while(p.getSig()!=getCabecera()) {
p=p.getSig();
}
p.setSig(x);
x.setSig(getCabecera());
}
}
public void mostrar() {
NodoS p=getCabecera(); if(getCabecera()!=null) {
do {
System.out.println(p.getDato());
p=p.getSig();
} while (p!=getCabecera());
}else
System.out.println("Lista vacia");
}
 public void mostrar2() {
NodoS p=getCabecera(); int
n=nroNodos();
for (int i = 0; i < n; i++) {
System.out.println(p.getDato());
p=p.getSig();
}
}

public int nroNodos() {

NodoS p=getCabecera(); int
cont=0;
if(getCabecera()!=null) {
do {
p=p.getSig();
cont++;
} while (p!=getCabecera());
}
return cont;
}
public NodoS eliInicio() {
NodoS p=getCabecera();
NodoS q=getCabecera();
if(nroNodos()==1)
{ setCabecera(null);
}else {

while(q.getSig()!=getCabecera()) {
q=q.getSig();
}
q.setSig(getCabecera().getSig());
setCabecera(p.getSig());

}
p.setSig(null);
return p;
}
public NodoS getCabecera() {
return Cabecera;
}
public void setCabecera(NodoS Cabecera) {
this.Cabecera = Cabecera;
}

1. Dada una lista simple normal Z se pide eliminar el par mas grande.

1. Libre
2. No utilizar nuevos nodos
import java.util.Scanner; public
class INF_131_4_1 {
public static void main(String[] args) {
Scanner lee=new Scanner(System.in);
LSNormal Z=new LSNormal();
Object dato;
 System.out.print("introduzca cantidad de elementos: ");
int m=lee.nextInt(),c=0; for (int
i = 0; i < m; i++) {
dato=(Object)lee.nextInt();
if((int)dato%2==0)
c++;
Z.adiFin(dato);
}
Z.mostrar();
int cont=0;
System.out.println("cantidad de pares "+c);
//inciso a
System.out.println("INCISO A");
NodoS p3=Z.getCabecera(); LSNormal aux1=new
LSNormal(); int n=Z.nroNodos();
for (int i = 0; i < n; i++) {
if((int)p3.getDato()%2==0) {
cont++;
if(cont!=c) {
aux1.adiFin(p3.getDato());
}
}
else
aux1.adiFin(p3.getDato());
p3=p3.getSig();
}
aux1.mostrar();
//inciso b
System.out.println("INCISO B");
cont=0;
NodoS p=Z.getCabecera(),q,p1; LSNormal aux=new
LSNormal(); for (int i = 0; i < n; i++) {
q=p.getSig();
p.setSig(null);
if((int)p.getDato()%2==0) {
cont++;
if(cont!=c) {
//aux.adiFinal(p);
if(aux.getCabecera()==null) {
//lista vacia
aux.setCabecera(p);
}else {
//lista con datos
p1=aux.getCabecera();
while(p1.getSig()!=null) {
p1=p1.getSig();
}
p1.setSig(p);
}
}
}
else
aux.adicionarFinal(p);
p=q;
}
 aux.mostrar();
}
}

2.Dadas dos listas simples normales se pide insertar la lista más pequeña en la
lista más grande de modo que los datos queden ordenados. No crear nuevos
nodos.
import java.util.Scanner; public
class INF_131_4_2 {
public static void main(String[] args) {
Scanner lee=new Scanner(System.in);
LSNormal lista1=new LSNormal();
LSNormal lista2=new LSNormal();
Object dato;
System.out.print("Introduzca cantidad de elementos: ");
int n=lee.nextInt();
for (int i = 0; i < n; i++) {
dato=(Object)lee.nextInt();
lista1.adiFin(dato);
}
System.out.print("Introduzca cantidad de elementos: ");
int m=lee.nextInt();
for (int i = 0; i < m; i++) {
dato=(Object)lee.nextInt();
lista2.adiFin(dato);
}
System.
lista1.
System.out.println("Lista 1");
lista2.mostrar();
int n1= out.println("Lista 2");
if mostrar();
(n1>n2lista1.nroNodos(),n2=lista2.nroNodos();
){
NodoS p=lista2.getCabecera(),q;
for (int i = 0; i < n2; i++) {
q=p.getSig();
p.setSig(null);
lista1.adicionarFinal(p);
p=q;
}
System.out.println("lista 1");
lista1.mostrar();
} else
{

NodoS p=lista1.getCabecera(),q;
for (int i = 0; i < n1; i++) {
q=p.getSig();
p.setSig(null);
lista2.adicionarFinal(p);
p=q;
}
System.out.println("lista 2");
} lista2.mostrar();
}
}
 3. En una lista simple circular de enteros se pide añadir antes y despues del
kesimo par su antecesor y su sucesor. a) libre
b) solo añadir dos nuevos nodos.
import java.util.Scanner;
public class INF_131_4_3 {
public static void main(String[] args) {
Scanner lee=new Scanner(System.in);
LSCircular lista=new LSCircular();
System.out.print("Introducir cantidad de datos: "); int
n=lee.nextInt(); Object dato;
for (int i = 0; i < n; i++) {
dato=(Object)lee.nextInt();
lista.adiFin(dato);
}
lista.mostrar();
System.out.print("introducir el dato Q: ");
int Q=lee.nextInt(); //inciso a
boolean sw=true;
LSCircular aux=new LSCircular();
int n1=lista.nroNodos();
NodoS p=lista.getCabecera(),q;
for (int i = 0; i < n1; i++) {
if(((int)p.getDato()==Q ||
(int)p.getDato()>Q) && sw) {
sw = false;
aux.adiFin(Q);
}
aux.adiFin(p.getDato());
p=p.getSig();
}
System.out.println("Lista resultante");
aux.mostrar();
//inciso b
boolean sw1=true;
LSCircular aux1=new LSCircular();
int n2=lista.nroNodos();
NodoS p1=lista.getCabecera();
for (int i = 0; i < n2; i++) {
q=p1.getSig();
if(((int)p1.getDato()==Q || (int)p1.getDato()>Q) && sw1) { sw1 = false;
NodoS qq=new NodoS();
qq.setDato(Q);
aux1.adicionarFinal(qq);
}
aux1.adicionarFinal(p1);
p1=q;
}
System.out.println("Lista resultante");
aux1.mostrar();
}
}
4. Dada una lista simple circular que contiene los caracteres de una palabra se pide
eliminar las consonantes repetidas. a) Libre
b) no crear nuevos nodos
import java.util.Scanner; public class
INF_131_4_5 {
public static void main(String[] args) {
Scanner lee=new Scanner(System.in);
LSCircular lista=new LSCircular();
System.out.print("Introducir cantidad de nombres: "); int m=lee.nextInt();
Object dato;
for (int i = 0; i < m; i++) {
dato=(String)lee.next();
lista.adiFin(dato);
}
lista.mostrar(); System.out.println("");
String cad="";
String voc="";
LSCircular aux=new LSCircular(); NodoS
p=lista.getCabecera(),q; int n=lista.nroNodos();
for (int i = 0; i < n; i++) {
q=p.getSig();
cad=(String)p.getDato();
if (cad.charAt(cad.length()-1)!='a'
&&cad.charAt(cad.length()-1)!='e'
&&cad.charAt(cad.length()-1)!='i'
&&cad.charAt(cad.length()-1)!='o'
&&cad.charAt(cad.length()-1)!='u')
System.out.println(cad);
else
aux.adicionarFinal(p);

p=q;
}
 System.out.println("\nLista resultante"); aux.mostrar();

}
}

5 Dada una lista simple circular de articulos(codigo,descripcion,cantidad,precio) se

pide
a) implementar la venta del articulo Z si existe la cantidad suficiente asimismo
debe actualizarse la cantidad si se realiza la venta.
b) el dueño del almacen ha comprado un nuevo articulo agregarlo a la lista
considerando que la lista estaba ordenada por descripcion de modo que se
mantenga el orden

import java.util.Scanner; public

class INF_131_4_4 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner lee=new Scanner(System.in);
LSCircular lista=new LSCircular();
lista.adiFin(new articulos(1001,"televisor",100,550));
lista.adiFin(new articulos(1002,"refrigerador",10,5000));
lista.adiFin(new articulos(1003,"bañera",20,1000));
lista.adiFin(new articulos(1004,"cocina",70,950));
lista.mostrar();
System.out.print("Introducir articulo: ");
String z=lee.next();
vender(lista,z);
}

private static void vender(LSCircular lista, String z) {

 NodoS p = lista.getCabecera();
int m = 0;
if (lista.nroNodos() != 0) {
do {
if (p.getDato().getDescripcion().equals(z))
System.out.println("existe articulo "+z);
p = p.getSig();
} while (p != lista.getCabecera());
}
}
}

public class articulos {

private int codigo,cantidad;
private String descripcion; private
double precio;
public articulos(int codigo,String descripcion,int cantidad,double precio) {
this.codigo=codigo; this.descripcion=descripcion;
this.cantidad=cantidad;
this.precio=precio;
}
public String toString() {
return "codigo=" +codigo+ ", descripcion=" +descripcion+ ", cantidad=" +cantidad+",
precio="+precio;
}
public int getCodigo() {
return codigo;
}
public void setCodigo(int codigo) {
this.codigo = codigo;
}
public int getCantidad() {
return cantidad;
}
public void setCantidad(int cantidad) {
this.cantidad = cantidad;
}
public String getDescripcion() {
return descripcion;
}
public void setDescripcion(String descripcion) { this.descripcion =
descripcion;
}
public double getPrecio() {
return precio;
}
public void setPrecio(double precio) {
this.precio = precio;
}
}
6 En Java se implementan listas con la clase LinkedList y con ArrayList cuál es la
diferencia entre ambas, ejemplificar su utilización.

Parámetros para comparar LinkedList y ArrayList en Java:

• Operación
• Implementación
• Proceso
• Memoria

1. Operaciones
Las operaciones de inserción, adición y eliminación de un artículo son más rápidas
en un LinkedList porque no necesitamos cambiar el tamaño como lo hacemos en
ArrayList.
2. Implementación
ArrayList se basa en el concepto de una matriz redimensionable dinámicamente,
mientras LinkedList se basa en la implementación de listas doblemente enlazadas
3. Proceso
A LinkedList La clase se puede usar como una lista y una cola porque implementa las
interfaces List y Deque, mientras que ArrayList solo puede implementar Lists.
4. Memoria
A LinkedList consume más memoria que un ArrayList porque cada nodo en un
LinkedList almacena dos referencias, mientras que Lista de arreglo contiene solo
datos y su índice
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List; public
class ListDiffDemo {
public static void main(String[] args) {
ArrayList<String> cities = new ArrayList<String>();
cities.add("a"); cities.add("b");
cities.add("c"); cities.add("d");
cities.add("e");
System.out.println("Elements in ArrayList: " + cities);

List<String> states = new LinkedList<String>();

states.add("a"); states.add("b");
states.add("c"); states.add("d");
states.add("e");
System.out.println("Elements in LinkedList" + states);
}
}