Actividad: Listas

Alex David Rodriguez Aguilar

Estructura de datos

Sabina Rada Mendoza

Universidad Cooperativa de Colombia

2022
EJERCICIOS "ESTRUCTURAS DE DATOS EN JAVA"
Punto 8.1

package lista;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
*
* @author Alx
*/
public class Lista {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
List<String>nombre;
nombre=new ArrayList<>();
System.out.println("desea añadir algo");
nombre.add(in.nextLine());
if(nombre.size()<0){
System.out.println("lista esta vacia");
}else{
System.out.println("la lista no anda vacia");
}
 }

Punto 8.2

public class Nodo {

private Nodo siguiente;

private Nodo anterior;
private String dato;

public Nodo(String dat,Nodo ant,Nodo sig){

siguiente=sig;
anterior=ant;
dato=dat;
}

public Nodo getSiguiente() {

return siguiente;
}

public void setSiguiente(Nodo siguiente) {

this.siguiente = siguiente;
}

public Nodo getAnterior() {

 return anterior;
}

public void setAnterior(Nodo anterior) {

this.anterior = anterior;
}

public String getDato() {

return dato;
}

public void setDato(String dato) {

this.dato = dato;
}

}
public class Lista_doble {
private Nodo Inicio;
private Nodo fin;

public Lista_doble(){
Inicio=null;
fin=null;
}
public void insertarInicio(String dato){
if(Inicio==null){
Inicio=new Nodo(dato,null,null);
 fin=Inicio;
}
else{
Nodo nuevo=new Nodo(dato,null,Inicio);
Inicio.setAnterior(nuevo);
Inicio=nuevo;
}

}
public void insertarFin(String dato){
if(Inicio==null){
fin=new Nodo(dato,null,null);
Inicio=fin;
}else{
Nodo nuevo=new Nodo(dato,null,Inicio);
fin.setAnterior(nuevo);
fin=nuevo;
}
}
public String ExtraerInicio(){
String dato=Inicio.getDato();
Inicio=Inicio.getSiguiente();
if(Inicio !=null){
Inicio.setAnterior(Inicio);
}else{
fin=null;
}
return dato;
 }
public void MostrarRegresar(){
Nodo temp=fin;
while(temp !=null){
System.out.println(temp.getDato());
temp=temp.getAnterior();
}
}
public Boolean buscar(String dato){
Nodo temp=Inicio;
while(temp !=null){
if(temp.getDato().equals(temp)){
return true;
}
temp=temp.getSiguiente();
}
return false;
}

}
public class punto82 {
public static void main(String[] args) {
Lista_doble lb=new Lista_doble();
lb.insertarInicio("3");
lb.insertarFin("1");
lb.insertarFin("2");

lb.MostrarRegresar();
 }

Punto 8.3

Clase Nodo:

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;
}

Clase Lista:

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 para agregar un nodo

public void agregarNodo(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 && anterior.getDato()!=numero)
{
anterior = siguiente;
siguiente = siguiente.getSiguiente();
}
if (siguiente!=null)
{
Nodo nuevo = new
Nodo(calculo(anterior.getDato(),siguiente.getDato()),siguiente);
anterior.setSiguiente(nuevo);
nuevo.setSiguiente(siguiente);
if(siguiente == fin)
{
fin = anterior;
}
}
}
}
}

//Metodo para calcular el valor absoluto entre dos numeros ubicados en los nodos
public int calculo(int primer, int segundo)
{
int num = primer -segundo;
num =Math.abs(num);
return num;
}

Clase Principal:
import javax.swing.JOptionPane;

public class Principal {

public static void main(String[] args)

{
Lista array = new Lista();

array.agregarInicio(17);
array.agregarInicio(43);
array.agregarInicio(20);
array.agregarFin(4);
array.agregarFin(11);
System.out.println("Lista inicial");
array.imprimir();

int agregar = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero

para que el nuevo valor se ubique despues de este"));
 array.agregarNodo(agregar);
System.out.println("Nueva lista:");
array.imprimir();
}
}

Punto 8.4

class node:
def __init__(self, data=None, next=None):
self.data = data
self.next = next

class ListasEnlazadas:
def __init__(self):
self.head = None

class node:
def __init__(self, data=None, next=None):
self.data = data
self.next = next

class AplicacionDeListasEnlazadas:
def __init__(self):
self.head = None

