Ayuda con un codigo

Hola hola necesito ayuda para poder modificar este codigo a una lista doblemente enlazada me urge porfa
/*************************************************************

• DEMO_LL.C

*

• Este programa ilustra el comportamiento de una lista ligada
• de enteros.
  • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • /

#include <alloc.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <mem.h>
#include "lista.h"

void despliegaPantallaInicial(void);
void borraLista(void);
void despliegaNodo(NODO *pNodo);
int igual(void *pInfo, void *pLlave);
int mayor(void *pInfo, void *pLlave);
LISTA lista = NULL;

int main(void)
{
NODO *pNodo, *pPos, *pAnt;
int dato;
char operador,sdato[6];
clrscr();
inicializarLista(&lista);
despliegaPantallaInicial();
operador=5;
while(operador!='8')
{
gotoxy(28,10); printf(" ");
gotoxy(51,10); printf(" ");
gotoxy(28,10);
//if((operador = getch()) == ESC) break;
//if(operador!=ESC)
//{
gotoxy(26,10);
operador = getchar();
switch(operador)
{
case '1':
printf("Insertar");
gotoxy(36,10);
//getchar(sdato);
scanf("%d",&dato);
pNodo = creaNodo(&dato, sizeof(int));
if(listaVacia(lista)) pAnt = NULL;
else pPos = buscaLista(lista, &pAnt, &dato, mayor);
insertarLista(&lista, pAnt, pNodo);
break;
case '2':
printf("Extraer. ");
if(listaVacia(lista))
{
printf("Lista Vacia. Presiona una tecla para continuar");
getch();
}


else
{
gotoxy(36,10);
scanf("%d",&dato);
//gets(sdato);
//dato = atoi(sdato);
if(!(pPos = buscaLista(lista, &pAnt, &dato, igual)))
{
printf("Valor inexistente. Presiona una tecla para continuar");
getch();
}
else
{
clrscr();
despliegaPantallaInicial();
extraerLista(&lista, pAnt, &dato, sizeof(int));
}
break;
}


}
clrscr();
despliegaPantallaInicial();
visitarLista(lista, despliegaNodo);
putchar('\n');
}

inicializarLista(&lista);
//visitarLista(lista, despliegaNodo);
putchar('\n');
return 0;
}
/*************************************************************

• void despliegaPantallaInicial(void)

*

• Esta función despliega la explicación de lo que hace el
• programa y las instrucciones de su uso.
  • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • /

void despliegaPantallaInicial(void)
{
clrscr();
gotoxy(5,3);
printf("Este programa demuestra el comportamiento de una");
printf(" lista ligada. En esta");
gotoxy(5,4);
printf("lista se almacenan enteros los cuales son");
printf(" acomodados en orden ascendente.");
gotoxy(5,5);
printf("Hay dos operaciones: Para insertar un numero a ");
printf("la lista presiona la tecla");
gotoxy(5,6);
printf("[1], luego el numero a insertar. Para ");
printf("extraer un numero de la lista");
gotoxy(5,7);
printf("presiona la tecla [2], luego el numero a extraer.");
printf(" Para terminar presiona");
gotoxy(5,8);
printf("la tecla [8].");
gotoxy(15,10);
printf("Operacion [ ] Valor [ ]");
}


/*************************************************************

• void despliegaNodo(NODO *pNodo)

*

• Esta función despliega para un nodo, su campo de información
• y su campo siguiente.
  • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • /

void despliegaNodo(NODO *pNodo)
{
static x = 10, y = 13;
/* Si es el primer nodo de la lista */
if(pNodo == lista)
{
x = 10; y = 13;
}
/* Si se va a saltar de renglón */
if(x == 74)
{
x = 10; y += 3;
}
/* Despliega el contenido del nodo en un recuadro */
gotoxy(x,y); putch(0x10);
gotoxy(x+1,y-1); printf("+-------------+");
gotoxy(x+1,y); printf("%6d%6p", *(int *)(pNodo->pInfo),pNodo->pSig);
gotoxy(x+1,y+1); printf("+-------------+");
x += 16;
/* Si va a desplegar otra pantalla */
if(pNodo->pSig && y == 22 && x == 74)
{
printf("ENTER PARA CONTINUAR");
x = 10; y = 13;
borraLista();
}
}


