LISTA ENCADENADA SIMPLE

Qu es una lista?Una lista enlazada es un conjunto de elementos

llamados nodos en los que cada uno de ellos contiene un dato y tambin la direccin
del siguiente nodo,donde el orden de los mismos seestablece mediante punteros.
La idea bsica es que cada componente de la listaincluya un
puntero que indique donde puede encontrarse el siguiente componente por lo que el
orden relativo de estos puede ser fcilmente alterado modificando los punteros
lo que permite, a su vez, aadir o suprimir elementos de la lista. El primer elemento
de la lista es la cabecera, que slo contiene un puntero que seala el primer
elemento de la lista.
El ltimo nodo de la lista apunta a NULL (nulo) porque no hay ms nodos en la lista.
Se usar el trmino NULL para designar el final de la lista.
Listas Enlazadas frente a Arrays
Las listas enlazadas tienen las siguiente ventajas sobre los arrays:

No requieren memoria extra para soportar la expansin. Por el contrario, los

arrays requieren memoria extra si se necesita expandirlo (una vez que todos los
elementos tienen datos no se pueden aadir datos nuevos a un array).

Ofrecen una insercin/borrado de elementos ms rpida que sus operaciones

equivalentes en los arrays. Slo se tienen que actualizar los enlaces despus de
identificar la posicin de insercin/borrado. Desde la perspectiva de los arrays, la
insercin de datos requiere el movimiento de todos los otros datos del array para
crear un elemento vaco. De forma similar, el borrado de un dato existente
requiere el movimiento de todos los otros datos para eliminar el elementovaco.

En contraste, los arrays ofrecen las siguiente ventajas sobre las listas enlazadas:

Los elementos de los arrays ocupan menos memoria que los nodos porque no
requieren campos de enlace.

Los arrays ofrecen un aceso ms rpido a los datos, medante ndices basados
en enteros.

Las listas enlazadas son ms apropiadas cuando se trabaja con datos dinmicos. En
otras palabras, inserciones y borrados con frecuencia. Por el contrario, los arrays son
ms apropiados cuando los datos son estticos (las inserciones y borrados son
raras). De todas formas, no olvide que si se queda sin espacio cuando aade tems a

un array, debe crear un array ms grande, copiar los datos del array original el nuevo
array mayor y elimiar el original. Esto cuesta tiempo, lo que afecta especialmente al
rendimiento si se hace repetidamente.
Mezclando una lista de enlace simple con un array uni-dimensional para acceder a
los nodos mediante los ndices del array no se consigue nada. Gastar ms memoria,
porque necesitar los elementos del array ms los nodos, y tiempo, porque
necesitar mover los tems del array siempre que inserte o borre un nodo. Sin
embargo, si es posible integrar el array con una lista enlazada para crear una
estructura de datos ti.
Existen diferentes tipos de listas enlazadas: Lista Enlazadas Simples, Listas
Doblemente Enlazadas y Listas Enlazadas Circulares.
Las listas enlazadas pueden ser implementadas en muchos lenguajes. Lenguajes
tales como Lisp y Scheme tiene estructuras de datos ya construidas, junto con
operaciones para acceder a las listas enlazadas. Lenguajes imperativos u orientados
a objetos tales como C, C++ o Java disponen de referencias para crear listas
enlazadas.
Las operaciones que podemos realizar sobre una lista enlazada son las siguientes:
Recorrido. Esta operacin consiste en visitar cada uno de los nodos que

forman la lista . Para recorrer todos los nodos de la lista, se comienza con el
primero, se toma el valor del campo liga para avanzar al segundo nodo, el
campo liga de este nodo nos dar la direccin del tercer nodo, y as
sucesivamente.
Insercin. Esta operacin consiste en agregar un nuevo nodo a la lista. Para

esta operacin se pueden considerar tres casos:

o

Insertar un nodo al inicio.

Insertar un nodo antes o despus de cierto nodo.

Insertar un nodo al final.

Borrado. La operacin de borrado consiste en quitar un nodo de la lista,

redefiniendo las ligas que correspondan. Se pueden presentar cuatro casos:

o

Eliminar el primer nodo.

Eliminar el ltimo nodo.

Eliminar un nodo con cierta informacin.

