Estructura de Datos - Sesión 2

EJERCICIOS RESUELTOS EN CLASE

1. Escribir un programa que permite insertar, buscar, modificar, eliminar un dato

de una lista enlazada, así como también ordenar la lista en forma ascendente.
Por último, permitirá mostrar toda la lista enlazada en pantalla.

#include <iostream>
using namespace::std;

struct nodo {
int dato;
nodo* siguiente;
} *cabecera, * ultimo;

void insertarDato();
void buscarDato();
void modificarDato();
void eliminarDato();
void mostrarLista();
void ordenarLista();

int main() {
int opcion_menu = 0;
do
{
cout << "\n|-------------------------------------------|";
cout << "\n| ° LISTAS ENLAZADAS SIMPLES ° |";
cout << "\n|--------------------|----------------------|";
cout << "\n| 1. Insertar dato | 5. Mostrar lista |";
cout << "\n| 2. Buscar dato | 6. Ordenar lista |";
cout << "\n| 3. Modificar dato | 7. Salir |";
cout << "\n| 4. Eliminar dato | |";
cout << "\n|--------------------|----------------------|";
cout << "\n\n Escoja una Opcion: ";
cin >> opcion_menu;
switch (opcion_menu) {
case 1:
cout << "\n\n INSERTA UN DATO EN LA LISTA \n\n";
insertarDato();
break;
case 2:
cout << "\n\n BUSCAR UN DATO DE LA LISTA \n\n";
buscarDato();
break;
case 3:
cout << "\n\n MODIFICAR UN DATO DE LA LISTA \n\n";
modificarDato();
break;
case 4:
cout << "\n\n ELIMINAR UN DATO DE LA LISTA \n\n";
eliminarDato();
break;
case 5:
cout << "\n\n MOSTRAR LISTA DE DATOS \n\n";
mostrarLista();
 Estructura de Datos - Sesión 2

break;
case 6:
cout << "\n\n MOSTRAR LISTA DE DATOS \n\n";
ordenarLista();
break;
case 7:
cout << "\n\n PROGRAMA FINALIZADO.";
break;
default:
cout << "\n\n OPCION NO CONOCIDA. \n\n";
}
} while (opcion_menu != 7);

return 0;
}

void insertarDato() {
nodo* nuevo = new nodo();

cout << "Ingrese el nuevo dato: ";

cin >> nuevo->dato;

if (cabecera == NULL) {
cabecera = nuevo;
cabecera->siguiente = NULL;
ultimo = nuevo;
}
else {
ultimo->siguiente = nuevo;
nuevo->siguiente = NULL;
ultimo = nuevo;
}
}

void buscarDato() {
nodo* actual = new nodo();
actual = cabecera;
bool encontrado = false;
int datoBuscado = 0;

cout << "Ingrese el dato que se quiere buscar: ";

cin >> datoBuscado;

if (cabecera != NULL) {
while (actual != NULL) {
if (actual->dato == datoBuscado) {
cout << "\n Un nodo con el dato " << datoBuscado << "
fue encontrado.\n";
encontrado = true;
}
actual = actual->siguiente;
}
if (!encontrado)
cout << "\n No fue encontrado un nodo que contenga el dato
buscado.\n";
}
else
cout << "\n La lista no tiene datos.\n\n";
}

void modificarDato() {
nodo* actual = new nodo();
 Estructura de Datos - Sesión 2

actual = cabecera;
bool encontrado = false;
int datoBuscado = 0, datoModificacion = 0;

cout << " Ingrese el dato que se quiere modificar: ";

cin >> datoBuscado;
cout << "\n Ingrese el nuevo dato: ";
cin >> datoModificacion;

if (cabecera != NULL) {
while (actual != NULL) {
if (actual->dato == datoBuscado) {
cout << "\n Un nodo con el dato " << datoBuscado << "
fue encontrado.\n";
actual->dato = datoModificacion;
encontrado = true;
}
actual = actual->siguiente;
}
if (!encontrado)
cout << "\n No fue encontrado el dato que se quiere
modificar.\n";
}
else
cout << "\n La lista no tiene datos.\n\n";
}

void eliminarDato() {
nodo* actual = new nodo();
actual = cabecera;
nodo* anterior = new nodo();
anterior = NULL;
bool encontrado = false;
int datoBuscado = 0;

cout << " Ingrese el dato que se quiere eliminar: ";

cin >> datoBuscado;

if (cabecera != NULL) {
while (actual != NULL) {
if (actual->dato == datoBuscado) {
cout << "\n Un nodo con el dato " << datoBuscado << "
fue encontrado.\n";
if (actual == cabecera) {
cabecera = cabecera->siguiente;
}
else if (actual == ultimo) {
anterior->siguiente = NULL;
ultimo = anterior;
}
else
anterior->siguiente = actual->siguiente;
cout << "\n El nodo que contiene el dato fue
eliminado.\n\n";
encontrado = true;
}
anterior = actual;
actual = actual->siguiente;
}
if (!encontrado)
cout << "\n No fue encontrado el dato que se quiere
eliminar.\n";
 Estructura de Datos - Sesión 2

}
else
cout << "\n La lista no tiene datos.\n\n";
}

