Lista Duplamente Ligada

#include <stdio.h>

struct no
{
    struct no *anterior;
    int dado;
    struct no *proximo;
};

struct no *inicio;
struct no *novo;
struct no *aux;
struct no *anterior;

void inicializar();
void finalizar();
void finalizar_elemento(struct no *elemento);
void adicionar_no(int dado);
void adicionar_no_final();
void adicionar_no_inicio();
void adicionar_no_meio();
void excluir_no(int dado);
void excluir_no_inicio();
void excluir_no_final();
void excluir_no_meio();
void listar();
void listar_invertido();
struct no *novo_no(int dado);
void menu();

int opcao = 0;
int numero = 0;

int main()
{
    inicializar();

    while(opcao != 5)
    {
        menu();
        switch(opcao)
        {
            case 1:
                printf("Digite um numero: ");
                scanf("%d", &numero);
                adicionar_no(numero);
                break;
            case 2:
                printf("Digite um numero: ");
                scanf("%d", &numero);
                excluir_no(numero);
                break;
            case 3:
                listar();
                break;
            case 4:
                listar_invertido();
                break;
        }
    }

    finalizar();
}

void menu()
{
    printf("Menu\n");
    printf("1 - inserir\n");
    printf("2 - excluir\n");
    printf("3 - listar\n");
    printf("4 - listar invertido\n");
    printf("5 - sair\n");

    printf("Digite sua opcao: ");
    scanf("%d", &opcao);
}

void inicializar()
{
    inicio = 0;
}

struct no *novo_no(int dado)
{
    struct no *n;
    n = malloc(sizeof(struct no));
    if(!n)
    {
        printf("Nao consegui alocar memoria!\n");
        exit(-1);
    }

    n->anterior = 0;
    n->dado = dado;
    n->proximo = 0;

    return n;
}

void adicionar_no(int dado)
{
    novo = novo_no(dado);

    if(inicio == 0)
    {
        inicio = novo;
    }
    else
    {
        // decidir aonde inserir
        if(inicio->dado > dado)
            adicionar_no_inicio();
        else
        {
            aux = inicio;
            while(aux->proximo != 0 && aux->dado <= dado)
            {
                aux = aux->proximo;
            }
            if(aux->proximo == 0 && dado > aux->dado)
                adicionar_no_final();
            else
                adicionar_no_meio();
        }
    }
}

void adicionar_no_final()
{
    aux->proximo = novo;
    novo->anterior = aux;
}

void adicionar_no_inicio()
{
    novo->proximo = inicio;
    inicio->anterior = novo;
    inicio = novo;
}

void adicionar_no_meio()
{
    anterior = aux->anterior;
    novo->proximo = aux;
    anterior->proximo = novo;
    aux->anterior = novo;
    novo->anterior = anterior;
}

void excluir_no(int dado)
{
    if(inicio == 0)
    {
        printf("Impossivel excluir! Lista vazia!\n");
    }
    else
    {
        // decidir aonde excluir
        if(inicio->dado == dado)
            excluir_no_inicio();
        else
        {
            aux = inicio;
            while(aux->proximo != 0 && aux->dado != dado)
            {
                aux = aux->proximo;
            }
            if(aux->dado == dado)
                if(aux->proximo == 0)
                    excluir_no_final();
                else
                    excluir_no_meio();
            else
                printf("Impossivel excluir! Nao encontrei o elemento.\n");
        }
    }
}

void excluir_no_final()
{
    anterior = aux->anterior;
    anterior->proximo = 0;
    free(aux);
}

void excluir_no_inicio()
{
    aux = inicio;
    if(inicio->proximo != 0)
    {
        inicio = inicio->proximo;
        inicio->anterior = 0;
        free(aux);
    }
    else
    {
        free(aux);
        inicio = 0;
    }
}

void excluir_no_meio()
{
    struct no *proximo;
    anterior = aux->anterior;
    proximo = aux->proximo;
    anterior->proximo = proximo;
    proximo->anterior = anterior;
    free(aux);
}

void finalizar()
{
    if(inicio != 0)
    {
        finalizar_elemento(inicio);
        inicio = 0;
    }
}

void finalizar_elemento(struct no *elemento)
{
    if(elemento->proximo != 0)
        finalizar_elemento(elemento->proximo);
    free(elemento);
}