# Se agrega elementos al frente de la lista

def add_at_front(self, data):
 self.head = node(data=data, next=self.head)

# Agrega un nuevo nodo entre dos nodos existentes

def add_between(self, posicion, elemento):
curr = self.head
count = 1
nodoPrevio = None
if elemento > 0:
while count != posicion:
nodoPrevio = curr
curr = curr.next
count += 1
if nodoPrevio is None:
self.head = curr.next
elif curr:
nodoPrevio.next = node(data=elemento, next=curr)
else:
return False

# Se agregan elementos al final de la lista enlazada

def add_at_end(self, data):
if not self.head:
self.head = node(data=data)
return
curr = self.head
while curr.next:
curr = curr.next
curr.next = node(data=data)
 # Evalua la lista en caso de que se encuentra vacia
def is_empty(self):
return self.head == None
# Imprime la lista con los nodos
def print_list(self):
node = self.head
while node != None:
print(node.data, end=" => ")
node = node.next

s = AplicacionDeListasEnlazadas()
s.add_at_front(-3)
s.add_at_end(7)
s.add_at_front(-8)
s.add_between(3, -4)
s.print_list()
8.5
lass CIDemo {

static class DictEntry {

String word;
String meaning;
DictEntry next;
}

// ListInfo is necessary because buildList() must return two pieces

// of information

static class ListInfo {

 DictEntry top;
DictEntry last;
}

public static void main (String [] args) {

String [] wordsMaster = { "aardvark", "anxious", "asterism" };

ListInfo liMaster = new ListInfo ();

buildList (liMaster, wordsMaster);

dump ("Master list =", liMaster.top);

String [] wordsWorking = { "carbuncle", "catfish", "color" };

ListInfo liWorking = new ListInfo ();
buildList (liWorking, wordsWorking);

dump ("Working list =", liWorking.top);

// Perform the concatenation

liMaster.last.next = liWorking.top;
dump ("New master list =", liMaster.top);

invert (liMaster);
dump ("Inverted new master list =", liMaster.top);
}

static void buildList (ListInfo li, String [] words) {

if (words.length == 0)
return;

// Create a node for first word/meaning

li.top = new DictEntry ();

li.top.word = words [0];
li.top.meaning = null;

// Initialize last reference variable to

// simplify append and make concatenation possible.

li.last = li.top;

for (int i = 1; i < words.length; i++) {

// Create (and append) a new node for next word/meaning

li.last.next = new DictEntry ();

li.last.next.word = words [i];
li.last.next.meaning = null;

// Advance last reference variable to simplify

// append and make concatenation possible

li.last = li.last.next;
}
 li.last.next = null;
}

static void dump (String msg, DictEntry topEntry) {

System.out.print (msg + " ");

while (topEntry != null) {

System.out.print (topEntry.word + " ");
topEntry = topEntry.next;
}
System.out.println ();
}

static void invert (ListInfo li) {

DictEntry p = li.top, q = null, r;

while (p != null) {
r = q;
q = p;
p = p.next;
q.next = r;
}
li.top = q;
}
}
Punto 8.6

typedef struct celda {

tElemento elemento;
struct celda *siguiente,*anterior;
} tipocelda;

typedef tipocelda *tPosicion;

typedef tipocelda *tLista;

static void error(char *cad)

{
fprintf(stderr, "ERROR: %s\n", cad);
exit(1);
}

tLista Crear()
{
tLista l;

l = (tLista)malloc(sizeof(tipocelda));
if (l == NULL)
Error("Memoria insuficiente.");
l->siguiente = l->anterior = l;
 return l;
}

void Destruir (tLista l)

{
tPosicion p;

for (p=l, l->anterior->siguiente=NULL; l!=NULL; p=l) {

l = l->siguiente;
free(p);
}
}

tPosicion Primero (tLista l)

{

return l->siguiente;
}

tPosicion Fin (tLista l)

{
 return l;
}

void Insertar (tElemento x, tPosicion p, tLista l)

{
tPosicion nuevo;

nuevo = (tPosicion)malloc(sizeof(tipocelda));
if (nuevo == NULL)
Error("Memoria insuficiente.");
nuevo->elemento = x;
nuevo->siguiente = p;
nuevo->anterior = p->anterior;
p->anterior->siguiente = nuevo;
p->anterior = nuevo;
}

void Borrar (tPosicion *p, tLista l)

