void mostra_pilha(PilhaGenerica p, void(*mostra)(void*)){
if(pilha_vazia(p)){
printf("Pilha vazia! \n");
} else {
printf("Dados da pilha:\n");
int i;
for(i = 0; i<= p.topo; i++){
mostra(p.dados[i]);
}
}
}
int verifica_topo(tp_pilha *p, tp_item *e){
if(pilha_vazia(p)){
printf("\n\n\t\tNão foi possivel verificar a pilha!\n");
return 0;
} else { ///igual ao desempilha a diferença que esse só retorna o valor no topo.
tp_item temp; ///cria uma variavel temporaria que vai
temp = p->item[p->topo]; ///receber o valor do elemento no topo da pilha
*e = temp; ///o valor da variavel que o ponteiro 'i' esta, vai receber o valor temporario - retorno
//printf("\nO Valor no topo da Pilha é: [%d]",*i);
return 1;
}
}
int desempilha(tp_pilha *p, tp_item *e){
if (pilha_vazia(p)){ ///if(pilha_vazia(p)==1) - o 'p' de pilha vazia é o mesmo 'p' de tp_pilha entretanto ele esta recebendo o seu valor, um endereço de memoria
printf("\n\n\t\tNão foi possível remover um item da pilha!\n");
return 0; ///retorna 0 como falso
} else {
tp_item temp; ///cria uma variavel temporaria que vai
temp = p->item[p->topo]; ///receber o valor do elemento no topo da pilha
*e = temp; ///o valor da variavel que o ponteiro 'i' esta, vai receber o valor temporario - retorno
p->topo--; ///decrementa a pilha
//printf("Desempilhei o Valor [%d]!\n",*e);
return 1;
}
}
int main(){
Pilha* p=NULL;
int op;
char resp;
float valor;
do{
system("cls");
printf("==PILHAS VETORIAIS >> FELIPE==\n\n");
printf("Escolha uma opcao:\n");
printf("1 - Cria a pilha\n");
printf("2 - Testa se a pilha esta vazia\n");
printf("3 - Adiciona um elemento a pilha\n");
printf("4 - Retira um elemento da pilha\n");
printf("5 - Exibe a pilha\n");
printf("6 - SAIR [X]\n\n");
printf("Escolha: ");
scanf("%d",&op);
switch(op){
case 1:
p=pilha_cria();
printf("Pilha criada no endereco %p",p);
break;
case 2:
if(pilha_vazia(p)){
printf("A pilha esta VAZIA");
}
else{
printf("A pilha NAO ESTA VAZIA");
}
break;
case 3:
printf("Digite um valor real:");
scanf("%f",&valor);
pilha_push(p,valor);
break;
case 4:
pilha_pop(p);
break;
case 5:
pilha_imprime(p);
break;
case 6:
exit(1);
}
printf("\n\nDeseja continuar? (s/n) :");
scanf("%s",&resp);
}while(resp=='s');
getch();
}
/* imprime os elementos da pilha */
void pilha_imprime( pilha_t* p, void (*imprime)(void*) )
{
lista_t* elem = p->primeiro;
if(pilha_vazia(p)) {
printf("ERRO! Não é possível imprimir. Pilha vazia.\n");
return;
}
while(elem != NULL){
imprime( elem->dado );
elem = elem->prox;
printf("\n");
}
}
//Esta funcao se encarrega de desempilhar um item da pilha,esse desempilhamento
//se da sempre do item do topo da pilha.
void pop(char *X, pilha *P)//recuperando o valor do topo da pilha
{
if(pilha_vazia(P))
{ clrscr();
printf("\nA pilha esta vazia");
getch();
return;
}
else
{ *X=P->entradas[P->topo];
(P->topo)--;
}
return;
}
int pop(tipo_pilha *p)
{
int x;
tipo_no *aux = p -> topo;
if (pilha_vazia(p))
{
printf("Pilha Vazia");
exit(1);
}
x = p -> topo -> info;
p -> topo = aux -> prox;
free(aux);
return(x);
}
um_atomo pilha_retira (uma_pilha *pilha)
{
um_atomo atomo;
int ultimo;
if (pilha_vazia (pilha))
return (um_atomo) NULL;
ultimo = pilha->tamanho - 1;
atomo = pilha->atomo[ultimo];
pilha->atomo = (um_atomo *) realloc (pilha->atomo, (--pilha->tamanho) * sizeof (um_atomo));
return atomo;
}
// mover carta de retenção para retenção (pilha retenção para pilha retenção)
int retencao_para_retencao(pilha pi_sup1, pilha pi_sup2)
{
tipo_chave num_o=pi_sup1->cartas[pi_sup1->topo].numero,
cor_o=pi_sup1->cartas[pi_sup1->topo].cor;
if(pilha_vazia(pi_sup2))
{
push(pi_sup2,num_o,cor_o,pi_sup1->cartas[pi_sup1->topo].naipe);
pop(pi_sup1);
return 1;
}
return 0;
}
// mover carta de coluna para retenção (pilha inferior para pilha retenção)
int coluna_para_retencao(pilha pi_inf, pilha pi_sup)
{
tipo_chave num_o=pi_inf->cartas[pi_inf->topo].numero,
cor_o=pi_inf->cartas[pi_inf->topo].cor;
if(pilha_vazia(pi_sup))
{
push(pi_sup,num_o,cor_o,pi_inf->cartas[pi_inf->topo].naipe);
pop(pi_inf);
return 1;
}
return 0;
}
um_atomo analisadorLexico(char **entrada, uma_pilha *pilha)
{
um_atomo a;
// Se houver um átomo na pilha, retorna esse átomo
if (! pilha_vazia (pilha))
return pilha_retira (pilha);
// Roda a máquina de estados até pegar um átomo
do
a = maquina_lexico(entrada);
while (!a);
return a;
}
int pop(tipo_pilha *p)
{
char x;
tipo_no *aux = p -> topo;
if (pilha_vazia(p))
{
printf("Pilha Vazia");
exit(1);
}
x = p -> topo -> info;
p -> topo = aux -> prox;
free(aux);
printf("Retirou o elemento %c", x);
return(x);
}
// computa a jogada do usuário caso for válida
int computa_jogada(pilha *pi_inf, pilha *pi_sup, int o, int d)
{
// se a pilha de origem pertencer as pilhas inferiores
if(o>NUM_PILHAS)
{
if(d>NUM_PILHAS)
{
if(coluna_para_coluna(pi_inf[o-NUM_PILHAS-1],pi_inf[d-NUM_PILHAS-1]))
return 1;
}
if(d>NUM_PILHAS/2)
{
if(coluna_para_base(pi_inf[o-NUM_PILHAS-1],pi_sup[d-1]))
return 1;
}
else
{
if(coluna_para_retencao(pi_inf[o-NUM_PILHAS-1],pi_sup[d-1]))
return 1;
}
return 0;
}
else
{
if(o>NUM_PILHAS/2)
return 0;
if(d>NUM_PILHAS)
{
if(retencao_para_coluna(pi_sup[o-1],pi_inf[d-NUM_PILHAS-1]))
return 1;
}
if(d>NUM_PILHAS/2)
{
if(retencao_para_base(pi_sup[o-1],pi_sup[d-1]))
return 1;
}
else
{
if(pilha_vazia(pi_sup[o-1]))
return 0;
if(retencao_para_retencao(pi_sup[o-1],pi_sup[d-1]))
return 1;
}
return 0;
}
}
int pilha_pop(Pilha *p)
{
Lista *t;
int k;
if (pilha_vazia(p)) {
fprintf(stderr, "Pilha esta vazia!\n");
exit(-1);
}
t = p->topo;
p->topo = p->topo->prox;
k = t->chave;
free(t);
return k;
}
// mover carta de coluna para base (pilha inferior para pilha base)
int coluna_para_base(pilha pi_inf, pilha pi_sup)
{
tipo_chave num_o=pi_inf->cartas[pi_inf->topo].numero,
cor_o=pi_inf->cartas[pi_inf->topo].cor;
tipo_simbolo naipe_o=pi_inf->cartas[pi_inf->topo].naipe;
if(pilha_vazia(pi_sup))
{
if(num_o==1)
{
push(pi_sup,num_o,cor_o,pi_inf->cartas[pi_inf->topo].naipe);
pop(pi_inf);
return 1;
}
}
else
{
tipo_chave num_d=pi_sup->cartas[pi_sup->topo].numero,
cor_d=pi_sup->cartas[pi_sup->topo].cor;
tipo_simbolo naipe_d=pi_sup->cartas[pi_sup->topo].naipe;
if(cmp_naipe(naipe_o,naipe_d))
{
if(cmp_cartas(num_o,cor_o,num_d,cor_d)==2)
{
push(pi_sup,num_o,cor_o,pi_inf->cartas[pi_inf->topo].naipe);
pop(pi_inf);
return 1;
}
}
}
return 0;
}
// mover carta de retenção para base (pilha retenção para pilha base)
int retencao_para_base(pilha pi_sup1, pilha pi_sup2)
{
tipo_chave num_o=pi_sup1->cartas[pi_sup1->topo].numero,
cor_o=pi_sup1->cartas[pi_sup1->topo].cor;
tipo_simbolo naipe_o=pi_sup1->cartas[pi_sup1->topo].naipe;
if(pilha_vazia(pi_sup2))
{
if(num_o==1)
{
push(pi_sup2,num_o,cor_o,pi_sup1->cartas[pi_sup1->topo].naipe);
pop(pi_sup1);
return 1;
}
}
else
{
tipo_chave num_d=pi_sup2->cartas[pi_sup2->topo].numero,
cor_d=pi_sup2->cartas[pi_sup2->topo].cor;
tipo_simbolo naipe_d=pi_sup2->cartas[pi_sup2->topo].naipe;
if(cmp_naipe(naipe_o,naipe_d))
{
if(cmp_cartas(num_o,cor_o,num_d,cor_d)==2)
{
push(pi_sup2,num_o,cor_o,pi_sup1->cartas[pi_sup1->topo].naipe);
pop(pi_sup1);
return 1;
}
}
}
return 0;
}
//funcao principal
//aqui serão feitas as intervenções com io usuário
int main ()
{
pilha p;//cria uma pilha chamada "p" vazia
p = criar_pilha();//define a estrutura de "p" e aplica p.topo=N-1 (contido em Criar_Pilha)
char nomes[50]; //string para receber o que o usuário digita
while (pilha_cheia(p)==false)//enquanto a pilha não estiver cheia faça(...)
{
printf ("Digite um nome: ");
scanf("%s", nomes);
push(p,nomes);
/*leva para empilhar "p" e "nomes", que na função "Push"
recebe o nome de "val"*/
}
//desempilhando
while (pilha_vazia(p)==false)
{
//consulta a pilha
top(p,nomes);
printf("Vou desempilhar: %s\n", nomes);//exibe o nome desempilhado
pop(p);//desempilha 1
//o "p.topo" mostra o valor atual do índice
}
system("Pause");
}
int main()
{
/* teste problema 1.1 */
{
vetor *v;
pilha *res;
int i;
char data[][11] = {"Estocolmo", "Oslo", "Helsinquia", "Copenhaga", "Reykjavik"};
printf("* Problema 1.1 *\n");
v = vetor_novo();
for(i=0; i<5; i++)
vetor_insere(v, data[i], -1);
printf("Vetor: ");
for(i=0; i<v->tamanho; i++)
printf("%s ", vetor_elemento(v, i));
printf("\n");
res = vetor_pilha(v);
printf("Pilha: ");
if(res)
{
while(!pilha_vazia(res))
{
printf("%s ", pilha_top(res));
pilha_pop(res);
}
}
printf("\n");
if(v->tamanho != 5)
printf("ERRO: Vetor original nao deve ser alterado!\n");
else
{
for(i=0; i<5; i++)
if(strcmp(data[i], vetor_elemento(v, i)) != 0)
{
printf("ERRO: Vetor original nao deve ser alterado!\n");
break;
}
}
vetor_apaga(v);
pilha_apaga(res);
}
printf("\n");
/* teste problema 1.2 */
{
int res, i, ok;
objeto obj;
char data[][20] = { "Paul Atreides", "Leto Atreides", "Voran Atreides",
"Vladimir Harkonnen", "Dmitri Harkonnen", "Hundro Moritani" };
tabela_dispersao td1, td2;
printf("* Problema 1.2 *\n");
td1 = tabela_cria(11, hash_djbm);
td2 = tabela_cria(7, hash_djbm);
for(i=0; i<6; i++)
{
strcpy(obj.chave, data[i]);
strcpy(obj.valor, data[i]);
tabela_adiciona(td1, &obj);
tabela_adiciona(td2, &obj);
}
res = tabela_redimensiona(td1, 7);
if(td1->tamanho == 7)
{
elemento *aux1, *aux2;
for(i=0; i<td1->tamanho; i++)
{
aux2 = td2->elementos[i];
while(aux2 != NULL)
{
ok = 0;
aux1 = td1->elementos[i];
while(aux1 != NULL)
{
if(strcmp(aux1->obj->chave, aux2->obj->chave) == 0)
{
ok = 1;
break;
}
aux1 = aux1->proximo;
}
if(!ok)
{
printf("ERRO: Elemento %s em posicao errada\n", aux2->obj->chave);
break;
}
aux2 = aux2->proximo;
}
}
if(ok)
printf("Tabela de dispersao redimensionada corretamente.\n");
}
else
printf("ERRO: Tabela de dispersao deveria ter novo tamanho.\n");
tabela_apaga(td1);
tabela_apaga(td2);
printf("\n");
}
/* teste problema 1.3 */
{
int i;
arvore_avl *avl;
lista *res, *indicacoes;
char data[][20] = { "prog2", "mt2", "trabalho", "e'", "muito", "zzzz...",
"dificil", "facil", "nada", "verdade"};
avl = avl_nova();
printf("* Problema 1.3 *\n");
for(i=0; i<10; i++)
avl_insere(avl, data[i]);
indicacoes = lista_nova();
lista_insere(indicacoes, "esquerda", -1);
lista_insere(indicacoes, "esquerda", -1);
lista_insere(indicacoes, "direita", -1);
res = descobre_segredo(avl, indicacoes);
printf("Segredo: ");
if(res)
{
for(i=0; i<res->tamanho; i++)
printf("%s ", lista_elemento(res, i));
}
printf("\n\nSegredo (impl. recursiva): ");
descobre_segredo_recurs(avl->raiz, indicacoes);
avl_apaga(avl);
lista_apaga(indicacoes);
lista_apaga(res);
printf("\n\n");
}
return 0;
}