introduccion a los que son las listas enlaza

1. UNIVERSIDAD FERMIN TORO
VICE-RECTORADO ACADEMICO
DECANATO DE INGENIERIA
ESCUELA DE COMPUTACION
Bachiller: Yanko Duran
C.I.: 20155416
Materia: Estructuras de Datos
Seccion: SAIA “A”

2. QUE ES UNA LISTA ENCADENADA O ENLAZADA?
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 o posterior. El principal beneficio de las listas
enlazadas respecto a los arreglos 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, además de no requerir memoria extra para soportar la
expansión.

3. Los operadores básicos de una lista enlazada son:
• Insertar: inserta un nodo con dato x en la lista, pudiendo realizarse esta inserción al principio
o final de la lista o bien en orden.
• Eliminar: elimina un nodo de la lista, puede ser según la posición o por el dato.
• Buscar: busca un elemento en la lista.
• Localizar: obtiene la posición del nodo en la lista.
• Vaciar: borra todos los elementos de la lista

4. • Existen diferentes tipos de listas enlazadas: Lista Enlazadas Simples, Listas Doblemente
Enlazadas y Listas Enlazadas Circulares.
• Listas enlazadas simples:
Tiene un enlace por nodo, este enlace apunta al siguiente nodo en la lista, o al valor
NULL o a la lista vacía, si es el último nodo. Una lista enlazada simple contiene dos valores: el
valor actual del nodo y un enlace al siguiente nodo.
• Listas doblemente enlazadas o Lista de dos vías:
Cada nodo tiene dos enlaces:
1.- Uno apunta al nodo anterior, o apunta al valor NULL si es el primer nodo.
2.- Otro que apunta al nodo siguiente o apunta al valor NULL si es el último nodo
Clasificacion de las listas enlazadas

5. • Listas enlazadas circulares :
El primer y último nodo está unido. Podemos empezar por cualquier nodo y seguir la lista
en cualquier dirección hasta que se regrese hasta el nodo original. Vistas como listas sin
comienzo ni fin, usado para dirigir buffers para “ingerir” datos, y para visitar todos los nodos de
una lista a partir de uno dado. Una lista enlazada circular que contiene tres valores enteros.
Estos también pueden ser :
Circulares simples: Cada nodo tiene un enlace ;El siguiente nodo del último apunta al primero.
Como es una lista enlazada simple, los nuevos nodos pueden ser solo eficientemente
insertados después de uno que ya tengamos referenciado. Permite rápidas inserciones al
principio y también permite accesos al primer nodo desde el puntero de último nodo.
Circulares doblemente enlazadas: Cada nodo tiene dos enlaces. Enlace anterior del primer
nodo apunta al último y el enlace siguiente del último nodo apunta al primero. Las inserciones
y eliminaciones pueden ser hechas desde cualquier punto con acceso a algún nodo cercano.
Aunque estructuralmente una lista circular doblemente enlazada no tiene ni principio ni fin.

6. EJEMPLOS:

7. EJEMPLO:
#include <stdio.h>
struct _agenda {
char nombre[20];
char telefono[12];
struct _agenda *siguiente;
};
struct _agenda *primero, *ultimo;
void mostrar_menu() {
printf("nnMenú:n=====nn");
printf("1.- Añadir elementosn");
printf("2.- Borrar elementosn");
printf("3.- Mostrar listan");
printf("4.- Salirnn");
printf("Escoge una opción: ");fflush(stdout);
}

8. /* Con esta función añadimos un elemento al final de la lista */
void anadir_elemento() {
struct _agenda *nuevo;
/* reservamos memoria para el nuevo elemento */
nuevo = (struct _agenda *) malloc (sizeof(struct _agenda));
if (nuevo==NULL) printf( "No hay memoria disponible!n");
printf("nNuevo elemento:n");
printf("Nombre: "); fflush(stdout);
gets(nuevo->nombre);
printf("Teléfono: "); fflush(stdout);
gets(nuevo->telefono);
/* el campo siguiente va a ser NULL por ser el último elemento
de la lista */
nuevo->siguiente = NULL;
/* ahora metemos el nuevo elemento en la lista. lo situamos
al final de la lista */

9. /* comprobamos si la lista está vacía. si primero==NULL es que no
hay ningún elemento en la lista. también vale ultimo==NULL */
if (primero==NULL) {
printf( "Primer elementon");
primero = nuevo;
ultimo = nuevo;
}
else {
/* el que hasta ahora era el último tiene que apuntar al nuevo */
ultimo->siguiente = nuevo;
/* hacemos que el nuevo sea ahora el último */
ultimo = nuevo;
}
}
void mostrar_lista() {
struct _agenda *auxiliar; /* lo usamos para recorrer la lista */
int i;
i=0;
auxiliar = primero;
printf("nMostrando la lista completa:n");

10. while (auxiliar!=NULL) {
printf( "Nombre: %s, Telefono: %sn",
auxiliar->nombre,auxiliar->telefono);
auxiliar = auxiliar->siguiente;
i++;
}
if (i==0) printf( "nLa lista está vacía!!n" );
}
int main() {
char opcion;
primero = (struct _agenda *) NULL;
ultimo = (struct _agenda *) NULL;
do {
mostrar_menu();
opcion = getch();
switch ( opcion ) {
case '1': anadir_elemento();
break;
case '2': printf("No disponible
todavía!n");
break;
case '3': mostrar_lista(primero);
break;
case '4': exit( 1 );
default: printf( "Opción no válidan" );
break;
}
} while (opcion!='4');
}
/*FIN DEL PROGRAMA*/