Ingeniera de Sistemas e Informtica

Nombre Juan Jos Ruiz, Mauro Rivadeneira Maldonado

Fecha: 23/05/2016
Perodo: Abril agosto 2016

NRC: 1100

Estructura de datos

1.- Tema. Listas doblemente enlazadas con ordenamiento

2.- Objetivos
Objetivo General. - Aprender el funcionamiento de las listas
doblemente enlazadas.

Objetivos Especficos:
Ordenar una lista doblemente enlazada

3.- Desarrollo:
Marco Terico
Lista doblemente enlazada:
Una lista doblemente enlazada tiene en sus nodos 2 enlaces
(atrs y adelante) estos enlaces que son punteros de tipo nodo
apuntan a la direccin de memoria de otros 2 nodos que se
encuentran en la lista antes y despus del nodo que estemos
trabajando respectivamente, adems del dato, esto permite recorrer
la lista en todas direcciones.
Tanto el primer nodo de la lista como el ultimo deben tener sus
respectivos enlaces sueltos apuntando a NULL.
Construimos adems mtodos para que puedan accederse y
modificarse estos atributos individualmente fuera de la clase nodo.

Despus del nodo se crea la clase lista, esta clase cuenta al

igual que la lista simple con un atributo puntero que sirve de

cabecera (cabeza), y es el que siempre va a apuntar al primer

elemento de la lista, adems servir como referencia para
operaciones como son: insertar, eliminar o buscar.
Las operaciones de la lista doble son muy similares a las de la
simple, pero gracias a que contamos con apuntadores hacia los nodos
de atrs y adelante no necesitamos punteros auxiliares que nos den
la direccin de algn nodo anterior ya que es posible trabajar con los
enlaces en ciertos casos.
Ordenar una lista doblemente enlazada:
Es posible ordenar una lista doblemente enlazada utilizando el
mtodo de la burbuja, al igual que con los arreglos estticos, se
puede mover el elemento de un nodo a otro ya sea ascendentemente
o descendentemente para ordenar los valores, para ello se utilizan 2
punteros ndices que estarn apuntando a 2 nodos a la vez, una vez
ordenado pasaran a los 2 nodos siguientes. Es ms sencillo de esta
forma para no tener que romper y armar los enlaces.
4.- Cdigo
typedef int Dato;
#include "iostream"
using namespace std;
class Nodo2
{
protected:
Dato dato;
Nodo2* adelante;
Nodo2* atras;
public:
Nodo2(Dato);
void setatras(Nodo2*);
void setadelante(Nodo2*);
void setdato(Dato);
Dato getdato();
Nodo2* getatras()const;
Nodo2* getadelante()const;
};
#include "stdafx.h"
#include "Nodo2.h"
Nodo2::Nodo2(Dato dato)
{
this->dato = dato;
adelante = atras = NULL;
}
void Nodo2::setatras(Nodo2 *atras)
{
this->atras = atras;
}
void Nodo2::setadelante(Nodo2 *adelante)

{
}

this->adelante = adelante;

void Nodo2::setdato(Dato dato)

{
this->dato = dato;
}
Dato Nodo2::getdato()
{
return dato;
}
Nodo2 * Nodo2::getatras() const
{
return atras;
}
Nodo2 * Nodo2::getadelante() const
{
return adelante;
}
#include "Nodo2.h"
class Lista_doble
{
private:
Nodo2 *cabeza;
public:
Lista_doble();
Lista_doble(Dato);
void insertar_inicio(Dato);
void insertar_final(Dato);
void insertar_despues_de(Nodo2*, Dato);
void insertar_antes_de(Nodo2*, Dato);
void eliminar(Dato);
Nodo2* buscarlista(Dato);
Nodo2* buscarposicion(int);
void insertarorden_ascendente(Dato);
void insertarorden_descendente(Dato);
void ordenar_ascendente();
void ordenar_descendente();
void mostrarlista();
};
#include "stdafx.h"
#include "Lista_doble.h"
Lista_doble::Lista_doble()
{
cabeza = NULL;
}
Lista_doble::Lista_doble(Dato dato)
{
cabeza = new Nodo2(dato);
}
void Lista_doble::insertar_inicio(Dato dato)