void ordenarLista()
{
nodo* actual = new nodo();
nodo* siguiente = new nodo();
int aux;
bool estaOrdenada = false;
while (!estaOrdenada)
{
estaOrdenada = true;
actual = cabecera;
while (actual->siguiente != NULL)
{
siguiente = actual->siguiente;
if (actual->dato > siguiente->dato)
{
aux = actual->dato;
actual->dato = siguiente->dato;
siguiente->dato = aux;
estaOrdenada = false;
}
actual = siguiente;
}
}
}

void mostrarLista() {
nodo* actual = new nodo();
actual = cabecera;

cout << "\n\n La lista enlazada es: \n";

if (cabecera != NULL) {
while (actual != NULL) {
cout << " " << actual->dato << " -> ";
actual = actual->siguiente;
}
cout << "NULL" << endl;
}
else
cout << "\n La lista no tiene datos.\n";
}

2. Escribir un programa que, dadas dos listas enlazadas, permita intercalar

(barajar) sus elementos.

#include <iostream>
using namespace std;

struct nodo
{
int dato;
nodo* siguiente;
};
 Estructura de Datos - Sesión 2

void InsertarDatoAlInicio(nodo*&, int);

void InsertarDatoAlFinal(nodo*&, nodo*&, int);
void ImprimirLista(nodo*);
nodo* MezclarListas(nodo*&, nodo*&);

int main()
{
nodo* p = NULL, * q = NULL, * ListaMezclada = NULL, * ultimo;
int cp, cq, dato;

cout << "Ingrese la cantidad de elementos de la primera lista 'p': ";

cin >> cp;

cout << "Ingrese la cantidad de elementos de la primera lista 'q': ";

cin >> cq;

cout << "INGRESO DE DATOS DE LA LISTA 'P' " << endl;

for (int i = 0; i < cp; i++)
{
cout << "Ingrese el dato " << i + 1 << ": ";
cin >> dato;
InsertarDatoAlFinal(p, ultimo, dato);
//InsertarDatoAlInicio(p, dato);
}

cout << "INGRESO DE DATOS DE LA LISTA 'Q' " << endl;

for (int j = 0; j < cq; j++)
{
cout << "Ingrese el dato " << j + 1 << ": ";
cin >> dato;
InsertarDatoAlFinal(q, ultimo, dato);
//InsertarDatoAlInicio(q, dato);
}

system("cls");

cout << "Primera lista enlazada 'p': " << endl;

ImprimirLista(p);
cout << "Segunda lista enlazada 'q': " << endl;
ImprimirLista(q);

ListaMezclada = MezclarListas(p, q);

cout << "Nueva lista con la mezcla: " << endl;

ImprimirLista(ListaMezclada);

return 0;
}

/* Función que permite ingresar un nodo al inicio */

void InsertarDatoAlInicio(nodo*& lista, int nuevoDato)
{
nodo* nuevoNodo = new nodo();
nuevoNodo->dato = nuevoDato;
nuevoNodo->siguiente = lista;
lista = nuevoNodo;
}

/* Función que permite ingresar un nodo al final */

void InsertarDatoAlFinal(nodo*& lista, nodo*& ultimo, int nuevoDato) {
nodo* nuevo = new nodo();
 Estructura de Datos - Sesión 2

nuevo->dato = nuevoDato;

if (lista == NULL)
lista = nuevo;
else
ultimo->siguiente = nuevo;
ultimo = nuevo;
}

/* Función que imprime una lista enlazada */

void ImprimirLista(nodo* lista)
{
nodo* actual = lista;
while (actual != NULL)
{
cout << actual->dato << " -> ";
actual = actual->siguiente;
}
cout << "NULL" << endl << endl;
}

/* Función que mezcla (baraja) dos listas enlazadas */

nodo* MezclarListas(nodo*& p, nodo*& q)
{
nodo* pActual, * qActual, * listaMezclada = NULL, * ultimo;
pActual = p;
qActual = q;

while (pActual != NULL || qActual != NULL)

{
if (pActual != NULL)
{
InsertarDatoAlFinal(listaMezclada, ultimo, pActual->dato);
pActual = pActual->siguiente;
}
if (qActual != NULL)
{
InsertarDatoAlFinal(listaMezclada, ultimo, qActual->dato);
qActual = qActual->siguiente;
}
}

return listaMezclada;
}