quarta-feira, 8 de junho de 2016
quarta-feira, 11 de maio de 2016
sexta-feira, 11 de dezembro de 2015
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");
}
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");
}
quarta-feira, 9 de dezembro de 2015
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);
}
}
}
quinta-feira, 19 de novembro de 2015
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;
}
Assinar:
Postagens (Atom)