{
Nodo2* nuevo = new Nodo2(dato);
nuevo->setadelante(cabeza);
if (cabeza != NULL) {
cabeza->setatras(nuevo);
}
cabeza = nuevo;
}
void Lista_doble::insertar_final(Dato dato)
{
Nodo2*p;
Nodo2* nuevo= new Nodo2(dato);
if (cabeza == NULL) {
cabeza = nuevo;
}
else {
for (p = cabeza; p->getadelante() != NULL; p = p->getadelante()) {
}
p->setadelante(nuevo);
nuevo->setatras(p);
}
}
void Lista_doble::insertar_despues_de(Nodo2 *antes, Dato dato)
{
Nodo2* nuevo = new Nodo2(dato);
if (cabeza == NULL) {
cout << "la lista esta vacia" << endl;
}
else {
nuevo->setadelante(antes->getadelante());
nuevo->setatras(antes);
antes->setadelante(nuevo);
if (antes->getadelante() != NULL) {
antes->getadelante()->setatras(nuevo);
}
}
}
void Lista_doble::insertar_antes_de(Nodo2 *despues, Dato dato)
{
Nodo2* nuevo = new Nodo2(dato);
//if (despues->getatras() == NULL) {
if(cabeza==despues){
insertar_inicio(dato);
}
else {
nuevo->setatras(despues->getatras());
nuevo->setadelante(despues);
nuevo->getatras()->setadelante(nuevo);
despues->setatras(nuevo);
}
}
void Lista_doble::eliminar(Dato dato)
{
Nodo2 *p;
p = cabeza;
if (p == NULL) {

"La lista esta vacia";

}
else {
if (dato == p->getdato()) {
p = p->getadelante();
cabeza = p;
}
else {
do {
p = p->getadelante();
if (p->getdato() == dato) {
p->getatras()->setadelante(p->getadelante());
if (p->getadelante() != NULL) {
p->getadelante()->setatras(p->getatras());
}
break;
}
} while (p->getadelante() != NULL);
}
}

Nodo2 * Lista_doble::buscarlista(Dato dato)

{
Nodo2*p;
p = cabeza;
while (p != NULL) {
if (p->getdato() == dato) {
return p;
}
p = p->getadelante();
}
return NULL;
}
Nodo2 * Lista_doble::buscarposicion(int static posicion)
{
Nodo2*p;
int cont = 1;
p = cabeza;
if (posicion < 1||p==NULL) {
return NULL;
}
for (cont = 1; cont < posicion && p != NULL;cont++, p = p->getadelante()){
}
return p;
}
void Lista_doble::insertarorden_ascendente(Dato dato)
{
Nodo2* nuevo=new Nodo2(dato);
Nodo2*p;
p = cabeza;
if (p == NULL || dato < p->getdato()) {
insertar_inicio(dato);
}
else {
do {
p = p->getadelante();
if (p == NULL) {

insertar_final(dato);
}
else if (dato <= p->getdato()) {
nuevo->setatras(p->getatras());
nuevo->setadelante(p);
nuevo->getatras()->setadelante(nuevo);
p->setatras(nuevo);
break;
}
} while (p != NULL);
}

void Lista_doble::insertarorden_descendente(Dato dato)

{
Nodo2* nuevo = new Nodo2(dato);
Nodo2*p;
p = cabeza;
if (p == NULL || dato > p->getdato()) {
insertar_inicio(dato);
}
else {
do {
p = p->getadelante();
if (p == NULL) {
insertar_final(dato);
}
else if (dato > p->getdato()) {
nuevo->setatras(p->getatras());
nuevo->setadelante(p);
nuevo->getatras()->setadelante(nuevo);
p->setatras(nuevo);
break;
}
}

} while (p != NULL);

}
void Lista_doble::ordenar_ascendente()
{
Nodo2 *p, *q;
Dato aux;
p = cabeza;
for (p = cabeza; p != NULL; p = p->getadelante()) {
for (q = p->getadelante(); q != NULL; q = q->getadelante()) {
if (p->getdato() > q->getdato()) {
aux = p->getdato();
p->setdato(q->getdato());
q->setdato(aux);
}
}
}
}
void Lista_doble::ordenar_descendente()
{
Nodo2 *p, *q;

Dato aux;
p = cabeza;
for (p = cabeza; p != NULL; p = p->getadelante()) {
for (q = p->getadelante(); q != NULL; q = q->getadelante()) {
if (p->getdato() < q->getdato()) {
aux = p->getdato();
p->setdato(q->getdato());
q->setdato(aux);
}
}
}
}
void Lista_doble::mostrarlista()
{
Nodo2 *p;
p = cabeza;
do {
cout << p->getdato() << " ";
p = p->getadelante();
} while (p != NULL);
}
#include "stdafx.h"
#include "Lista_simple.h"
#include "Lista_doble.h"
#include <Windows.h>
using namespace System;
void gotoxy(int x, int y)//Funcion para que nos permita el uso del gotoxy
{
COORD coord;
coord.X = x; coord.Y = y;//Coordenadas de x y y
HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleCursorPosition(hStdOut, coord);
}
void menu(Lista_doble l2) {
Dato aux;
Nodo2 *auxnodo;
char opl = '0';
do
{
system("cls");
system("color 3F");
cout << "\t\t///////////////////////////////////\n!";
cout << "\t\t**MENU LISTAS ENLAZADAS DOBLES
\n";
cout << "\t\t
\n";
cout << "\t\t 1: Insertar al inicio
\n";
cout << "\t\t 2: Insertar al final
\n";
cout << "\t\t 3: Insertar despues de un numero
\n";
cout << "\t\t 4: Insertar antes de un numero \n";
cout << "\t\t 5: Buscar un numero
\n";
cout << "\t\t 6: Buscar en una posicion
\n";
cout << "\t\t 7: Insertar en orden ascendente \n";
cout << "\t\t 8: Insertar en orden descendente \n";
cout << "\t\t 9: Mostrar lista
\n";
cout << "\t\t a: Ordenar lista ascendente
\n";
cout << "\t\t d: Ordenar lista descendente
\n";
cout << "\t\t x: Salir
\n";
cout << "\t\t e: Eliminar
\n";
cout << "\t\t///////////////////////////////////\n";
gotoxy(30, 20); cout << "SELECCIONE OPCION:";

cin >> opl;

switch (opl)
{
case '1':
system("cls");
cout << "ingrese un numero" << endl;
cin >> aux;
l2.insertar_inicio(aux);
l2.mostrarlista();
system("pause");
break;
case '2':
system("cls");
cout << "ingrese un numero" << endl;
cin >> aux;
l2.insertar_final(aux);
l2.mostrarlista();
system("pause");
break;
case '3':
system("cls");
cout << "ingrese un numero anterior" << endl;
cin >> aux;
auxnodo = l2.buscarlista(aux);
if (auxnodo == NULL) {
cout << "no existe el numero en la lista" << endl;
}
else {
cout << "ingrese un numero a ingresar" << endl;
cin >> aux;
l2.insertar_despues_de(auxnodo, aux);
l2.mostrarlista();
}
system("pause");
break;
case '4':
system("cls");
cout << "ingrese un numero anterior" << endl;
cin >> aux;
auxnodo = l2.buscarlista(aux);
if (auxnodo == NULL) {
cout << "no existe el numero en la lista" << endl;
}
else {
cout << "ingrese un numero a ingresar" << endl;
cin >> aux;
l2.insertar_antes_de(auxnodo, aux);
l2.mostrarlista();
}
system("pause");
break;
case '5':
system("cls");
cout << "ingrese un numero a buscar" << endl;
cin >> aux;
auxnodo = l2.buscarlista(aux);
if (auxnodo == NULL) {
cout << "no existe el numero en la lista" << endl;
}

else {
cout << "el numero si existe" << endl;
l2.mostrarlista();
}
system("pause");
break;
case '6':
system("cls");
int pos ;
cout << "ingrese posicion" << endl;
cin >> pos;
auxnodo = l2.buscarposicion(pos);
if (auxnodo == NULL) {
cout << "no existe el numero en la lista" << endl;
}
else {
cout << "el numero de la posicion " <<pos<<"es:
"<<auxnodo->getdato()<< endl;
}
//
l2.mostrarlista();
system("pause");
break;
case '7':
system("cls");
cout << "ingrese un numero" << endl;
cin >> aux;
l2.insertarorden_ascendente(aux);
l2.mostrarlista();
system("pause");
break;
case '8':
system("cls");
cout << "ingrese un numero" << endl;
cin >> aux;
l2.insertarorden_descendente(aux);
l2.mostrarlista();
system("pause");
break;
case '9':
system("cls");
l2.mostrarlista();
system("pause");
break;
case 'a':
system("cls");
cout << "Lista ordenada ascendentemente" << endl;
l2.ordenar_ascendente();
l2.mostrarlista();
system("pause");
break;
case 'd':
system("cls");
cout << "Lista ordenada descendentemente" << endl;
l2.ordenar_descendente();
l2.mostrarlista();
system("pause");
break;
case 'e':
system("cls");
cout << "ingrese un numero" << endl;

cin >> aux;

l2.eliminar(aux);
l2.mostrarlista();
system("pause");
break;
case 'x':
break;

}
} while (opl != 'x');

int main()
{
Lista_doble l2;
menu(l2);
system("pause");
return 0;
}

5.- Conclusin
Las listas doblemente enlazadas funcionan de manera similar a
las listas simplemente enlazadas, pero su segundo enlace
(atrs) puede facilitar algunos procesos.
6.- Recomendaciones
Especificar bien los identificadores de los enlaces para no tener
problemas al momento de hacer las operaciones, es recomendable
especificar cul es el enlace de atrs y cual el de adelante, evitar
poner nombres como enlace1 y enlace2.
Tener en cuenta cual es la cabeza de la lista, pues est siempre va a
ser nuestra referencia, siempre debe estar apuntando al primer
elemento de la lista.

7.- Bibliografia

Bibliografa
Joyanes, Aguilar.(2007). Estructura de datos en C++ (1
ed.).Madrir,Espaa:Mcgraw-Hill.