Buenas!
Resulta que he estado estudiando en la universidad las
estructuras de datos en C++, y me gustaría compartirles algunos códigos que he estado haciendo en este tiempo, son códigos más que nada de la escuela. He buscado información al respecto en internet, y la mayoria (por no decir todos) están hechos en C (los que he visto en español), utilizan estructuras con
struct y
no objetos en C++, así que sirve que alimentamos el internet y el foro ;D .
No les voy a mostrar teoría sobre el tema, eso se los dejo a su búsqueda.
listas.h#include <iostream>
using namespace std;
#ifndef __LISTAS_H_INCLUDED__
#define __LISTAS_H_INCLUDED__
class Nodo{
private:
int dato;
Nodo *sig;
Nodo *ant;
public:
Nodo(void) { sig = ant = NULL; }
Nodo( int x , Nodo* s = NULL , Nodo* a = NULL )
{
dato = x;
sig = s;
ant = a;
}
// SETTERS
void setDato(int x) { dato = x; }
void setAnt(Nodo *a) { ant = a; }
void setSig(Nodo *s) { sig = s; }
// GETTERS
int getDato() { return dato;}
Nodo *getAnt() { return ant; }
Nodo *getSig() { return sig; }
};
class Lista
{
private:
Nodo *lista; // ancla
public:
Lista(void) { Inicializar(); } // CONSTRUCTOR
// METODOS BASICOS
Nodo *Primero() { return lista; }
Nodo *Siguiente(Nodo *pos) { return pos->getSig(); }
Nodo *Anterior(Nodo *pos) { return pos->getAnt(); }
Nodo *Ultimo() {
Nodo *aux = lista;
if ( !Vacia() ) { while ( aux->getSig() ) { aux = aux->getSig(); } }
return aux;
}
// METODOS DE LA LISTA
void Inicializar() { lista = NULL; }
bool Vacia() { return lista==NULL; }
void Mostrar();
void Insertar(int x, Nodo* pos = NULL);
};
void Lista::Insertar(int x, Nodo* pos)
{
Nodo* aux;
Nodo* temp_n = new Nodo(x);
if ( Vacia() ){
lista = temp_n;
}else{
if ( pos == Primero() ){
aux = Primero();
aux->setAnt(temp_n);
temp_n->setSig(aux);
lista = temp_n;
}else if ( pos == NULL ){
aux = Ultimo();
aux->setSig(temp_n);
temp_n->setAnt(aux);
}else{
aux = Primero();
while ( aux ){
if ( aux == pos ){
Anterior(aux)->setSig( temp_n );
temp_n->setAnt( Anterior(aux) );
temp_n->setSig( aux );
aux->setAnt( temp_n );
}else {
aux = aux->getSig();
}
}
}
}
}
void Lista::Mostrar()
{
Nodo* aux;
Primero();
aux = lista;
if ( !Vacia() ){
while ( aux ){
cout << aux ->getDato();
cout << "\n";
aux = aux ->getSig();
}
}
}
#endif
main.cpp#include <iostream>
#include "listas.h"
using namespace std;
int main(void)
{
Lista numeros; // Mi lista
char opc; // Opcion del menu
int n; // dato a insertar
do{
cout << "\n \n LISTAS DOBLEMENTE LIGADAS: ";
cout << "\n *- MENU -* ";
cout << "\n 1. AGREGAR A LA LISTA . ";
cout << "\n 2. MOSTRAR LOS DATOS . ";
cout << "\n 3. SALIR . ";
cout << "\n _> ";
cin >> opc;
switch(opc){
case '1':
cout << "\n AGREGANDO DATOS A LA LISTA . ";
cout << "\n INGRESE EL VALOR NUMERICO . ";
cout << "\n _> ";
cin >> n;
numeros.Insertar(n);
cout << " --> < Guardado correctamente > " << endl;
break;
case '2':
if(numeros.Vacia())
{
cout << "\n < No hay registros!. > ";
break;
}
cout << "\n \n DATOS GUARDADOS EN LA LISTA: \n ";
numeros.Mostrar();
break;
case '3':
cout << " - < Saliendo!...... >" << endl;
break;
default:
cout << " - < Opcion incorrecta!, intente de nuevo. >" << endl;
break;
}
}while(opc!='3');
cin.ignore();
return 0;
}
Espero que les sea de utilidad, y son bienvenidas sus criticas y/o comentarios 8)
Zalu2!
Buenas!
Hace poco cree un tema sobre un en C++, pues quería compartirles otro código que no lo hice para la escuela y por lo tanto me dió más tiempo de currarmelo más y agregarle más métodos ;D .
(http://foro.elhacker.net/programacion_cc/estructura_de_datos_listas_doblemente_ligadas_c-t439306.0.html[/url)
#include <iostream>
using namespace std;
#define ASCENDENTE 1
#define DESCENDENTE 0
class nodo
{
private:
int valor;
nodo *siguiente;
nodo *anterior;
friend class lista;
public:
nodo(int v, nodo *sig = NULL, nodo *ant = NULL) // CONSTRUCTOR
{
valor = v;
siguiente = sig;
anterior = ant;
}
// SETTERS
void setAnterior(nodo *ant) { anterior = ant; }
void setSiguiente(nodo *sig) { siguiente = sig; }
// GETTERS
int getValor() { return valor; }
nodo *getSiguiente() { return siguiente; }
nodo *getAnterior() { return anterior; }
};
class lista
{
private:
nodo *plista; // ANCLA
public:
lista(){ plista = NULL; } // CONSTRUCTOR
~lista(); // DESTRUCTOR
// METODOS DE LA LISTA
void Insertar(int v);
void Borrar(int v);
bool ListaVacia() { return plista == NULL; }
void Mostrar(int);
// METODOS DE POSICION
void Siguiente() { if(plista) plista = plista->getSiguiente(); }
void Anterior() { if(plista) plista = plista->getAnterior(); }
void Primero() { while(plista && plista->getAnterior()) plista = plista->getAnterior(); }
void Ultimo() { while(plista && plista->getSiguiente()) plista = plista->getSiguiente(); }
int ValorActual() { return plista->valor; }
};
lista::~lista() // VACIAMOS LA LISTA
{
nodo *aux;
Primero();
while(plista) {
aux = plista;
plista = plista->getSiguiente();
delete aux;
}
}
void lista::Insertar(int v)
{
nodo *nuevo;
Primero();
// Si la lista está vacía
if(ListaVacia() || plista->getValor() > v)
{
nuevo = new nodo(v, plista);
if(!plista) plista = nuevo;
else plista->setAnterior(nuevo);
}
else
{
while(plista->getSiguiente() && plista->getSiguiente()->getValor() <= v) Siguiente();
// Creamos un nuevo nodo después del nodo actual
nuevo = new nodo(v, plista->getSiguiente(), plista);
plista->setSiguiente(nuevo);
if(nuevo->getSiguiente()) nuevo->getSiguiente()->setAnterior(nuevo);
}
}
void lista::Borrar(int v)
{
nodo *nodo;
nodo = plista;
while(nodo && nodo->getValor() < v) nodo = nodo->getSiguiente();
while(nodo && nodo->getValor() > v) nodo = nodo->getAnterior();
if(!nodo || nodo->getValor() != v) return;
// Borrar el nodo
if(nodo->getAnterior()) // no es el primer elemento
nodo->getAnterior()->setSiguiente(nodo->getSiguiente());
if(nodo->getSiguiente()) // no el el último nodo
nodo->getSiguiente()->setAnterior(nodo->getAnterior());
delete nodo;
}
void lista::Mostrar(int orden)
{
nodo *nodo;
if(orden == ASCENDENTE)
{
Primero();
nodo = plista;
while(nodo)
{
cout << nodo->getValor() << "-> ";
nodo = nodo->getSiguiente();
}
}
else
{
Ultimo();
nodo = plista;
while(nodo)
{
cout << nodo->getValor() << "-> ";
nodo = nodo->getAnterior();
}
}
cout << endl;
}
int main(void) {
lista Lista;
Lista.Insertar(20);
Lista.Insertar(10);
Lista.Insertar(40);
Lista.Insertar(30);
Lista.Mostrar(ASCENDENTE);
Lista.Mostrar(DESCENDENTE);
Lista.Primero();
cout << "Primero: " << Lista.ValorActual() << endl;
Lista.Ultimo();
cout << "Ultimo: " << Lista.ValorActual() << endl;
Lista.Borrar(10);
Lista.Borrar(15);
Lista.Borrar(45);
Lista.Borrar(40);
Lista.Mostrar(ASCENDENTE);
Lista.Mostrar(DESCENDENTE);
return 0;
}
Espero que les guste y les sirva, cualquier duda y/o comentario me lo hacen saber ::).
Zalu2!
Te faltó [ESTRUCTURA DE DATOS] Listas doblemente ligadas [C++] (otro ejemplo) xD
En realidad no, lo adjunte a este hilo; como siempre la politica es que si quieren subir codigo (cosa que no aliento, esta mejor en un repositorio de codigo o en un Blog) lo hagan un solo hilo con su nombre.