void listar()
{
    if(inicio != 0)
    {
        aux = inicio;
        while(aux->proximo != 0)
        {
            printf("%d -> ", aux->dado);
            aux = aux->proximo;
        }
        printf("%d\n", aux->dado);
    }
    else
        printf("Lista vazia!\n");
}

void listar_invertido()
{
    if(inicio != 0)
    {
        aux = inicio;
        while(aux->proximo != 0)
        {
            aux = aux->proximo;
        }
        while(aux->anterior != 0)
        {
            printf("%d -> ", aux->dado);
            aux = aux->anterior;
        }
        printf("%d\n", aux->dado);
    }
    else
        printf("Lista vazia!\n");
}

Lista Ligada

#include <stdio.h>

struct no
{
    int dado;
    struct no *proximo;
};

struct no *inicio;
struct no *novo;
struct no *aux;
struct no *anterior;

void inicializar();
void finalizar();
void finalizar_elemento(struct no *elemento);
void adicionar_no(int dado);
void adicionar_no_final();
void adicionar_no_inicio();
void adicionar_no_meio();
void excluir_no(int dado);
void excluir_no_inicio();
void excluir_no_final();
void excluir_no_meio();
void listar();
struct no *novo_no(int dado);
void menu();

int opcao = 0;
int numero = 0;

int main()
{
    inicializar();
    while(opcao != 4)
    {
        menu();
        switch(opcao)
        {
            case 1:
                printf("Digite um numero: ");
                scanf("%d", &numero);
                adicionar_no(numero);
                break;
            case 2:
                printf("Digite um numero: ");
                scanf("%d", &numero);
                excluir_no(numero);
                break;
            case 3:
                listar();
                break;
        }
    }

    finalizar();
}

void menu()
{
    printf("Menu\n");
    printf("1 - inserir\n");
    printf("2 - excluir\n");
    printf("3 - listar\n");
    printf("4 - sair\n");

    printf("Digite sua opcao: ");
    scanf("%d", &opcao);
}

void inicializar()
{
    inicio = 0;
}

struct no * novo_no(int dado)
{
    struct no *n;
    n = malloc(sizeof(struct no));
    if(!n)
    {
        printf("Nao consegui alocar memoria!\n");
        exit(-1);
    }

    n->proximo = 0;
    n->dado = dado;

    return n;
}

void adicionar_no(int dado)
{
    novo = novo_no(dado);

    if(inicio == 0)
    {
        inicio = novo;
    }
    else
    {
        // decidir aonde inserir
        if(inicio->dado >= dado)
            adicionar_no_inicio();
        else
        {
            aux = inicio;
            anterior = inicio;
            while(aux->proximo != 0
                  && aux->dado < dado)
            {
                anterior = aux;
                aux = aux->proximo;
            }
            if(aux->proximo == 0
               && dado > aux->dado)
                adicionar_no_final();
            else
                adicionar_no_meio();
        }
    }
}

void adicionar_no_final()
{
    aux->proximo = novo;
}

void adicionar_no_inicio()
{
    novo->proximo = inicio;
    inicio = novo;
}

void adicionar_no_meio()
{
    novo->proximo = aux;
    anterior->proximo = novo;
}

void excluir_no(int dado)
{
    if(inicio == 0)
    {
        printf("Lista vazia\n");
    }
    else
    {
        // decidir aonde excluir
        if(inicio->dado == dado)
            excluir_no_inicio();
        else
        {
            aux = inicio;
            anterior = inicio;
            while(aux->proximo != 0
                  && aux->dado != dado)
            {
                anterior = aux;
                aux = aux->proximo;
            }
            if(dado == aux->dado)
                if(aux->proximo == 0)
                    excluir_no_final();
                else
                    excluir_no_meio();
            else
                printf("Impossivel excluir. Nao existe o dado!\n");
        }
    }
}

void excluir_no_final()
{
    anterior->proximo = 0;
    free(aux);
}

void excluir_no_inicio()
{
    aux = inicio;
    inicio = aux->proximo;
    free(aux);
}

void excluir_no_meio()
{
    anterior->proximo = aux->proximo;
    free(aux);
}

void listar()
{
    if(inicio != 0)
    {
        aux = inicio;
        while(aux->proximo != 0)
        {
            printf("%d -> ", aux->dado);
            aux = aux->proximo;
        }
        printf("%d\n", aux->dado);
    }
    else
        printf("Lista vazia!\n");
}