Eliminar el nodo anterior o posterior al nodo cierta con informacin.

Bsqueda. Esta operacin consiste en visitar cada uno de los nodos, tomando

al campo liga como puntero al siguiente nodo a visitar.

Figura 1. Esquema de un nodo y una lista enlazada.

LISTA ENLAZADA SIMPLE

La lista enlazada bsica es la lista enlazada simple la cual tiene un enlace por
nodo. Este enlace apunta al siguiente nodo en la lista, o al valor NULL o a la lista
vaca, si es el ltimo nodo.

He aqu tenemos un ejemplo de una lista enlazada simple

//DECLARACIN DE PROTOTIPOS
#include<alloc.h>
#include<stdlib.h>
#include<conio.h>
#include<iostream.h>
//Declaramosla estructura
typedef struct nodo

{
int dato;
struct nodo * siguiente;
}tipoNodo;
//reservamos el espacio de memoria
tipoNodo *nuevo_elemento();
//Operaciones que vamos a arealizar
void crear();
void insertar();
void insertar_inicio();
void insertar_ordenado();
void insertar_final();
void presentar();
void modificar();
void buscar();
void ordenar();
void ordenar_ascendente();
void ordenar_descendente();
void eliminar();
void eliminar_cabeza();
//FUNCION PARA EL CUADRO
void cuadro(int x1,int y1, int x2, int y2, char simb);
//NUESTRA CABEZA
tipoNodo *cab;
tipoNodo *nuevo_elemento()
{
tipoNodo *nodo1;
nodo1=(tipoNodo *)malloc(sizeof(tipoNodo ));
if(!nodo1)
cout<<No se ha reservado memoria para el nuevo ;
return nodo1;
}
void main()
{

clrscr();
crear();
clrscr();
char opc= ;
do
{
clrscr();
cuadro(1,10,35,56,);
gotoxy(13,3);cout<<->[ LISTAS ENLAZADAS ]<-\n;
gotoxy(12,6);cout<<

MENU PRINCIPAL\n;

gotoxy(12,9); cout<< [1]: INSERTAR\n;

gotoxy(12,12);cout<< [2]: MODIFICAR\n;
gotoxy(12,15);cout<< [3]: BUSCAR\n;
gotoxy(12,17);cout<< [4]: ORDENAR\n;
gotoxy(12,19);cout<< [5]: ELIMINAR\n;
gotoxy(12,21);cout<< [6]: PRESENTAR\n;
gotoxy(12,24);cout<< [7]: SALIR DEL MENU\n;
gotoxy(12,27);cout<< Elegir una Opcin [ ];
gotoxy(32,27);cin>>opc;
switch(opc)
{
case1:
clrscr();
insertar();getch();break;
case2:
clrscr();
modificar();getch();break;
case3:
clrscr();
buscar();getch();break;
case4:
clrscr();
ordenar();getch();break;
case5:

clrscr();
eliminar();getch();break;
case6:
clrscr();
presentar();getch();break;
}
}while(opc!=7);
getch();
}
//CREANDO LA CABEZA
void crear()
{
clrscr();
cab=nuevo_elemento();
gotoxy(20,20);
cout<<Ingrese valor de cabeza :\t;
cin>>cab->dato;
cab->siguiente=NULL;
getch();
}
//MENU DE INSERTAR
void insertar()
{
clrscr();
char opc= ;
do
{
clrscr();
cuadro(1,10,35,56,);
gotoxy(13,3);cout<<->[ LISTAS ENLAZADAS ]<-\n;
gotoxy(12,6);cout<<

MENU PRINCIPAL\n;

gotoxy(12,9); cout<< [1]: INSERTAR AL INICIO\n;

gotoxy(12,12);cout<< [2]: insertar AL FINAL\n;

gotoxy(12,15);cout<< [3]: INSERTAR ORDENADO\n;

gotoxy(12,18);cout<< [4]: REGRESAR\n;
gotoxy(12,21);cout<< Elegir una Opcin [ ];
gotoxy(32,21);cin>>opc;
switch(opc)
{
case1:
clrscr();
insertar_inicio();getch();break;
case2:
clrscr();
insertar_final();getch();break;
case3:
clrscr();
insertar_ordenado();getch();break;
}
}while(opc!=4);
getch();
}
//INSERATAR AL INICIO
void insertar_inicio()
{
clrscr();
nodo *pAuxElem;
nodo *recorre;
pAuxElem=(tipoNodo*) malloc(sizeof(tipoNodo));
while(recorre->siguiente!=NULL)
{
recorre=recorre->siguiente;
}
int n;
gotoxy(20,20);
cout<<INGRESE VALOR :\t;

cin>>n;
pAuxElem->dato=n;
pAuxElem->siguiente=cab;
cab=pAuxElem;
}
//INSERTAR AL FINAL
void insertar_final()
{
clrscr();
nodo *elem;
elem=nuevo_elemento();
clrscr();
gotoxy(20,20);
cout<<INGRESE VALOR :\t;
cin>>elem->dato;
nodo *recorrer;
recorrer=cab;
while(recorrer->siguiente!=NULL)
recorrer=recorrer->siguiente;
recorrer->siguiente=elem;
elem->siguiente=NULL;
getch();
}
//INSERATAR ORDENADO
void insertar_ordenado()
{
clrscr();
nodo *pAuxElem;
nodo *post;
nodo *recorre;
pAuxElem=(tipoNodo*) malloc(sizeof(tipoNodo));
post=(tipoNodo*) malloc(sizeof(tipoNodo));
int n;
gotoxy(20,20);
cout<<INGRESE VALOR :\t;
cin>>n;
if(n<cab->dato)
{

post=cab->siguiente;
while((pAuxElem->dato>post->dato)&&(post->siguiente!=NULL))
{
post=post->siguiente;
}
if(post->siguiente!=NULL)
{
pAuxElem->siguiente=cab;
cab=pAuxElem;
}
else
{
pAuxElem->siguiente=NULL;
post->siguiente=pAuxElem;
}
}
else
{
while(recorre->siguiente!=NULL)
{
recorre=recorre->siguiente;
}
pAuxElem->dato=n;
pAuxElem->siguiente=cab;
cab=pAuxElem;
}
/*cout<<Ingrese un numero;
cin>>n;
if(n>cab->dato)
{
insertar_inicio(n);
}
else
{
nodo *aux;
nodo *ant;
aux=cab->siguiente;
while((aux!=NULL)(n>aux->dato))

{
ant=aux;
aux=aux->siguiente
}
nodo *nuevo;
nuevo=crear_nuevo();
nuevo->dato=n;
ant->siguiente=nuevo;
nuevo->siguiente=aux;
}*/
}
//PARA MODIFICAR
void modificar()
{
clrscr();
nodo *elem;
nodo *ele;
gotoxy(10,25);cout<<\n;
gotoxy(10,26);cout<<

\n;

gotoxy(10,27);cout<<MODIFICAR NUMERO DE LISTA \n;

gotoxy(10,28);cout<<

\n;

gotoxy(10,29);cout<<\n;
gotoxy(20,20);
cout<<INGRESE EL VALOR A MODIFICAR :\t;
cin>>elem->dato;
nodo *recorrer;
recorrer=cab;
while(recorrer!=NULL)
{
if(recorrer->dato==elem->dato)
{
clrscr();
gotoxy(20,20);
cout<<INGRESE VALOR :\t;
cin>>ele->dato;

recorrer->dato=ele->dato;
}
recorrer=recorrer->siguiente;
}
getch();
}
//PARA BUSCAR
void buscar()
{
clrscr();
nodo *elem;
gotoxy(10,25);cout<<\n;
gotoxy(10,26);cout<<

\n;

gotoxy(10,27);cout<<BUSCADOR DE NUMERO DE LISTA\n;

gotoxy(10,28);cout<<

\n;

gotoxy(10,29);cout<<\n;
gotoxy(20,20);
cout<<INGRESE EL VALOR A BUSCAR :\t;
cin>>elem->dato;
nodo *recorrer;
recorrer=cab;
while(recorrer!=NULL)
{
if(recorrer->dato==elem->dato)
{
clrscr();
gotoxy(20,20);
cout<<elem->dato<<:\t;
cout<<ESTE ELEMENTO SI EXISTE;
recorrer->dato=elem->dato;
}
recorrer=recorrer->siguiente;
}

getch();
}
//ORDENAR
void ordenar()
{
clrscr();
char opc= ;
do
{
clrscr();
cuadro(1,10,25,56,);
gotoxy(13,3);cout<<->[ ORDENAR LAS LISTAS ENLAZADAS ]<-\n;
gotoxy(12,6);cout<<

MENU PRINCIPAL\n;

gotoxy(12,9); cout<< [1]: ORDENAR ASCENDENTE\n;

gotoxy(12,12);cout<< [2]: ORDENAR DESCENDENTE\n;
gotoxy(12,15);cout<< [3]: REGRESAR\n;
gotoxy(12,17);cout<< Elegir una Opcin [ ];
gotoxy(32,17);cin>>opc;
switch(opc)
{
case1:
clrscr();
ordenar_ascendente();getch();break;
case2:
clrscr();
ordenar_descendente();getch();break;
}
}
while(opc!=3);
getch();
}

