Uma Empresa de Entregas Fechou um Contrato com um cliente onde um numero de Itens por carregamento são entregues. Os caminhões são identificados pela parte numerica da Placa "AAA XXXX". Faça um programa que armazene tanto a placa quanto o Numero de itens e seja capaz de listar os caminhões e os intens entregues ordenados de forma crescente dos Intens.

/* Uma Empresa de Entregas Fechou um Contrato com um cliente onde um numero de Itens por carregamento
são entregues.
    Os caminhões são identificados pela parte numerica da Placa "AAA XXXX".
    Faça um programa que armazene tanto a placa quanto o Numero de itens e seja capaz de listar os
    caminhões e os intens entregues ordenados de forma crescente dos Intens.*/

#include <stdio.h>

struct no
{
    struct no *anterior;
    int itens;
    int placa;
    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 placa, int itens);
void adicionar_no_final();
void adicionar_no_inicio();
void adicionar_no_meio();
void excluir_no(int placa);
void excluir_no_inicio();
void excluir_no_final();
void excluir_no_meio();
void listar();
void listar_invertido();
struct no *novo_no(int placa, int itens);
void menu();

int opcao = 0;
int placa = 0;
int itens = 0;
float numero_itens = 0;
int numero_placa = 0;

int main()
{
    inicializar();

    while(opcao != 5)
    {
        menu();
        switch(opcao)
        {
            case 1:
                printf("Digite a placa: ");
                scanf("%d", &numero_placa);
                printf("Digite quantidade de itens: ");
                scanf("%f", &numero_itens);
                adicionar_no(numero_placa, numero_itens);
                break;
            case 2:
                listar();
                break;
            case 3:
                printf("Digite a Placa: ");
                scanf("%d", &numero_placa);
                excluir_no(numero_placa);
                break;
             case 4:
                listar_invertido();
                break;
        }
    }

    finalizar();
}

void menu()
{
    printf("Menu\n");
    printf("1 - inserir\n");
    printf("2 - listar\n");
    printf("3 - excluir\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 placa, int itens)
{
    struct no *n;
    n = malloc(sizeof(struct no));
    if(!n)
    {
        printf("Nao consegui alocar memoria!\n");
        exit(-1);
    }

    n->anterior = 0;
    n->itens = itens;
    n->placa = placa;
    n->proximo = 0;

    return n;
}

void adicionar_no(int placa, int itens)
{
    novo = novo_no(placa, itens);

    if(inicio == 0)
    {
        inicio = novo;
    }
    else
    {
        // decidir aonde inserir
        if(inicio->itens > itens)
            adicionar_no_inicio();
        else
        {
            aux = inicio;
            while(aux->proximo != 0 && aux->itens <= itens)
            {
                aux = aux->proximo;
            }
            if(aux->proximo == 0 && itens > aux->itens)
                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 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 excluir_no(int placa)
{
    if(inicio == 0)
    {
        printf("Impossivel excluir! Lista vazia!\n");
    }
    else
    {
        // decidir aonde excluir
        if(inicio->placa == placa)
            excluir_no_inicio();
        else
        {
            aux = inicio;
            while(aux->proximo != 0 && aux->placa != placa)
            {
                aux = aux->proximo;
            }
            if(aux->placa == placa)
                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 listar()
{
    if(inicio != 0)
    {
        aux = inicio;
        while(aux->proximo != 0)
        {
            printf("\tPlaca: %d \t Itens: %d \n", aux->placa, aux->itens);
            aux = aux->proximo;
        }
        printf("\tPlaca: %d \t Itens: %d \n", aux->placa, aux->itens);
    }
    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("\tPlaca: %d \t Itens: %d \n", aux->placa, aux->itens);
            aux = aux->anterior;
        }
        printf("\tPlaca: %d \t Itens: %d \n", aux->placa, aux->itens);
    }
    else
        printf("Lista vazia!\n");
}