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

        }

    }

}

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

Uma empresa está desenvolvendo um novo controle para uma impressora. Ela recebe os pedidos e estes devem ser atendidos na mesma ordem que chegam. Cada pedido é representado por um inteiro que corresponde ao tamanho em Bytes da impressão. Faça um programa capaz de atender estas especificações e no final dizer quantos Bytes foram impressos e quantos documentos foram atendidos.

#include <stdio.h>
#include <stdlib.h>

#define QUANTIDADE 3

int fila[QUANTIDADE];
int fim;
int inicio;
int retorno;
int contador = 0;
int opcao;
int byte = 0;
int pedido;

void menu();
void adicionar(int pedido);
int retirar();

int main()
{
        opcao = 0;
        inicio = 0;
        fim = 0;
        while(opcao != 3){

            menu();
            switch (opcao){

        case 1:
                printf("Entre com o novo pedido: ");
                scanf("%d",&pedido);
                adicionar(pedido);
            break;

            case 2:
                pedido = retirar();
                printf("Quantidade de pedidos: %d de %d bytes\n",contador, byte);
            break;

            case 3:
                printf("Sistema Finalizado!!!");
                break;
            default:
                printf("Opcao invalida, escolha entre 1, 2 e 3.\n");
        }
    }
}

void adicionar(int pedido)
    {
        if (fim == QUANTIDADE){
            printf("\nPedido esgotados!!!\n");
       }else{
            fila[fim] = pedido;
            fim++;
    }
}
int retirar()
{
    if(fim == inicio){
        printf("\nNão há pedidos.\n");
        return -0;
    }else{
        retorno = fila[inicio];
        inicio++;
        contador++;
        byte+= retorno;
        return retorno;
        return contador;
        return byte;
    }
}

void menu()
{
    printf("\n1 - Entre com o pedido ");
    printf("\n2 - Pedido a retirar ");
    printf("\n3 - Sair\n");
    printf("\Digite a opcao: ");
    scanf("%d",&opcao);

}

Uma empresa de entregas tem um determinado percurso a ser seguido pelos caminhões e estes devem voltar pelo mesmo caminho. Faça um programa capaz de cadastrar estes caminhos e extrair o caminho de volta na ordem inversa. O dado a ser armazenado corresponde a quantos quilometros foram percorridos. Na saida do programa deve ser impressa a media de quilometros que foram percorridos por trecho.

#include <stdio.h>

#include <stdlib.h>

#define QUANTIDADE 3

void menu();

void imprimir();

float voltaItinerario(float km);

float itinerario(float km);

float mediatotal;

float media();

float contador=0;

float soma=0;

float km;

float pilha[QUANTIDADE];

int posicao;

int opcao;

float percurso;

int main()

{

    opcao = 0;

    while(opcao!=5)

    {

        menu();

        if(opcao == 1)

        {

            printf("Digite a Distancia a Percorrer : ");

            scanf("%f", &percurso);

            itinerario(percurso);

        }

        if(opcao == 2)

        {

            percurso = media();

            printf("\nTotal %4.0f Intinerario com Média %4.2f Kms por Percurso.\n\n", contador, mediatotal);

            imprimir();

        }

        if (opcao == 3){

            percurso = voltaItinerario(km);

            printf("\nVolta de ** %4.2f Kms ** do Intineriario ja Percorrido.\n\n",percurso);

            imprimir();

        }

        if(opcao == 4)

        {

            posicao=0;

            contador = 0;

            soma = 0;

        }

        if (opcao == 5)

        {

            printf("\nSistema Finalizado!!!\n");

            break;

        }

        if((opcao>5)||(opcao<1)){

         printf(" \n*** Opcao Invalida ***\n");

    }

    }

}

void menu()

{

    printf("\n1 - Inserir Distancia do Intinerario a Percorrer  \n");

    printf("2 - Calcular Media do Intinerario\n");

    printf("3 - Voltar o Intinerario ja Percorrido\n");

    printf("4 - Novo Intinerario\n");

    printf("5 - Sair\n");

    printf("\nDigite a opcao: ");

    scanf("%d", &opcao);

}

void imprimir()

{

    int i;

    for(i = posicao - 1; i >=0; i--)

    {

        printf("  %d ° Percurso = %2.2f kms\n ", i+1,pilha[i]);

    }

    printf(" \nTotal de %4.2f Kms Percorridos\n",soma);

}

float itinerario(float km)

{

    if(posicao == QUANTIDADE)

        printf("\nLimite Intinerario Esgotado!!!\n");

    else

    {

        pilha[posicao] = km;

        posicao++;

        contador++;

        soma=soma+km;

   }

}

float voltaItinerario(float km)

{

    if(posicao == 0){

        printf("\nFim dos Intinerarios Percorridos!!!\n");

        return 0;

    }else{

        posicao--;

        contador++;

        soma= soma+pilha[posicao];

        return pilha[posicao];

    }

}

float media()

{

    if(posicao == 0)

    {

        printf("\nSem Intinerario , Vazio!!!\n");

        return 0;

    }

    mediatotal=soma/contador;

}

Lista - Prof. Nava - Adicionar Elemento - Qtde Elemento - Busca Por Indice - Busca por Valor - Excluir - Ordenar - Listar - Sair

#include <stdio.h>

#define TAMANHO 5

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

void menu();