void ordenar_ascendente()
{
nodo* aux;
nodo* temp;
int vaux;
aux=(tipoNodo *)malloc(sizeof(tipoNodo));
temp=(tipoNodo *)malloc(sizeof(tipoNodo));
aux=cab;
while (aux!=NULL)
{
temp=aux;
while(temp->siguiente!=NULL)
{
temp=temp->siguiente;
if(aux->dato>temp->dato)
{
vaux=aux->dato;
aux->dato=temp->dato;
temp->dato=vaux;
}
}
aux=aux->siguiente;
}
}
void ordenar_descendente()
{
nodo* aux;
nodo* temp;
int vaux;
aux=(tipoNodo *)malloc(sizeof(tipoNodo));
temp=(tipoNodo *)malloc(sizeof(tipoNodo));
aux=cab;
while (aux!=NULL)
{
temp=aux;
while(temp->siguiente!=NULL)
{
temp=temp->siguiente;

if(aux->dato<temp->dato)
{
vaux=aux->dato;
aux->dato=temp->dato;
temp->dato=vaux;
}
}
aux=aux->siguiente;
}
}
//ELIMINAR
void eliminar()
{
presentar();
nodo *eliminar;
//

nodo *recorrer;

nodo *asigna;
gotoxy(10,25);cout<<\n;
gotoxy(10,26);cout<<

\n;

gotoxy(10,27);cout<<INSERTAR NUMERO A ELIMINAR\n;

gotoxy(10,28);cout<<

\n;

gotoxy(10,29);cout<<\n;
gotoxy(10,31);cout<<Ingrese el nmero a eliminar\t;
cin>>eliminar->dato;
//

recorrer=cab;

if (eliminar->dato==cab->dato)
{
eliminar_cabeza();
}
else
{
nodo *anterior=cab;
nodo * aux=cab->siguiente;
while((aux!=NULL)&&(aux->dato!=eliminar->dato))
{
anterior=aux;

aux=aux->siguiente;
}
if(aux!=NULL)
{
anterior->siguiente=aux->siguiente;
aux->siguiente=NULL;
free(aux);
}
else
{
gotoxy(10,33);
cout<<NO SE ENCUENTRA;
}
}
}
//ELIMINAR CABEZA
void eliminar_cabeza()
{
nodo *aux;
aux=cab;
cab=cab->siguiente;
aux->siguiente=NULL;
free(aux);
}
//PRESENTAR LA LISTA
void presentar()
{
clrscr();
int f=10;
nodo *recorrer;
recorrer=cab;
gotoxy(20,f);
while(recorrer!=NULL)
{
gotoxy(20,f);
cout<<recorrer->dato;
cout<<\n\n;
recorrer=recorrer->siguiente;

f=f+2;
}
getch();
}
//ESTA FUNCION PERMITE PRESENTAR LOS BORDES DE UN CUADRO
void cuadro(int x1,int y1, int x2, int y2, char simb)
{
for (int i1=y1;i1<=y2;i1++)
{
gotoxy(i1,x1);cout<<simb;
gotoxy(i1,x2);cout<<simb;
}
for (int i2=x1;i2<=x2;i2++)
{
gotoxy(y1,i2);cout<<simb;
gotoxy(y2,i2);cout<<simb;
}
}