/*************************************************************

• void borraLista(void)

*

• Borra de la pantalla la lista.
  • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • /

void borraLista(void)
{
int i;
for(i = 12; i < 25; i++)
{
gotoxy(1,i); clreol();
}
}

/*************************************************************

• int igual(void *pInfo, void *pLlave)

*

• Esta función regresa 0 si info y llave son iguales, diferente
• de cero en caso contrario.
  • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • /

int igual(void *pInfo, void *pLlave)
{
return *(int *)pInfo - *(int *)pLlave;
}
/*************************************************************

• int mayor(void *pInfo, void *pLlave)

*

• Esta función regresa 0 si info > llave, diferente de cero
• en caso contrario.
  • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • /

int mayor(void *pInfo, void *pLlave)
{
return *(int *)pInfo <= *(int *)pLlave;
}
/*************************************************************

• LISTA.C

*

• Este módulo implementa las operaciones de una lista ligada
• generalizada, esto es, que opera con cualquier tipo de dato.
• Las funciones que implementan las operaciones de la lista
• reciben como parámetros datos o apuntadores de tipo LISTA y
• NODO definidos como:

*

• struct nodo
• {
• void pInfo; /* Campo de información */

/* struct nodo *pSig; /* Campo siguiente */
/* };
*

• typedef struct nodo NODO;
• typedef struct nodo *LISTA;

*

• Aunque una variable y un apuntador de tipo LISTA declaradas
• como:

*

• LISTA lista;
• LISTA *pLista;

*

• podrían haberse declarado como:

*

• NODO *lista;
• NODO **pLista;

*

• sin necesidad de crear el tipo LISTA, el definir el tipo
• LISTA permite utilizar a LISTA par hacer referencia a la
• El uso del tipo LISTA simplifica las declaraciones como
• la de NODO **plista a LISTA *pLista.
  • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • /

/*************************************************************

• void inicializarLista(LISTA *pLista)

*

• Esta función inicializa (vacía) una lista. pLista es un
• apuntador al apuntador a la lista.
  • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • /

void inicializarLista(LISTA *pLista)
{
LISTA pTemp;
/* Mientras haya nodos en la lista */
while(*pLista)
{
pTemp = *pLista;

• pLista = (*pLista)->pSig;

destruyeNodo(pTemp);
}
}
/*************************************************************

• int listaVacia(LISTA lista)

*

• Esta función regresa un 1 si la lista está vacía, 0 en
• caso contrario. lista es un apuntador a la lista.
  • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • /

int listaVacia(LISTA lista)
{
return lista == NULL;
}
/*************************************************************

• void insertarLista(LISTA *pLista, NODO *pPos, NODO *pNodo)

*

• Esta función inserta el nodo apuntado por pNodo en la lista
• apuntada por el apuntador pLista. pPos es un apuntador al
• nodo después del cual se va insertar el nodo. Si se desea
• insertar el dato al inicio de la lista pPos debe valer NULL.
• La función no verifica que pPos sea una dirección de un
• nodo de la lista.
  • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • /

void insertarLista(LISTA *pLista, NODO *pPos, NODO *pNodo)
{
/* Si la lista está vacía */
if(listaVacia(*pLista))
{

• pLista = pNodo;

return;
}
/* Si se va a insertar al inicio de la lista */
if(!pPos)
{
pNodo->pSig = *pLista;

• pLista = pNodo;

return;
}
/* Si se va a insertar después del nodo pPos */
pNodo->pSig = pPos->pSig;
pPos->pSig = pNodo;
}

/*************************************************************

• int extraerLista(LISTA *pLista, NODO *pPos, void *pDato,
• int tamDato)

*

• Esta función extrae un nodo de la lista si no está vacía.
• pPos es un apuntador al nodo después del cual esta el nodo
• que se va extraer. Si se desea extraer el dato al inicio de
• la lista pPos debe valer NULL. pDato es la localidad de
• memoria en la que se almacena el campo de información del
• nodo extraído. tamDato es el tamaño en bytes del campo de
• información del nodo. La función no verifica que nPos sea
• una dirección de un nodo de la lista.
  • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • /

int extraerLista(LISTA *pLista, NODO *pPos, void *pDato, int tamDato)
{
LISTA pTemp;
/* Si la lista esta vacía */
if(listaVacia(*pLista)) return 0;
/* Si se va a extraer el primer elemento */
if(!pPos)
{
pTemp = *pLista;

• pLista = (*pLista)->pSig;

}
/* Si se va a extraer un elemento intermedio */
else
{
pTemp = pPos->pSig;
pPos->pSig = pTemp->pSig;
}
/* Extrae el dato */
memcpy(pDato, pTemp->pInfo, tamDato);
/* Libera el nodo */
destruyeNodo(pTemp);
return 1;
}