void finalizar()
{
    if(inicio != 0)
    {
        finalizar_elemento(inicio);
        inicio = 0;
    }
}

void finalizar_elemento(struct no *elemento)
{
    if(elemento->proximo != 0)
        finalizar_elemento(elemento->proximo);
    free(elemento);
}

Lista Dinamica

#include <stdio.h>

void adicionar(int valor);
int quantidadeElementos();
int buscarPorIndice(int indice);
int buscarPorValor(int valor);
void excluir(int valor);
void ordenar();
void expandir();
void inicializar();
void finalizar();
void listar();

void menu();

int tamanho = 5;
int posicao = 0;
int *lista;
int opcao;
int numero;
int indice;

int main()
{
    inicializar();
    opcao = 0;
    while(opcao !=8)
    {
        menu();
        switch(opcao)
        {
        case 1:
            printf("Digite o numero: ");
            scanf("%d", &numero);
            adicionar(numero);
            break;
        case 2:
            printf("A lista possui %d elementos.\n", quantidadeElementos());
            break;
        case 3:
            printf("Digite o indice: ");
            scanf("%d", &indice);

            numero = buscarPorIndice(indice);
            if(numero == -1)
                printf("Indice invalido!\n");
            else
                printf("Valor encontrado no indice %d = %d\n", indice, numero);
            break;
        case 4:
            printf("Digite o numero: ");
            scanf("%d", &numero);

            indice = buscarPorValor(numero);
            if(indice == -1)
                printf("Nao encontrei %d na lista!\n", numero);
            else
                printf("Encontreio valor %d no indice %d\n", numero, indice);
            break;
        case 5:
            printf("Digite o valor para excluir: ");
            scanf("%d", &numero);
            excluir(numero);
            break;
        case 6:
            printf("Ordenando...\n");
            ordenar();
            break;
        case 7:
            listar();
            break;
        }
    }
    finalizar();
}

void inicializar()
{
    lista = malloc(tamanho * sizeof(int));
    if(!lista)
    {
        printf("Erro de alocacao!");
        exit(-1);
    }
}

void finalizar()
{
    free(lista);
}

void menu()
{
    printf("1 - Adicionar\n");
    printf("2 - Quantidade de Elementos\n");
    printf("3 - Buscar por Indice\n");
    printf("4 - Buscar por Valor\n");
    printf("5 - Excluir\n");
    printf("6 - Ordenar\n");
    printf("7 - Listar\n");
    printf("8 - Sair\n");
    printf("Digite a sua opcao: ");
    scanf("%d", &opcao);
}

void listar()
{
    int i;
    for(i = 0; i < posicao; i++)
        printf("lista[%d] = %d\n", i, lista[i]);
}

void adicionar(int valor)
{
    if(posicao < tamanho)
    {
        lista[posicao] = valor;
        posicao++;
    }
    else
    {
        expandir();
        adicionar(valor);
    }
}

int quantidadeElementos()
{
    return posicao;
}

int buscarPorIndice(int indice)
{
    if(indice >= 0 && indice < posicao)
        return lista[indice];
    else
        return -1;
}

int buscarPorValor(int valor)
{
    int i = 0;
    for(i = 0; i < posicao; i++)
        if(lista[i] == valor)
            return i;
    return -1;
}

void excluir(int valor)
{
    int i = 0;
    i = buscarPorValor(valor);
    if(i != -1)
    {
        for(; i < posicao - 1; i++)
            lista[i] = lista[i + 1];
        posicao--;
    }
    else
        printf("Nao encontrei %d na lista!\n", valor);
}

void ordenar()
{
    int i = 0;
    int j = 0;
    int aux = 0;

    for(i = 0; i < (posicao -1); i++)
    {
        for(j = i + 1; j < posicao; j++)
        {
            if(lista[i] > lista[j])
            {
                aux = lista[i];
                lista[i] = lista[j];
                lista[j] = aux;
            }
        }
    }
}

void expandir()
{
    printf("Expandindo o array...\n");
    int novoTamanho = tamanho + (tamanho / 2);
    int *p;
    int i;

    p = malloc(novoTamanho * sizeof(int));
    if(!p)
    {
        printf("Erro na alocacao de memoria!");
        exit(-1);
    }

    for(i = 0; i < tamanho; i++)
        p[i] = lista[i];

    free(lista);
    lista = p;
    tamanho = novoTamanho;
}