TDA Lista implementado en estructura de lista simplemente ligada

Este desarrollo es sumamente sencillo. Tiene por objeto comprender el

mecanismo de altas, bajas, recorridos en una estructura de lista ligada.
En la cursada se les pedirá que puedan manipular listas para operar con
los nodos a “nivel bajo”, como hemos visto en la primera clase, y también
que puedan resolver problemas más complejos a nivel más alto y abstracto
utilizando una clase lista ya armada y provista de todos los métodos
imprescindibles, además de iteradores para movernos dentro de la
estructura.
Los dos aspectos son complementarios. Ambos deben ser manejados con
soltura y ambos serán evaluados en el parcial.

//Este es el código que comenzamos a armar en clase, con explicaciones.

//Se pide leerlo todo, y hacer el seguimiento, incluso de los
métodos //que no llegamos a desarrollar

// Separar el código en .h, .cpp y main

#include <iostream>
using namespace std;

class nodo
{
private:
int info;
nodo *sig;
public:
nodo(int,nodo *);
int Getinfo() {return info;}
nodo *Getsig() {return sig;}
void Setinfo(int i) {info=i;}
void Setsig (nodo *n) {sig=n;}
};

// estructura del nodo:

Info sig

// Constructor del nodo. Tiene un argumento por defecto. Si se lo

invoca // con un solo argumento, que debe ser el dato a almacenar en
info, pone // a NULL el puntero del atributo sig
nodo::nodo(int x,nodo *p=NULL){info=x; sig=p;}

class lista
{
private:
nodo *p;
public:
lista(); //constructor sin argumentos; (agregar el
constructor copia)
~lista(); //destructor
void altafin(int); // alta al final
void altaprin(int); //alta al principio
//baja de la primera aparicion de un elemento determinado
// modificarlo para que realice la baja de todas las apariciones
void baja(int);
bool esta(int)const; // retorna un bool indicando si el entero
pasado por argumento está en la lista
void emite()const; //emite la lista
};

//Un objeto lista (con estructura d elista simplemente ligada) se

puede //pensar así:

O b j e t o s n o d o

Objeto lista

//Alta al principio
//Se puede plantear así:
//Esté nulo o no el puntero de entrada, mediante un puntero auxiliar aux
//generamos un nuevo nodo.
//El atributo sig del nodo nuevo debe apuntar al primer nodo de la lista
//Luego reasignamos p haciendo que apunte al nodo nuevo, que de esta
forma se convierte en el primero de la lista
/*
En código:
aux=new nodo (x); //Se genera el nodo con x en el atributo info
aux->Setsig(p); //asi el siguiente de aux apunta al primer nodo
p= aux; //p apunta al nodo nuevo

Con el constructor de Nodo que está propuesto en la clase Nodo al

principio de este apunte, el alta al principio se puede “acortar” como se
indica a continuación:
*/
void lista::altaprin(int x)
{
p=new nodo(x,p);
//aquí, primero se genera el nodo con new, que llama al constructor,
y //coloca el valor de p (dirección del primer nodo en sig del nodo
nuevo.
//Luego la dirección de este nodo nuevo se almacena en p
}

//Alta al final
//con un puntero auxiliar, si no está nulo el puntero de entrada,
//recorremos la lista hasta apuntar al nodo que tiene NULL en sig. La
//dirección del nodo nuo debe quedar almacenada en el atributo sig
del //último nodo.
void lista::altafin(int x)
{
nodo *aux=p; //asignamos p a aux, aunque no sabemos si p es nulo o no
while ((aux)&&(aux->Getsig()))
aux=aux->Getsig();

//es decir, mientras aux no sea nulo (por haber sido nulo p) y no sea
nulo //el puntero sig del nodo apuntado por aux, avanzamos.

if (aux)

//con esa condición preguntamos si aux no está nulo (es decir, si

está //apuntando a un nodo que sí debe tener nulo el sig)
{
aux->Setsig(new nodo(x));

//generamos el nodo nuevo, con NULL en el atributo sig, y su

dirección //queda almacenada en aux->sig
}

else p=new nodo(x,p);

//Si el puntero aux esta nulo, es porque p está nulo, entonces generamos
//el nodo nuevo desde p
}

//Baja de un elemento determinado

//Se desarrolla acá la baja de la primera aparición de un elemento.
//Hacer una baja será eliminar el nodo que contenga ese elemento.
//Este algoritmo se deberá modificar para realizar la baja de todos
los //nodos que contengan el elemento pasado por argumento, dado que
una //lista es un contenedor que admite repeticiones

void lista::baja(int x)
//Elimina la primera aparicion del dato pasado por argumento
//Ejercicio: analizar el código y modificarlo para que elimine todos los
//nodos con el valor pasado
{
if (p)
{
if((p->Getinfo()!=x) && (p->Getsig()))
{
nodo *aux1 =p, *aux2 =p->Getsig();
while ((aux2->Getinfo()!=x) && (aux2->Getsig()!=NULL))
{
aux1=aux2 ;
aux2 =aux2->Getsig();
}
if (aux2->Getinfo()==x)
{
aux1->Setsig(aux2->Getsig());

delete aux2;
}
}
else if(p->Getinfo()==x)
{
nodo *aux =p;
p=p->Getsig();
delete aux;
}
}
}
lista::~lista()
{
if (p)
{
nodo *aux=p;
while (aux)
{
p=p->Getsig();
delete aux;
aux=p;
}
}
}

//Búsqueda de un elemento en la lista: con el método esta

bool lista::esta(int x) const

{
nodo *aux=p;
while(aux)
{
if (aux->Getinfo() == x) return true;
else aux=aux->Getsig();
}
return false;
}

// Recorrido de la lista: a través del método emite

void lista::emite()const
{
nodo *aux=p;
while (aux)
{
cout<<aux->Getinfo();
aux=aux->Getsig();
}
}

//Constructor de lista: coloca el puntero de entrada en NULL

lista::lista():p(0){}

//Ejemplo de uso de la clase lista

int main()
{
lista l;
cout<<"\n alta al final de 1\n";
l.altafin(1);
l.emite();
cout<<"\n alta al final de 2\n";
l.altafin(2);
l.emite();
cout<<"\n alta al final de 3\n";
l.altafin(3);
l.emite();
cout<<"\n alta al final de 4\n";
l.altafin(4);
l.emite();
cout<<"\n alta al principio de 5\n";
l.altaprin(5);
l.emite();
cout<<"\n baja 4\n";
l.baja(4);
l.emite();
cout<<"\n baja 1\n";
l.baja(1);
l.emite();
cout<<endl;
system("pause");
return 0;