Listas Enlazadas en C++:

Ejemplo
Paso
Tipos Básicos Estructuras
struct Tcomplex
{
double p_r;
double p_i;
};
typedef Tcomplex *TPComplex;

typedef int *TPInt; ó

Definición del Tipo typedef char *TPChar;
typedef struct Tcomplex *TPComplex;
struct Tcomplex
{
double p_r;
double p_i;
};

Declaración de TPInt p_int;

TPComplex p_complex;
varibles TPChar p_char;
p_int = new(int);
p_char = new(char); p_complex = new(Tcomplex);
Petición de
memoria (y if((p_int == NULL) || if(p_complex == NULL)
comprobación de (p_char == NULL)) {
que la ha asignado) { cout << “No hay memoria” << endl;
cout << “No memoria”; }
}
Acceso I: *p_int = 7;
p_complex->p_r = 4.6;
Modifición cin >> *p_char;
Acceso II: cout << *pint;
parte_img = p_complex->p_i;
Consulta un_char = *p_char;
delete(p_int);
Borrado delete(p_char);
delete(p_complex);

Declaración del Tipo:

typedef ... Tdatos; typedef ... Tdatos;

struct Tnodo typedef struct Tnodo *Tlista;

{ struct Tnodo
Tdatos datos; {
Tnodo *sig; Tdatos datos;
}; Tnodo *sig;
typedef Tnodo *Tlista; };
Definición de la Variable:

Basura
Tlista primero;
primero

Inicialización de la Lista:

Tlista crear()
{
return NULL; NULL
}
... primero
primero = crear();

Insertar Ordenado:

1. Crear Nodo a insertar

void insertar(Tlista &l, Tdato d)

{
Tlista paux;
paux = new(Tnodo);

if(paux == NULL)
{ d NULL
cout << “ERROR”;
} paux
else
{
paux->dato = d;
paux->sig = NULL;
}

2. Si la lista es vacía introducimos al principio:

NULL
if( l == NULL )
{ l => l
l = paux;
} d NULL d NULL

paux paux

3. Si no es vacía comprobamos si hay que añadir al principio:

e … e …
if( l.dato > d )
{
paux->sig = l;
l => l
l = paux; d NULL d
}
paux paux
 4. Insertamos en medio

a b e …
/* Creamos un puntero auxiliar l
para buscar la posición donde
insertar */
pbusca = l; d NULL
pbusca paux
/* Recoremos la lista buscando a b e …
donde insertar */
while( (pbusca->sig != NULL) && l
(pbusca->sig->datos < d))
{ d NULL
pbusca = pbusca->sig;
} pbusca paux
a b e …
/* Una vez encontrada la posición l
insertamos el nuevo nodo */
paux->sig = pbusca->sig;
pbusca->sig = paux; d
pbusca paux

Borrar:

Borrar es similar a la insertar. Primero se comprueba si es vacía, en tal caso no

hacemos nada. Si no está vacía buscamos el elemento que queramos borrar, y una vez
localizado, lo sacamos de la lista y liberamos la memoria que tenía asignada-

1. Borrado del primer elemento

if(l->dato == d)
{
ptr = l;
l = l->sig;
delete(ptr);
}

d e ... => d e ...

l l

ptr ptr
 2. Borrado de un elemento intermedio

/* Creamos dos punteros a b d e …

auxiliares uno que examine la
posición actual y otro que l
indique la posición anterior
*/
pact = l->sig;
pant = l; pant pact
/* Recoremos la lista
buscando el nodo a borrar*/ a b d e …
while((pact != NULL) &&
l
(pact->dato != d))
{
pant = pact;
pact = pact->sig;
} pant pact

/* Una vez encontrada la

posición borramos el nodo */ a b d e …
if(pact != NULL)
{
l
pant->sig = pact->sig;
delete(pact);
}
pant pact