LISTAS SIMPLES ENLAZADAS

ESTRUCTURA DE DATOS
En programacin, una estructura de datos es una forma de organizar un
conjunto de datos elementales con el objetivo de facilitar su manipulacin.
Un dato elemental es la mnima informacin que se tiene en un sistema.
Una estructura de datos define la organizacin e interrelacin de stos y un
conjunto de operaciones que se pueden realizar sobre ellos. Las operaciones
bsicas son:
Alta, adicionar un nuevo valor a la estructura.
Baja, borrar un valor de la estructura.
Bsqueda, encontrar un determinado valor en la estructura para realizar una
operacin con este valor, en forma secuencial o binario (siempre y cuando
los datos estn ordenados).
Otras operaciones que se pueden realizar son:
Ordenamiento, de los elementos pertenecientes a la estructura.
Apareo, dadas dos estructuras originar una nueva ordenada y que contenga
a las apareadas.
Cada estructura ofrece ventajas y desventajas en relacin a la simplicidad y
eficiencia para la realizacin de cada operacin. De esta forma, la eleccin de
la estructura de datos apropiada para cada problema depende de factores

como la frecuencia y el orden en que se realiza cada operacin sobre los

datos.
LISTAS (informtica)
En Ciencias de la Computacin, una lista enlazada es una de las estructuras
de datos fundamentales, y puede ser usada para implementar otras
estructuras de datos. Consiste en una secuencia de nodos, en los que se
guardan campos de datos arbitrarios y una o dos referencias (punteros) al
nodo anterior y/o posterior. El principal beneficio de las listas enlazadas
respecto a los array convencionales es que el orden de los elementos
enlazados puede ser diferente al orden de almacenamiento en la memoria o
el disco, permitiendo que el orden de recorrido de la lista sea diferente al de
almacenamiento.
Una lista enlazada es un tipo de dato auto-referenciado porque contienen un
puntero o link a otro dato del mismo tipo. Las listas enlazadas permiten
inserciones y eliminacin de nodos en cualquier punto de la lista en tiempo