/*************************************************************

• void visitarLista(LISTA lista, void (* fVisitar)(NODO *pNodo))

*

• Esta función recorre la lista dada por lista. En cada uno
• de los nodos de la lista la función ejecuta la operación
• dada por la función fVisitar(). La función fVisitar() es
• suministrada por el Usuario y es de tipo void y recibe como
• parámetro un apuntador a NODO
  • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • /

void visitarLista(LISTA lista, void (* fVisitar)(NODO *pNodo))
{
/* Mientras no se llegue al final de la lista */
while(lista)
{
/* Opera sobre el nodo */
fVisitar(lista);
/* Va al siguiente nodo */
lista = lista->pSig;
}
}
/*************************************************************

• NODO *buscaLista(LISTA lista, LISTA *pAnt, void *pLlave,
• int (* fcmp)(void *pInfo, void *pLlave))

*

• Esta función busca en la lista dada por lista la primera
• ocurrencia de un nodo cuyo campo de información al
• compararse con llave cumpla la condición establecida por la
• función fcmp(). La función regresa la dirección del nodo
• que contiene esa primera ocurrencia, NULL en caso de no
• encontrar un nodo que cumpla con la condición. pAnt apunta
• al nodo anterior al nodo con la primera ocurrencia. Si el
• nodo con la primera ocurrencia es el primer nodo de la
• lista, pAnt apunta a NULL. fcmp es un apuntador a la función
• utilizada para comparar la llave con los nodos de la lista.
• La función para comparar es suministrada por el usuario y es
• de tipo entero y recibe como parámetros dos apuntadores void
• a los datos a comparar: pInfo y pLlave que corresponden al
• campo de información y a la llave. La función fcmp() debe
• regresar 0 si el campo de información y la llave cumplen con
• la condición establecida por la función, diferente de cero
• en caso contrario. *
  • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • /

NODO *buscaLista(LISTA lista, LISTA *pAnt, void *pLlave,
int (* fcmp)(void *pInfo, void *pLlave))
{

• pAnt = NULL;

/* Mientras no se llegue al final de la lista */
while(lista)
{
/* Si la encontró */
if(!fcmp(lista->pInfo, pLlave)) break;
/* avanza al siguiente nodo */

• pAnt = lista;

lista = lista->pSig;
}
return lista;
}
/*************************************************************

• NODO *creaNodo(void *pDato, int tamDato)

*

• Esta función crea un nodo haciendo una petición dinámica de
• memoria e inicializa su campo de información con el valor
• de info y el campo siguiente con un apuntador nulo.
  • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • /

NODO *creaNodo(void *pDato, int tamDato)
{
NODO *pNodo;
/* Pide un bloque de memoria para el nodo, en forma dinámica */
pNodo = malloc(sizeof(NODO));
//if((pNodo = malloc(sizeof(NODO))))
//{
/* Pide un bloque de memoria para el dato, en forma dinámica */
pNodo->pInfo = malloc(tamDato);
//if((pNodo->pInfo = malloc(tamDato)))
/* Almacena en el campo de información el dato */
memcpy(pNodo->pInfo, pDato, tamDato);
//else return NULL;
/* Almacena en el campo siguiente un apuntador nulo */
pNodo->pSig = NULL;
//}
return pNodo;
}
/*************************************************************

• void destruyeNodo(NODO *pNodo)

*

• Esta función libera el bloque de memoria ocupada por el
• nodo.
  • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • /

void destruyeNodo(NODO *pNodo)
{
/* Libera el bloque de memoria ocupada por el dato */
free(pNodo->pInfo);
/* Libera el bloque de memoria ocupada por el nodo */
free(pNodo);
}