int posicao = 0;
int lista[TAMANHO];
int opcao;
int numero;
int indice;

int l = 0;

int main()
{
    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:
            for(l=0; l < quantidadeElementos(); l++)
                printf("lista[%d]=%d\n", l, buscarPorIndice(l));
            break;
        }
    }
}

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 adicionar(int valor)
{
    if(posicao < TAMANHO)
    {
        lista[posicao] = valor;
        posicao++;
    }
    else
        printf("Lista cheia!\n");
}

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

Lista Array , Função - Inserir - Excluir - Consulta - Ordenar

#include <stdio.h>

#define TAMANHO 3

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

void menu();

int posicao = 0;
int lista[TAMANHO];
int opcao;
int numero;
int indice;

int l = 0;

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

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

            indice = buscarPorValor(numero);
            if(indice == -1)
                printf("\n*** Nao encontrei %d na lista! ***\n\n", numero);
            else
                printf("\n*** Encontrei o valor %d no indice %d ***\n\n", numero, indice);
            break;
        case 5:
            printf("\n Digite o valor para excluir: ");
            scanf("%d", &numero);
            excluir(numero);
            break;
        case 6:
            printf("\n*** Ordenando...\n");
            ordenar();
            break;
        case 7:
            for(l=0; l < quantidadeElementos(); l++)
                printf("lista[%d]=%d\n", l, buscarPorIndice(l));
            break;
         case 8:
                printf(" \n*** Bay Bay ***\n");
            break;
        }
    }
}

void menu()
{
    printf("\n");
    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);
    printf("\n\n");
}

void adicionar(int valor)
{
    if (posicao == TAMANHO){
        printf("\n*** Lista Cheia!!! ***\n");
        printf("\n\n");
    }else{
        lista[posicao] = numero;
        posicao++;
    }
}

int quantidadeElementos()
{
    return posicao;
}

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

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

void excluir(int valor)
{
    int i=0, j=0;
        for(i=0;i<posicao;i++){
            if(lista[i] == valor){ 
                    for(j=i;j<posicao;j++){
                        lista[j] = lista[j+1]; 
                    }
            posicao--;
                   printf("\n*** Retirado Valor %d da posicao %d ***\n", valor,i);
             }
      }
         if (valor!=lista[i]){
            printf("\n*** Valor %d Nao Existente ***\n",valor);
                }
}

void ordenar()
{
int i, j, aux;
          for( i=0; i<posicao; i++ ){
                  for( j=i+1; j<posicao; j++ ){
                       if( lista[i] > lista[j] ){
                           aux = lista[i];
                           lista[i] = lista[j];
                           lista[j] = aux;
                  }
             }
       }
           printf("\n Ordenado com sucesso!!! ***\n\n");
}

Fila Circular com String

#include <stdio.h>

#include <stdlib.h>

#define TAMANHOVET 3

#define TAMANHOSTRING 20

char fila[TAMANHOVET][TAMANHOSTRING];

char palavra[TAMANHOSTRING];

int opcao;

int fim;

int inicio;

int vazia = 0;

void menu();

void adicionar(char *palavra[TAMANHOSTRING]);

char retirar();

void imprimir(char *palavra);

int main()

{

    opcao = 0;

    inicio = 0;

    fim = 0;

    while(opcao != 4)

    {

        menu();

        switch(opcao)

        {

        case 1:

            printf("Digite um Nome: ");

            fflush(stdin);

            scanf("%s ",&palavra);

            adicionar(palavra);

            break;

        case 2:

            if(vazia==0){

                printf("\n***FILA VAZIA***\n");

            } else{

                retirar();

            }

            break;

        case 3:

            imprimir(*palavra);

            if(vazia == 0){

        printf(" *** Nao Tem Nome na Fila ***\n");

       }

            break;

        case 4:

           printf(" *** Bay Bay ***");

            break;

        default:

            printf("\nOpcao invalida!\n");

        }

        printf("\n");

    }

}

void menu()

{

    printf("1 - Adicionar\n");

    printf("2 - Retirar\n");

    printf("3 - Imprimir Lista\n");

    printf("4 - Sair\n");

    printf("Digite a opcao: ");

    scanf("%d", &opcao);

    printf("\n");

}

void adicionar(char *palavra[TAMANHOSTRING])

{

    if(vazia==0){

        strcpy(fila[fim], palavra);

        fim++;

        if(fim == TAMANHOVET){

            fim = 0;

        }

        vazia = 1;

    } else if(inicio==fim){

        printf("\n***FILA CHEIA***\n");

    }else{

        strcpy(fila[fim], palavra);

        fim++;

    }if(fim == TAMANHOVET){

        fim=0;

    }

}

char retirar()

{

    if(vazia == 0){

        printf("\n ***Fila Vazia*** \n");

    }else{

        printf("\nRetirado a palavra da fila!\n");

        puts(fila[inicio]);

        inicio++;

        if(inicio==TAMANHOVET){

            inicio=0;

        }if(inicio==fim){

            vazia = 0;

        }

    }

}

void imprimir(char *palavra)

{

    int i;

    int a = 0;

    i = inicio;

    if(vazia == 1){

        while(a==0){

            printf("%s - ",fila[i]);

            i++;

            if(i==TAMANHOVET)

                i=0;

            if(i==fim)

                a=1;

        }

        printf("\n");

    }

}