constante (suponiendo que dicho punto est previamente identificado o

localizado), pero no permiten un acceso aleatorio.
Existen diferentes tipos de listas enlazadas: Lista Enlazadas Simples, Listas
Doblemente Enlazadas, Listas Enlazadas Circulares y Listas Enlazadas
Doblemente Circulares.
Las listas enlazadas pueden ser implementadas en muchos lenguajes.
Lenguajes tales como Lisp y Scheme tiene estructuras de datos ya
construidas, junto con operaciones para acceder a las listas enlazadas.
Lenguajes imperativos u orientados a objetos tales como C o C++ y Java,
respectivamente, disponen de referencias para crear listas enlazadas.
TIPOS DE LISTAS ENLAZADAS
LISTAS ENLAZADAS LINEALES
LISTAS SIMPLES ENLAZADAS
La lista enlazada bsica es la lista enlazada simple la cual tiene un enlace
pornodo. Este enlace apunta al siguiente nodo en la lista, o al valor NULL o a
la listavaca, si es el ltimo nodo.
Una lista enlazada simple contiene dos valores: el valor actual del nodo y un
enlace al siguiente nodo
APLICACIONES DE LISTAS ENLAZADAS
Las listas enlazadas son usadas como mdulos para otras muchas
estructuras de
datos, tales como pilas, colas y
sus variaciones.
El campo de datos de un nodo puede ser otra lista enlazada. Mediante
estemecanismo, podemos construir muchas estructuras de datos enlazadas
con listas;esta practica tiene su origen en el lenguaje de programacin Lisp,
donde las listasenlazadas son una estructura de datos primaria (aunque no la
nica), y ahora esuna caracterstica comn en el estilo de programacin
funcional.

A veces, las listas enlazadas son usadas para implementar arrays

asociativos, yestas en el contexto de las llamadas listas asociativas. Hay
pocas ventajas en esteuso de las listas enlazadas; hay mejores formas de
implementar stas estructuras,por ejemplo con rboles binarios de bsqueda
equilibrados. Sin embargo, a vecesuna lista enlazada es dinmicamente
creada fuera de un subconjunto propio denodos semejante a un rbol, y son
usadas ms eficientemente para recorrer staserie de datos.