{
tPosicion q;
 if (*p == l){
Error("Posicion fin(l)");
}
q = (*p)->siguiente;
(*p)->anterior->siguiente = q;
q->anterior = (*p)->anterior;
free(*p);
(*p) = q;
}

tElemento elemento(tPosicion p, tLista l)

{

if (p == l){
Error("Posicion fin(l)");
}
return p->elemento;
}

tPosicion siguiente (tPosicion p, tLista l)

{
 if (p == l){
Error("Posicion fin(l)");
}
return p->siguiente;
}

tPosicion anterior( tPosicion p, tLista l)

{

if (p == l->siguiente){
Error("Posicion primero(l)");
}
return p->anterior;
}

tPosicion posicion (tElemento x, tLista l)

{
tPosicion p;
int encontrado;
 p = primero(l);
encontrado = 0;
while ((p != fin(l)) && (!encontrado))
if (p->elemento == x)
encontrado = 1;
else
p = p->siguiente;
return p;
}

Punto 8.8
public class Nodo {
// Variable en la cual se va a guardar el valor.
private int valor;
// Variable para enlazar los nodos.
private Nodo siguiente;
/**
* Constructor que inicializamos el valor de las variables.
*/
public void Nodo(){
this.valor = 0;
this.siguiente = null;
}

// Métodos get y set para los atributos.

