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");
}

Arvore Binaria.

#include <stdio.h>

struct no

{

    struct no *esquerda;

    int dado;

    struct no *direita;

};

struct no *inicio;

struct no *anterior;

struct no *aux;

char ultimo_movimento = ' ';

void adicionar(struct no *posicao, struct no *novo);

struct no *novo_no(int dado);

void inicializar();

void finalizar(struct no *posicao);

struct no *localizar(struct no *posicao, int dado);

void excluir(int dado);

void menu();

int opcao;

int numero;

int main()

{

    inicializar();

    while(opcao != 4)

    {

        menu();

        switch(opcao)

        {

            case 1:

                printf("Digite um numero: ");

                scanf("%d", &numero);

                adicionar(inicio, novo_no(numero));

                break;

            case 2:

                printf("Digite um numero: ");

                scanf("%d", &numero);

                excluir(numero);

                break;

            case 3:

                printf("Digite um numero: ");

                scanf("%d", &numero);

                aux = localizar(inicio, numero);

                if(aux == 0)

                    printf("Nao encontrei o dado!\n");

                else

                    printf("Encontrei %d!\n", aux->dado);

                break;

        }

    }

    finalizar(inicio);

}

void menu()

{

    printf("Menu\n");

    printf("1 - inserir\n");

    printf("2 - excluir\n");

    printf("3 - localizar\n");

    printf("4 - sair\n");

    printf("Digite sua opcao: ");

    scanf("%d", &opcao);

}

void inicializar()

{

    inicio = 0;

}

void adicionar(struct no *posicao, struct no *novo)

{

    if(inicio == 0)

    {

        printf("Adicionando %d no inicio!\n", novo->dado);

        inicio = novo;

    }

    else

    {

        if(novo->dado > posicao->dado)

        {

            if(posicao->direita == 0)

            {

                printf("Adicionando %d a direita de %d!\n", novo->dado, posicao->dado);

                posicao->direita = novo;

            }

            else

            {

                printf("Indo para a direita de %d!\n", posicao->dado);

                adicionar(posicao->direita, novo);

            }

        }

        else

        {

            if(posicao->esquerda == 0)

            {

                printf("Adicionando %d a esquerda de %d!\n", novo->dado, posicao->dado);

                posicao->esquerda = novo;

            }

            else

            {

                printf("Indo para a esquerda de %d!\n", posicao->dado);

                adicionar(posicao->esquerda, novo);

            }

        }

    }

}

struct no *novo_no(int dado)

{

    struct no *novo;

    novo = malloc(sizeof(struct no));

    if(!novo)

    {

        printf("Nao consegui alocar memoria!\n");

        exit(-1);

    }

    novo->esquerda = 0;

    novo->dado = dado;

    novo->direita = 0;

    return novo;

}

void finalizar(struct no *posicao)

{

    if(posicao!=0)

    {

        printf("Processando esquerda de %d\n", posicao->dado);

        if(posicao->esquerda != 0)

            finalizar(posicao->esquerda);

        printf("Processando direita de %d\n", posicao->dado);

        if(posicao->direita != 0)

            finalizar(posicao->direita);

        printf("Liberando %d\n", posicao->dado);

        free(posicao);

    }

}

struct no *localizar(struct no *posicao, int dado)

{

    if(posicao == 0)

        return 0;

    if(posicao == inicio)

        anterior = inicio;

    if(posicao->dado == dado)

        return posicao;

    else

    {

        anterior = posicao;

        if(dado > posicao->dado && posicao->direita != 0)

        {

            ultimo_movimento = 'D';

            return localizar(posicao->direita, dado);

        }

        if(dado < posicao->dado && posicao->esquerda != 0)

        {

            ultimo_movimento = 'E';

            return localizar(posicao->esquerda, dado);

        }

        return 0;

    }

}

void excluir(int dado)

{

    aux = localizar(inicio, dado);

    if(aux == 0)

        printf("Impossivel excluir, registro nao existe!\n");

    else

    {

        if(aux == inicio)

        {

            inicio = 0;

            if(aux->esquerda != 0)

                adicionar(inicio, aux->esquerda);

            if(aux->direita != 0)

                adicionar(inicio, aux->direita);

            free(aux);

        }

        else

        {

            if(ultimo_movimento == 'D')

                anterior->direita = 0;

            else

                anterior->esquerda = 0;

            if(aux->esquerda != 0)

                adicionar(inicio, aux->esquerda);

            if(aux->direita != 0)

                adicionar(inicio, aux->direita);

            free(aux);

        }

    }

}