You are on page 1of 4

30.

31.
32.
33.
34.
35.
36.

LISTAS CIRCULARES DOBLEMENTE ENLAZADAS


ste tipo de listas, es una combinacin de las listar cicular y la lista doblemente enlazada, puesto que cada
nodo est conectado con el siguiente nodo y el anterior a l, adems que el primer nodo est conectado al
ltimo, y el ltimo al primero.
Es por esa razn que, particularmente consideto que, sta estructura es una de las ms complejas de
manejar, por las consideraciones que debemos tener.
Declaracin de la estructura
Typedef struct celda{
Int elemento;
Struct nodo*sig, ant;
}tipocelda;
typedef tipocelda *tPosicion;
typedef tipocelda* tLista;
Funcin getnodo()
tLista getnodo()
{
tLista L;
L=(tLista)malloc(sizeof(tipocelda));
If(L==NULL)
Printf("ERROR: Memoria Insuficiente\a\n");
L->sig=L->ant=L;
Return L;
}
Funcin Insertar
Algoritmo:
Crear el nuevo nodo
Guardar el dato en el nuevo nodo
Hacer que el nuevo nodo, en su parte de siguiente apunte al nodo anterior (que est siendo apuntado por p)
Luego copiar en nuevo->ant, lo que hay en p->ant
hacer que en la parte de siguiente del nodo anterior apuntado por p, contenga la direccin del nuevo nodo
hacer que p->ant apunte anuevo
guardar la direccin de nuevo en p
void insertar (int x, tPosicion p)
{
tPosicion nuevo;
nuevo=(tPosicion)malloc(sizeof(tipocelda));
if(nuevo==NULL)
printf("ERROR: memoria insuficiente\a\n");
nuevo->elemento=x;
nuevo->sig=p;
nuevo->ant=p->ant;
p->ant->sig=nuevo;
p->ant=nuevo;
p=nuevo;
}
Funcin Buscar
Esta funcin recibe como argumento un dato a buscar, dentro de la lista y devuelve el nodo que contenga
dicho dato.
tPosicion buscar (int x, tLista L)
{
tPosicion p;
int ban=0;
p=L->sig;
while((p!=L) && (!ban))
if(p->elemento==x)
ban=1;
else
p=p->sig;
return p;
}

Ejemplo 12.4
Disee una lista circular doblemente enlazada, que gaurde enteros, y luego permita determinar cuantas
veces se encuentra un nmero ingresado por el usuario.
#include <stdio.h>
#include <conio.h>
#include <string.h>
/*Version Circular doblememente enlazada*/
typedef struct tipoNodo{
int x;
struct tipoNodo *adelante;
struct tipoNodo *atras;
}Nodo;
/*Declaracion de los sinonimos para referirnos al tipo de dato*/
typedef Nodo *tLista;
typedef Nodo *tPosicion;
int cont=0;
/*Declaracin de las funciones que utilizaremos*/
void insertarPrim (tLista cabeza, int entrada);
tLista CrearNodo();
void ImprimeLista(Nodo *ptr);
int buscar(int busca, Nodo *cabeza, Nodo *ptr);
main()
{
/*inicio del programa principal*/
Nodo *ptr;
tPosicion cabeza;
int entrada, opc, busca;
char ban;
/*cabeza contiene la direccin del primer nodo creado*/
cabeza=CrearNodo();
ban='S';
clrscr();
printf("\n\n\n\n");
printf("\n\t
");
printf("\n\t ");
printf("\n\t PROGRAMA QUE CALCULA LOS VALORES REPETIDOS EN UNA LISTA ");
printf("\n\t DOBLEMENTE ENLAZADA ");
printf("\n\t ");
printf("\n\t
");
while(ban=='S' || ban=='s')
{
printf("\n\nIngrese un elemento para la lista:\n");
scanf("%d", &entrada);
cont++;
/*le enviamos a la funcion de insertar, le enviamos la direccin del
primer nodo y el valor que vamos a introducir*/
insertarPrim(cabeza, entrada);
printf("Desea Introducir un nuevo elemento a la lista? (S/N)\n");
ban=getch();
}
printf("Los Valores Guardados en la Lista son:\n");
/*la funcion de imprimir, recibe un puntero hacia el primer
nodo para iniciar con la impresion*/
clrscr();
ImprimeLista(cabeza);
getch();
clrscr();
printf("\n\t\tQue desea Hacer?\n");

printf("\t\t1.Buscar un valor en la lista\n");


printf("\t\t2.Salir\n");
scanf("%d", &opc);
switch(opc)
{
case 1:clrscr();
printf("Ingrese el valor que desea buscar en la lista:\n");
scanf("%d", &busca);
printf("El valor %d se encuentra %d veces en la lista\n\n", busca,buscar(busca,cabeza, cabeza));
break;
case 2:exit(1);
default:printf("Error, el comando no es v lido\n");
break;
}
getch();
return 0;
}
/*definicin de las funciones*/
void insertarPrim(tPosicion cabeza, int entrada)
{
tPosicion nuevo;
/*creamos un nuevo nodo y le asignamos la direccion de memoria*/
nuevo=(tPosicion)malloc(sizeof(Nodo));
if(nuevo==NULL)
printf("ERROR\n");
nuevo->x=entrada;
/*la parte de adelante del nuevo nodo, apunta al primer nodo*/
nuevo->adelante=cabeza;
nuevo->atras=cabeza->atras;
cabeza->atras->adelante=nuevo;
cabeza->atras=nuevo;
}
tLista CrearNodo()
{
/*creamos un nuevo nodo, el cual sera la "cabeza" de la lista*/
tLista L;
L=(tLista)malloc(sizeof(Nodo));
if(L==NULL);
printf("Error, memoria Insuciente\n");
L->adelante=L->atras=L;
return L;
}
void ImprimeLista(Nodo *ptr)
{
Nodo *p;
int k=0;
if(ptr!=NULL)
{
printf("Lista de Nmeros Guardados:\n");
p=ptr->adelante;
do{
k++;
if(k<=cont)
printf("\t\t\t* %d *\n", p->x);
p=p->adelante;
}while(p!=ptr->adelante);
}
else
{
printf("No Hay elementos en la Lista\n");

}
}
int buscar(int busca, Nodo *cabeza, Nodo *ptr)
{
int k=0;
if(ptr!=NULL)
{
cabeza=ptr->adelante;
do{
if(cabeza->x==busca)
k++;
cabeza=cabeza->adelante;
}while(cabeza!=ptr->adelante);
}
else
{
printf("No Hay elementos en la Lista\n");
}
return k;
}

You might also like