 public int getValor() {
return valor;
}

public void setValor(int valor) {

this.valor = valor;
}

public Nodo getSiguiente() {

return siguiente;
}

public void setSiguiente(Nodo siguiente) {

this.siguiente = siguiente;
}
}
Clase ListaCircular:
/**
* Clase que define las operaciones básicas que debe tener una lista
* circular simple.
* @author Alx
*/
public class ListaCircular {
// Puntero que indica el inicio de la lista o conocida tambien
// como cabeza de la lista.
private Nodo inicio;
// Puntero que indica el final de la lista o el ultimo nodo.
private Nodo ultimo;
// Variable para registrar el tamaño de la lista.
private int tamanio;
/**
* Constructor por defecto.
*/
public void Lista(){
inicio = null;
ultimo = null;
tamanio = 0;
}
/**
* Consulta si la lista esta vacia.
* @return true si el primer nodo (inicio), no apunta a otro nodo.
*/
public boolean esVacia(){
return inicio == null;
}
/**
* Consulta cuantos elementos (nodos) tiene la lista.
* @return numero entero entre [0,n] donde n es el numero de elementos
* que contenga la lista.
*/
public int getTamanio(){
return tamanio;
}
/**
* Agrega un nuevo nodo al final de la lista circular.
* @param valor a agregar.
*/
public void agregarAlFinal(int valor){
// Define un nuevo nodo.
Nodo nuevo = new Nodo();
// Agrega al valor al nodo.
nuevo.setValor(valor);
// Consulta si la lista esta vacia.
if (esVacia()) {
// Inicializa la lista agregando como inicio al nuevo nodo.
inicio = nuevo;
// De igual forma el ultimo nodo sera el nuevo.
ultimo = nuevo;
// Y el puntero del ultimo debe apuntar al primero.
ultimo.setSiguiente(inicio);
// Caso contrario el nodo se agrega al final de la lista.
} else{
// Apuntamos con el ultimo nodo de la lista al nuevo.
ultimo.setSiguiente(nuevo);
// Apuntamos con el nuevo nodo al inicio de la lista.
nuevo.setSiguiente(inicio);
// Como ahora como el nuevo nodo es el ultimo se actualiza
// la variable ultimo.
ultimo = nuevo;
}
// Incrementa el contador de tamaño de la lista
tamanio++;
}
/**
* Agrega un nuevo nodo al inicio de la lista circular.
* @param valor a agregar.
*/
public void agregarAlInicio(int valor){
// Define un nuevo nodo.
Nodo nuevo = new Nodo();
// Agrega al valor al nodo.
nuevo.setValor(valor);
// Consulta si la lista esta vacia.
if (esVacia()) {
// Inicializa la lista agregando como inicio al nuevo nodo.
inicio = nuevo;
// De igual forma el ultimo nodo sera el nuevo.
ultimo = nuevo;
// Y el puntero del ultimo debe apuntar al primero.
ultimo.setSiguiente(inicio);
// Caso contrario va agregando los nodos al inicio de la lista.
} else{
// Une el nuevo nodo con la lista existente.
nuevo.setSiguiente(inicio);
// Renombra al nuevo nodo como el inicio de la lista.
inicio = nuevo;
// El puntero del ultimo debe apuntar al primero.
ultimo.setSiguiente(inicio);
}
// Incrementa el contador de tamaño de la lista.
tamanio++;
}
/**
* Inserta un nuevo nodo despues de otro, ubicado por el valor que contiene.
* @param referencia valor del nodo anterios al nuevo nodo a insertar.
* @param valor del nodo a insertar.
*/
public void insertarPorReferencia(int referencia, int valor){
// Define un nuevo nodo.
Nodo nuevo = new Nodo();
// Agrega al valor al nodo.
nuevo.setValor(valor);
// Verifica si la lista contiene elementos
if (!esVacia()) {
// Consulta si el valor existe en la lista.
if (buscar(referencia)) {
// Crea ua copia de la lista.
Nodo aux = inicio;
// Recorre la lista hasta llegar al nodo de referencia.
while (aux.getValor() != referencia) {
aux = aux.getSiguiente();
}
// Consulta si el nodo a insertar va despues del ultimo
if (aux == ultimo) {
// Apuntamos con el ultimo nodo de la lista al nuevo.
aux.setSiguiente(nuevo);
// Apuntamos con el nuevo nodo al inicio de la lista.
nuevo.setSiguiente(inicio);
// Como ahora como el nuevo nodo es el ultimo se actualiza
 // la variable ultimo.
ultimo = nuevo;
} else {
// Crea un respaldo de la continuación de la lista.
Nodo siguiente = aux.getSiguiente();
// Enlaza el nuevo nodo despues del nodo de referencia.
aux.setSiguiente(nuevo);
// Une la continuacion de la lista al nuevo nodo.
nuevo.setSiguiente(siguiente);
}
// Incrementa el contador de tamaño de la lista.
tamanio++;
}
}
}
/**
* Inserta un nuevo nodo despues en una posición determinada.
* @param posicion en la cual se va a insertar el nuevo nodo.
* @param valor valor del nuevo nodo de la lista.
*/
public void insrtarPorPosicion(int posicion, int valor){
// Verifica si la posición ingresada se encuentre en el rango
// >= 0 y <= que el numero de elementos del la lista.
if(posicion>=0 && posicion<=tamanio){
Nodo nuevo = new Nodo();
nuevo.setValor(valor);
// Consulta si el nuevo nodo a ingresar va al inicio de la lista.
if(posicion == 0){
 // Une el nuevo nodo con la lista existente.
nuevo.setSiguiente(inicio);
// Renombra al nuevo nodo como el inicio de la lista.
inicio = nuevo;
// El puntero del ultimo debe apuntar al primero.
ultimo.setSiguiente(inicio);
}
else{
// Si el nodo a inserta va al final de la lista.
if(posicion == tamanio){
// Apuntamos con el ultimo nodo de la lista al nuevo.
ultimo.setSiguiente(nuevo);
// Apuntamos con el nuevo nodo al inicio de la lista.
nuevo.setSiguiente(inicio);
// Como ahora como el nuevo nodo es el ultimo se actualiza
// la variable ultimo.
ultimo = nuevo;
}
else{
// Si el nodo a insertar va en el medio de la lista.
Nodo aux = inicio;
// Recorre la lista hasta llegar al nodo anterior
// a la posicion en la cual se insertara el nuevo nodo.
for (int i = 0; i < (posicion-1); i++) {
aux = aux.getSiguiente();
}
// Guarda el nodo siguiente al nodo en la posición
// en la cual va a insertar el nevo nodo.
 Nodo siguiente = aux.getSiguiente();
// Inserta el nuevo nodo en la posición indicada.
aux.setSiguiente(nuevo);
// Une el nuevo nodo con el resto de la lista.
nuevo.setSiguiente(siguiente);
}
}
// Incrementa el contador de tamaño de la lista.
tamanio++;
}
}
/**
* Obtiene el valor de un nodo en una determinada posición.
* @param posicion del nodo que se desea obtener su valor.
* @return un numero entero entre [0,n-1] n = numero de nodos de la lista.
* @throws Exception
*/
public int getValor(int posicion) throws Exception{
// Verifica si la posición ingresada se encuentre en el rango
// >= 0 y < que el numero de elementos del la lista.
if(posicion>=0 && posicion<tamanio){
// Consulta si la posicion es el inicio de la lista.
if (posicion == 0) {
// Retorna el valor del inicio de la lista.
return inicio.getValor();
}else{
// Crea una copia de la lista.
Nodo aux = inicio;
 // Recorre la lista hasta la posición ingresada.
for (int i = 0; i < posicion; i++) {
aux = aux.getSiguiente();
}
// Retorna el valor del nodo.
return aux.getValor();
}
// Crea una excepción de Posicion inexistente en la lista.
} else {
throw new Exception("Posicion inexistente en la lista.");
}
}
/**
* Busca si existe un valor en la lista.
* @param referencia valor a buscar.
* @return true si existe el valor en la lista.
*/
public boolean buscar(int referencia){
// Crea una copia de la lista.
Nodo aux = inicio;
// Bandera para indicar si el valor existe.
boolean encontrado = false;
// Recorre la lista hasta encontrar el elemento o hasta
// llegar al primer nodo nuevamente.
do{
// Consulta si el valor del nodo es igual al de referencia.
if (referencia == aux.getValor()){
// Canbia el valor de la bandera.
 encontrado = true;
}
else{
// Avansa al siguiente. nodo.
aux = aux.getSiguiente();
}
}while(aux != inicio && encontrado != true);
// Retorna el resultado de la bandera.
return encontrado;
}
/**
* Consulta la posición de un elemento en la lista
* @param referencia valor del nodo el cual se desea saber la posición.
* @return un valor entero entre [0,n] que indica la posición del nodo.
* @throws Exception
*/
public int getPosicion(int referencia) throws Exception{
// Consulta si el valor existe en la lista.
if (buscar(referencia)) {
// Crea una copia de la lista.
Nodo aux = inicio;
// COntado para almacenar la posición del nodo.
int cont = 0;
// Recoore la lista hasta llegar al nodo de referencia.
while(referencia != aux.getValor()){
// Incrementa el contador.
cont ++;
// Avansa al siguiente. nodo.
 aux = aux.getSiguiente();
}
// Retorna el valor del contador.
return cont;
// Crea una excepción de Valor inexistente en la lista.
} else {
throw new Exception("Valor inexistente en la lista.");
}
}
/**
* Actualiza el valor de un nodo que se encuentre en la lista ubicado
* por un valor de referencia.
* @param referencia valor del nodo el cual se desea actualizar.
* @param valor nuevo valor para el nodo.
*/
public void editarPorReferencia(int referencia, int valor){
// Consulta si el valor existe en la lista.
if (buscar(referencia)) {
// Crea ua copia de la lista.
Nodo aux = inicio;
// Recorre la lista hasta llegar al nodo de referencia.
while(aux.getValor() != referencia){
aux = aux.getSiguiente();
}
// Actualizamos el valor del nodo
aux.setValor(valor);
}
}
/**
* Actualiza el valor de un nodo que se encuentre en la lista ubicado
* por su posición.
* @param posicion en la cual se encuentra el nodo a actualizar.
* @param valor nuevo valor para el nodo.
*/
public void editarPorPosicion(int posicion , int valor){
// Verifica si la posición ingresada se encuentre en el rango
// >= 0 y < que el numero de elementos del la lista.
if(posicion>=0 && posicion<tamanio){
// Consulta si el nodo a eliminar es el primero.
if(posicion == 0){
// Alctualiza el valor delprimer nodo.
inicio.setValor(valor);
}
else{
// En caso que el nodo a eliminar este por el medio
// o sea el ultimo
Nodo aux = inicio;
// Recorre la lista hasta lleger al nodo anterior al eliminar.
for (int i = 0; i < posicion; i++) {
aux = aux.getSiguiente();
}
// Alctualiza el valor del nodo.
aux.setValor(valor);
}
}
}
/**
* Elimina un nodo que se encuentre en la lista ubicado
* por un valor de referencia.
* @param referencia valor del nodo que se desea eliminar.
*/
public void removerPorReferencia(int referencia){
// Consulta si el valor de referencia existe en la lista.
if (buscar(referencia)) {
// Consulta si el nodo a eliminar es el pirmero
if (inicio.getValor() == referencia) {
// El primer nodo apunta al siguiente.
inicio = inicio.getSiguiente();
// Apuntamos con el ultimo nodo de la lista al inicio.
ultimo.setSiguiente(inicio);
} else{
// Crea ua copia de la lista.
Nodo aux = inicio;
// Recorre la lista hasta llegar al nodo anterior
// al de referencia.
while(aux.getSiguiente().getValor() != referencia){
aux = aux.getSiguiente();
}
if (aux.getSiguiente() == ultimo) {
aux.setSiguiente(inicio);
ultimo = aux;
} else {
// Guarda el nodo siguiente del nodo a eliminar.
Nodo siguiente = aux.getSiguiente();
 // Enlaza el nodo anterior al de eliminar con el
// sguiente despues de el.
aux.setSiguiente(siguiente.getSiguiente());
// Actualizamos el puntero del ultimo nodo
}
}
// Disminuye el contador de tamaño de la lista.
tamanio--;
}
}
/**
* Elimina un nodo que se encuentre en la lista ubicado
* por su posición.
* @param posicion en la cual se encuentra el nodo a eliminar.
*/
public void removerPorPosicion(int posicion){
// Verifica si la posición ingresada se encuentre en el rango
// >= 0 y < que el numero de elementos del la lista.
if(posicion>=0 && posicion<tamanio){
// Consulta si el nodo a eliminar es el primero
if(posicion == 0){
// Elimina el primer nodo apuntando al siguinte.
inicio = inicio.getSiguiente();
// Apuntamos con el ultimo nodo de la lista al inicio.
ultimo.setSiguiente(inicio);
}
// En caso que el nodo a eliminar este por el medio
// o sea el ultimo
 else{
// Crea una copia de la lista.
Nodo aux = inicio;
// Recorre la lista hasta lleger al nodo anterior al eliminar.
for (int i = 0; i < posicion-1; i++) {
aux = aux.getSiguiente();
}
if (aux.getSiguiente() == ultimo) {
aux.setSiguiente(inicio);
ultimo = aux;
} else {
// Guarda el nodo siguiente del nodo a eliminar.
Nodo siguiente = aux.getSiguiente();
// Enlaza el nodo anterior al de eliminar con el
// sguiente despues de el.
aux.setSiguiente(siguiente.getSiguiente());
// Actualizamos el puntero del ultimo nodo
}
}
// Disminuye el contador de tamaño de la lista.
tamanio--;
}
}
/**
* Elimina la lista
*/
public void eliminar(){
// Elimina el valor y la referencia a los demas nodos.
 inicio = null;
// Elimina el valor y la referencia al primer nodo.
ultimo = null;
// Reinicia el contador de tamaño de la lista a 0.
tamanio = 0;
}
/**
* Mustra en pantalla los elementos de la lista.
*/
public void listar(){
// Verifica si la lista contiene elementoa.
if (!esVacia()) {
// Crea una copia de la lista.
Nodo aux = inicio;
// Posicion de los elementos de la lista.
int i = 0;
System.out.print("-> ");
// Recorre la lista hasta llegar nuevamente al incio de la lista.
do{
// Imprime en pantalla el valor del nodo.
System.out.print(i + ".[ " + aux.getValor() + " ]" + " -> ");
// Avanza al siguiente nodo.
aux = aux.getSiguiente();
// Incrementa el contador de la posión.
i++;
}while(aux != inicio);
}
}
}
Clase Main:
/**
* Clase principa que implementa los metodos de la clase ListaCircular.
* @author xavier
*/
public class Main {
/**
* @param args the command line arguments
* @throws Exception
*/
public static void main(String[] args) throws Exception{
ListaCircular listaCircular = new ListaCircular();

System.out.println("<<-- Ejemplo de lista circular simple -->>\n");

// Agregar al final de la lista circular

listaCircular.agregarAlFinal(12);
listaCircular.agregarAlFinal(15);
listaCircular.agregarAlFinal(9);
// Agregar in inicio de la lista circular
listaCircular.agregarAlInicio(41);
listaCircular.agregarAlInicio(6);

System.out.println("<<-- Lista Circular -->>");

listaCircular.listar();

System.out.println("\n\n<<-- Tamaño -->");

System.out.println(listaCircular.getTamanio());

System.out.println("\n<<-- Obtener el valor del nodo en la posicion 3 -->>");

System.out.println(listaCircular.getValor(3));

System.out.println("\nInsrta un nodo con valor 16 despues del 15");

listaCircular.insertarPorReferencia(15, 16);
listaCircular.listar();
System.out.print(" | Tamaño: ");
System.out.println(listaCircular.getTamanio());

System.out.println("\n\nInsrta un nodo con valor 44 en la posición 5");

listaCircular.insrtarPorPosicion(5, 44);
listaCircular.listar();
System.out.print(" | Tamaño: ");
System.out.println(listaCircular.getTamanio());

System.out.println("\nActualiza el valor 12 del tercer nodo por 13");

listaCircular.editarPorReferencia(12, 13);
listaCircular.listar();
System.out.print(" | Tamaño: ");
System.out.println(listaCircular.getTamanio());

System.out.println("\nActualiza el valor nodo en la posición 0 por 17");

listaCircular.editarPorPosicion(0, 17);
listaCircular.listar();
System.out.print(" | Tamaño: ");
System.out.println(listaCircular.getTamanio());
 System.out.println("\nElimina el nodo con el valor 41");
listaCircular.removerPorReferencia(41);
listaCircular.listar();
System.out.print(" | Tamaño: ");
System.out.println(listaCircular.getTamanio());

System.out.println("\nElimina el nodo en la posición 4");

listaCircular.removerPorPosicion(4);
listaCircular.listar();
System.out.print(" | Tamaño: ");
System.out.println(listaCircular.getTamanio());

System.out.println("\nConsulta si existe el valor 30");

System.out.println(listaCircular.buscar(30));

System.out.println("\nConsulta la posicion del valor 16");

System.out.println(listaCircular.getPosicion(16));

System.out.println("\nElimina la lista");
listaCircular.eliminar();

System.out.println("\nConsulta si la lista está vacia");

System.out.println(listaCircular.esVacia());

System.out.println("\n\n<<-- Fin de ejemplo lista simple -->>");

}
}
Punto 8.9
Lista Mezcla2(Lista l1,Lista l2)
{
Lista L;
Posicion p1,p2;
int aux1,aux2;

/*En la lista L guardaremos el resultado*/

L=CrearLista(sizeof(int));

/*Utilizamos p1 y p2 para recorrer las dos listas*/

p1=PrimeroLista(l1);
p2=PrimeroLista(l2);

/*Obtenemos los elementos apuntados por p1 y p2 ,el menor*/

/*de ellos se inserta en el resultado y se adelanta en una*/
/*posicion.Se repite el proceso hasta que una lista queda */
/*sin elementos (cuando p1 o p2 llegan al final) */

while (p!=FinLista(l1)&& p2!=FinLista(l2)){

Recuperar(&aux1,p1,l1);
Recuperar(&aux2,p2,l2);
if (aux1 < aux2){
p1=Siguiente(p1,l1);
Insertar(&aux1,FinLista(L),L);
}
else{
p2=Siguiente(p2,l2);
 Insertar(&aux2,FinLista(L),L);
}
}

/*Si p1 no ha llegado al final hay que vaciar l1 al final*/

/*de la lista resultado*/
While (p1!=FinLista(l1)){
Recuperar(&aux1,p1,l1);
p1=Siguiente(p1,l1);
Insertar(&aux1,FinLista(L),L);
}

/*Si p2 no ha llegado al final hay que vaciar l2 al final*/

/*de la lista resultado*/
while (p2!=FinLista(l2)){
Recuperar(&aux2,p2,l2);
p2=Siguiente(p2,l2);
Insertar(&aux2,FinLista(L),L);
}

/*Devolvemos L como resultado estando ya l1 y l2 vacias */

return L;

Punto 8.10

#include<iostream>
#include<stdlib.h>
using namespace std;

struct Registro{
int cedula;
string nombre;
string apellido;
int edad;
char sexo;
Registro *Rpersona;
};

void menu();
void insertarLista(Registro *&,int c, string n, string a, int e, char s);
void mostrarLista(Registro *);
void buscarLista(Registro *,int c);
void eliminarNodo(Registro *&,int c);
void eliminarLista(Registro *&,int &);

Registro *lista = NULL;

int main(){

menu();

return 0;
}
void menu(){
int opcion,c,e;
string n,a;
char s;

do{
cout<<"\t.:::Proyecto UBV:::.\n";
cout<<"1. Ingresar un Registro a la lista\n";
cout<<"2. Mostrar los Registros de la lista\n";
cout<<"3. Buscar un Registro en la lista\n";
cout<<"4. Eliminar un Registro de la lista\n";
cout<<"5. Dejar vacia la lista\n";
cout<<"6. Salir\n";
cout<<"Opcion: ";
cin>>opcion;

switch(opcion){
case 1: cout<<"\nIngrese un Numero de Cedula: ";
cin>>c;
cout<<"\nIngrese el Nombre: ";
cin>>n;
cout<<"\nIngrese el Apellido: ";
cin>>a;
cout<<"\nIngrese la Edad: ";
cin>>e;
cout<<"\nIngrese el Sexo: ";
 cin>>s;
insertarLista(lista,c,n,a,e,s);
cout<<"\n";
system("pause");
break;
case 2: mostrarLista(lista);
cout<<"\n";
system("pause");
break;
case 3: cout<<"\nIngrese el Numero de Cedula a Buscar en el
Registro: ";
cin>>c;
buscarLista(lista,c);
cout<<"\n";
system("pause");
break;
case 4: cout<<"\nIngrese el Numero de Cedula a Eliminar del
Registro: ";
cin>>c;
eliminarNodo(lista,c);
cout<<"\n";
system("pause");
break;
case 5:
while(lista != NULL){
eliminarLista(lista,c);
cout<<c <<" -> ";
}
cout<<"\n";
 system("pause");
break;
}
system("cls");
}while(opcion != 6);
}

void insertarLista(Registro *&,int c, string n, string a, int e, char s){

Registro *nuevo_registro = new Registro();

nuevo_registro->cedula = c;
nuevo_registro->nombre = n;
nuevo_registro->apellido = a;
nuevo_registro->edad = e;
nuevo_registro->sexo = s;
Registro *aux1 = lista;
Registro *aux2;

while((aux1 != NULL) && (aux1->cedula < c), (aux1->nombre < n), (aux1-
>apellido < a), (aux1->edad < e), (aux1->sexo < s)){
aux2 = aux1;
aux1 = aux1->Rpersona;
}

if(lista == aux1){
lista = nuevo_registro;
}
else{
aux2->Rpersona = nuevo_registro;
 }

nuevo_registro->Rpersona = aux1;

cout<<"\tPersona "<<c<<" insertada a la lista correctamente\n";

}

void mostrarLista(Registro *lista){

Registro *actual = new Registro();
actual = lista;

while(actual != NULL){
cout<<actual->cedula<<" -> ";
cout<<actual->nombre<<" -> ";
cout<<actual->apellido<<" -> ";
cout<<actual->edad<<" -> ";
cout<<actual->sexo<<" -> ";
actual = actual->Rpersona;
}
}

void buscarLista(Registro *lista,int c,string n,string a,int e,char s){

bool band = false;

Registro *actual = new Registro();

actual = lista;

while((actual != NULL) && (actual->cedula <= c), (actual->nombre <= n),

(actual->apellido <= a),(actual->edad <= e), (actual->sexo <= s)){
 if((actual->cedula == c), (actual->nombre == n), (actual->apellido ==
a), (actual->edad == e), (actual->sexo == s)){
band = true;
}
actual = actual->Rpersona;
}

if(band == true){
cout<<"Persona "<<n<<" SI a sido encontrado en lista\n";
}
else{
cout<<"Persona "<<n<<" NO a sido encontrado en la lista\n";
}
}

void eliminarNodo(Registro *&lista,int c,string n, string a, int e, char s){

if(lista != NULL){
Registro *aux_borrar;
Registro *anterior = NULL;

aux_borrar = lista;

while((aux_borrar != NULL) && (aux_borrar->cedula != c),

(aux_borrar->nombre != n), (aux_borrar->apellido != a), (aux_borrar->edad != e),
(aux_borrar->sexo != s)){
anterior = aux_borrar;
aux_borrar = aux_borrar->Rpersona;
 }

if(aux_borrar == NULL){
cout<<"La persona no ha sido encontrado";
}

else if(anterior == NULL){

lista = lista->Rpersona;
delete aux_borrar;
}

else {
anterior->Rpersona = aux_borrar->Rpersona;
delete aux_borrar;
}
}
}

void eliminarLista(Registro *&lista,int &c, string &n, string &a,int &e, char &s){
Registro *aux = lista;
c = aux->cedula;
n = aux->nombre;
a = aux->apellido;
e = aux->edad;
s = aux->sexo;
lista = aux->Rpersona;
 delete aux;
}