//Incluindo bibliotecas
#include <stdlib.h>
#include <stdio.h>

//criando estrutura do nó da LLDE
struct NOH{
    int info;
    struct NOH *prox, *ant;
};

//definindo o nó como um tipo de dado LLDE
typedef struct NOH *LLDE;

//função para inserir Nó no Inicio da LLDE
void insInicioLLDE(LLDE *L, int vr)
{
    //alocando novo nó
    LLDE N = (LLDE) malloc (sizeof(struct NOH));
    
    //definindo ant como NULL, padrão do primeiro nó
    N -> ant = NULL;
    
    //definindo prox pra receber o primeiro nó da fila
    //caso a fila esteja vazia prox fica null, padrão para um nó só na LLDE
    N -> prox = *L;
    
    //info recebe o valor para esse primeiro nó
    N -> info = vr;
    
    //se a lista não for vazia
    if(*L != NULL)
         //o primeiro elemento da lista original recebe o novo no campo ant
         (*L) -> ant = N;
    //e a lista passa a apontar para o novo primeiro nó
    *L = N;
}

//Função para inserir no final
void insFinalLLDE(LLDE *L, int vr)
{
    //criando uma lista auxiliar, e alocando um novo nó na memória                   
    LLDE A, N = (LLDE) malloc (sizeof(struct NOH));
    
    //novo nó no campo de próximo recebe null pois ele ficará no final
    N -> prox = NULL;
    
    //novo nó no campo de info recebe o valor deste novo nó
    N -> info = vr;
    
    //se a lista não for vazia
    if (*L)
    {
         //a lista auxiliar recebe a lista  
         A = *L;
         
         //neste laço a lista auxiliar aponta para o último nó
         for(; A -> prox != NULL; A = A -> prox);
         
         //lista auxiliar no campo de próximo recebe o novo nó
         A -> prox = N;
         
         //novo nó no campo de ant recebe o último nó
         N -> ant = A;
    }
    //se a lista for vazia
    else
    {
         //Ela aponta pro novo nó
         *L = N;
         
         //campo de ant no novo nó é null
         N -> ant = NULL;
    }   
}

// Remover o elemento inicial da lista
void remInicioLLDE(LLDE *L)
{
    //Criando lista auxiliar                    
    LLDE A;
    
    //se a lista não for vazia
    if(*L)
    {
         //lista auxiliar guarda a lista 
         A = *L;
         
         //Lista passa a apontar pro próximo elemento da          
         (*L) = A -> prox;
         
         //apagar o próximo nó
         free(A);
         
         //se a lista não for vazia
         if(*L)
              //primeiro nó da lista no campo de ant é NULL
              (*L) -> ant = NULL;
    }
}

// Remover o elemento final da lista
void remFinalLLDE(LLDE *L)
{
    //Criando lista auxiliar                    
    LLDE A, B;
    
    //se a lista não for vazia
    if(*L)
    {
         //a lista auxiliar recebe a lista  
         A = *L;
         
         //neste laço a lista auxiliar aponta para o último nó
         for(; A -> prox != NULL; A = A -> prox);
         
         //Lista B preserva o penúltimo nó da Lista
         //se a lista só tiver um elemento B é null
         B = A -> ant;
         
         //apaga o último Nó apontado pela lista A
         free(A);
         
         //se B for NULL é porque a lista só tinha um nó
         if(B)
              //lista agora é vazia
              *L = NULL;
         //se B for um endereço de memória de algum nó, este será o último
         else
              //logo seu campo de prox deve ser NULL
              B -> prox = NULL;
              
    }
}

//Função para Ordenar LLDE em Ordem Crescente
void ordernarLLDECresc(LLDE *L)
{   
    //Declarando listas auxiliares
    LLDE A = *L, B;
    
    //Declarando auxiliar para troca do valor de info
    int aux;
    
    //Declarando auxiliar para indicar se houve troca
    int troca = 1;    
    
    //Lista vazia?
    if(*L)
    {
         //Lista B recebe Lista A no campo de próximo, para pegar o Nó seguinte
         B = A -> prox;
    
         //while para manter o laço for enquanto não houver mais trocas
          while(troca)
          {
               //zerando a variável de troca, caso não haja troca o while saberá
               troca = 0;
               
               //laço que percorre a LLDE mantendo B na frente de A
               for(A = *L; A -> prox != NULL; A = A -> prox, B = A -> prox)
               {
                    //se o valor do nó anterior for maior que o posterior, troca 
                    if(A -> info > B -> info)
                    {
                         //trocando info
                         aux = B -> info;
                         B -> info = A -> info;
                         A -> info = aux;
                         
                         //indicar que houve troca
                         troca = 1;
                    }//fim se
               }//fim for
          }//fim while
    }
}

int main()
{
    system("Pause");
}

Disallowed system call: SYS_fork