Pilhas em c # [falhando a função]

[naldoP]

Ola pessoal é o seguinte estou tendo problemas em desenvolver essa pilhas; o objetivo e fazer 3 pilhas no sentido de empilhar na pilha1 e desempilhar empilhar na pilha2 desempilhar e empilhar na pilha3, eu fiz aqui uma implementação com 3 pilhas empilhando e desempilhando, na função empilha esta tudo beleza o problema esta no desempilhar, quando eu empilho na pi1[tos1 peço para desempilhar tudo ok ! ai e mesmo elemento que foi desempilhado vou empilhar na pi2[tos2] tudo ok ! ai o mesmo elemento que foi desempilhado eu empilho na pi3[tos3] tudo ok ! o problema começa aqui na pi3[tos3] eu mando desempilhar não desempilhar ele continua a desempilhar a pi2[tos2] não desempilha a pi3[tos3].

Bom pessoal aqui esta o codigo para analise:

#include <stdlib.h>
#include <time.h>
#define MAX 10


int Empilhar (int pi1[], int pi2[], int pi3[],int pi4[], int dado, int num, int aux2);
int Desempilhar(int pi1[], int pi2[], int pi3[],int pi4[], int del);
void Nulos(int pi1[], int pi2[], int pi3[], int pi4[]);
void ExibirPilhas (int pi1[], int pi2[], int pi3[], int pi4[]);



int pi1[MAX],pi2[MAX],pi3[MAX],pi4[MAX],mat[5][3];
int tos1=0,tos2=0,tos3=0,tos4=0,adc,num,aux2=0,aux3=0,aux4=0,dado,del;



int main(){    
    char op;
    Nulos(pi1,pi2,pi3,pi4);
     
     

 printf("\n\nMenu: \ne - Empilhar\nd - Desempilhar\ni - Inserir\nr - Remover\ns - Sair\n\nDigite sua Opcao: ");     
     
     
     
       
              do                 
              {                          
             
               scanf("%c",&op);
               switch (op){
           
           
           
              case 'E' :
                        {
                         printf("\nDigite a direcao ");
                         scanf("%d",&num);                              
                         printf("\nDigite um valor ");
                         scanf("%d",&dado);
                         Empilhar(pi1,pi2,pi3,pi4,dado,num,aux2); 
                         ExibirPilhas(pi1,pi2,pi3,pi4);                          
                         scanf("%c",&op);
                         break;
                         
               
              case  'D' :
                         {
                          printf("\nDigite a direcao ");
                          scanf("%d",&del);
                          aux2 = Desempilhar(pi1,pi2,pi3,pi4,del); 
                       
                                                                                                     
                          ExibirPilhas(pi1,pi2,pi3,pi4);                    
                          printf("\nRemovido %d",aux2);
                        
                             
                          } 
                           
                          scanf("%c",&op);
                          break; 
                          
              case  'I' :
                        {
                         printf("\nDigite a direcao");
                         scanf("%d",&num);
                         Empilhar(pi1,pi2,pi3,pi4,dado,num,aux2);
                         ExibirPilhas(pi1,pi2,pi3,pi4);        
                       
                      
                       
                         scanf("%c",&op);
                          break;                                           
                        }
                      }
                    }
                  }                
                                                         
                       
               while(op != 'E' && op != 'D');
               system("pause");         
        }           
      
        
     
int Empilhar (int pi1[], int pi2[],int pi3[],int pi4[], int dado, int num, int aux2){       
    if(tos1 > MAX ){
       printf("A pilha esta cheia\n");
       return;
     }else{
    if(num == 1){   
       pi1[tos1]= dado;
       tos1++;       
     }else{     
    if(tos2 > MAX){
       printf("A pilha esta cheia\n");
       return;
     }else{
    if(num == 2){
       pi2[tos2]=aux2;
       tos2++;
     }else{
    if(tos3 > MAX){
       printf("A pilha esta cheia\n");
       return;
     }else{  
    if(num == 3){
       pi3[tos3]=aux2;
       tos3++;
     }else{
    if(tos4 > MAX){
       printf("A pilha esta cheia\n");
       return;
     }else{
    if(num == 4){
       pi4[tos4] = aux2;
       tos4++;                   
       }            
      }
     }                           
     }                             
     }
     }
     }
     }
     }





int Desempilhar(int pi1[], int pi2[], int pi3[],int pi4[], int del){    
    tos1--;
    if(tos1 < -1){
       printf("A pilha esta vazia\n ");
       return 0;
     }else{
    if(del == 1){
       return pi1[tos1];
     }else{
    tos2--;
    if(tos2 < -1){
       printf("A pilha esta vazia\n "); 
       return 0;
     }else{
    if(del == 2){
       return pi2[tos2];
     }else{
    tos3--;
    if(tos3 < -1){
       printf("A pilha esta vazia\n ");
       return 0;
     }else{
    if(del == 3){
       return pi3[tos3];
     }else{
    tos4--;
    if(tos4 < -1){
       printf("A pilha esta vazia\n ");
       return 0;
     }else{
    if(del == 4){
       return pi4[tos4];
        }                                                                     
       }
      }
     }
    }
   }
  }
 }
}               
} 


     
                                                        
            
void Nulos(int pi1[], int pi2[], int pi3[], int pi4[]){
     int aux;
     for(aux=0;aux<=MAX;aux++){                            
         pi1[aux]=0;
         pi2[aux]=0;
         pi3[aux]=0;
         pi4[aux]=0;
     }
}


void ExibirPilhas(int pi1[], int pi2[], int pi3[],int pi4[]){
     int i;
     for(i=tos1-1;i>=0;i--){
         printf("\n%d",pi1[i]);
     }
     for(i=tos2-1;i>=0;i--){
         printf("\n\t%d",pi2[i]);
     }
     for(i=tos3-1;i>=0;i--){
         printf("\n\t\t%d",pi3[i]);
     }
     for(i=tos4-1;i>=0;i--){
         printf("\n\t\t\t%d",pi4[i]);
     }                       
         printf("\n(A)\t(B)\t(C)\t(D)");
}

Editado Junho 16, 2011 por kuroi
Adicionar tag CODE

[kuroi]

hum... não entendi direito qual o objetivo do exercicio, mas essa forma de implementacao de pilha q você esta usando é muito estranha... alias, queria ate perguntar onde você aprendeu...

primeiro q costumamos usar uma classe (caso seja em c++), ou pelo menos uma estrutra (caso seja em c e você não possa criar classes) q deixasse os dados da pilha agrupados. assim, você não fica declarando varias variaveis separadas só pra uma pilha. e depois, essas funcoes q recebem varias pilhas por parametro tb não fazem muito sentido. e menos ainda se elas vao usar variaveis "públicas".

pelo menos uma struct você poderia usar pra facilitar:

typedef sctruct pilha {
    int itens[MAX]; //Guarda os itens
    int tos; //Guarda a quantidade de itens
};[/code]



assim, você declara as pilhas de uma vez só:
[code]pilha pi1, pi2, pi3, pi4;

e não esqueca de inicializar todos os tos com 0 logo q abrir o int main(). e depois você faz as funcoes de empilhar e desempilhar q trabalhem com uma unica pilha por vez. um exemplo de funcao q empilha:

bool Empilha(pilha *p, int elemento)
{
    bool r = false;

    if (p->tos < MAX)
    {
        p->itens[p->tos] = elemento;
        p->tos++;
    
        r = true;
    }

    return r;
}[/code]


um exemplo de como chamar a funcao:
[code]if (!Empilha(&pi1, dado))
{
    printf("A pilha está cheia.");
}

e pra desempilhar e empilhar na outra, você retorna o valor desempilhado pela funcao, como você já esta fazendo e em seguida, chama o empilha para a proxima pilha.

e ai você criaria uma variavel pra controlar qual a proxima pilha q sera empilhada. e seria muito mais facil se você pudesse criar um array com as 4 pilhas. mas não posso dar mtas dicas nessa parte pois não entendi direito o q tem q ser feito...

Editado Junho 16, 2011 por kuroi

[naldoP]

Primeiramente gostaria de agradecer a sua boa vontade de me ajudar, valeu Kuroi a sua dica realmente vai ser o meu obejtivo agora, em relação as pilhas acontece o seguinte os professores da faculdade falam que tinha mesmo que usar uma struct para tratar as pilhas; mas sabemos que na faculdade os professores não dao muita detalhes por exemplo ele pediu para que agente desenvolvese um jogo a Torre de Hanoi que envolbe tres pinos, por isso eu fiz essas 3 pilhas para testar e entender melhor sobre os movimentos dela, em relação a struct eu tentei fujir o maximo porque não consegui entender direito são muitas duvidas por esse motivo arrisquei a fazer esse codigo sem noção , que por sua vez não funcionou, mas graças a suas dicas agora vi que e possivel fazer a struct, na internet existem muitas implementaçoes mas nada que manipule mais de uma pilhas compartilhando o mesmo dado. sou meio de vagar para pegar as logicas mas com esforço acredito que chego la mas com certeza com ajuda de gente humilde igual a voces ai, valeu pelas dicas.

Mas como já estou por que gostari de pedir mais umas dicas se for possivel ok !!

A minha duvida agora e o seguinte, voce citou a;

typedef sctruct pilha {

int itens[MAX]; //Guarda os itens

int tos; //Guarda a quantidade de itens

};

assim, você declara as pilhas de uma vez só:

CODE

pilha pi1, pi2, pi3, pi4;

Ate aqui eu entendi, mas e no caso dos tos eu inicializo eles já na struct ou na main ?

int tos1,tos2,tos3, dessa forma estaria correto ?

Outra duvida sera que eu posso fazer uma função paramentrizando todas a pilhas para empilhar e paramentrizando todas as pilhas para desempilha assim como fiz naquele codigo, ou as funçoes de cada pilha tem que ser separadas uma funçao para cada pilha ao de vez ser em uma função so ?

Editado Junho 17, 2011 por naldoP

[kuroi]

assim, você declara as pilhas de uma vez só:

CODE

pilha pi1, pi2, pi3, pi4;

Ate aqui eu entendi, mas e no caso dos tos eu inicializo eles já na struct ou na main ?

int tos1,tos2,tos3, dessa forma estaria correto ?

hum... não. ai q ta o segredo heheh. veja a struct:

typedef sctruct pilha {
    int itens[MAX]; //Guarda os itens
    int tos; //Guarda a quantidade de itens
};[/code]

note q eu já declarei o tos dentro da struct, justamente pra fazer uma associacao melhor. ou seja, você não precisa declarar de novo, tos1, tos2 e tos3. porque já estao dentro da pilha. ou seja, quando eu declarei isso aqui:
[code]pilha pi1, pi2, pi3, pi4;

eu já declarei os itens da pilha e o contador de itens (tos) de uma vez. ai assim, quando você for passar a pilha por parametro, você passa somente a struct e já vao os itens e o contador juntos. assim, você não tem q passar os dois parametros pra funcao. exemplo, imagina q vc, por engano, acaba mandando empilhar a pilha pi1, mas mas passa o tos2 (contador de indices da pi2) como parametro. ai você ferra o programa todo, por um detalhe minusculo q você pode acabar gastando horas pra perceber. alem de q com a struct, o codigo fica muito menor, mais organizado e facil de mexer. então pra inicializar com 0, como eu estava falando, você faz isso (dentro do int main()):

pi1.tos = 0;
pi2.tos = 0;
pi3.tos = 0;
pi4.tos = 0;[/code]

a razao de isso ser necessario é q a pilha deve comecar vazia, ou seja com 0 elementos. então você tem q especificar q tem um 0 la dentro, porque quando a variavel é alocada, o valor dela vai ser o q estava no espaco de memoria q ela vai ocupar. ou seja, pode ser qualquer coisa. se você não especificar q ele tem q comecar com 0, você vai compremeter o resto do programa.


Outra duvida  sera que  eu posso fazer uma    função paramentrizando  todas a pilhas para empilhar e paramentrizando todas as pilhas   para desempilha  assim  como fiz  naquele codigo, ou  as  funçoes de  cada pilha  tem que  ser separadas  uma  funçao para  cada  pilha ao de vez  ser  em uma   função so ?
você poderia fazer uma funcao q fizesse esse empilhamento em varias pilhas. mas o melhor seria q ela propria usasse uma funcao de empilhamento generico pra cada pilha.
de uma olhada naquela funcao de empilhamento q eu passei. aquela seria a funcao padrão q costumamos usar sempre q trabalhamos com pilhas. assim, fica mais facil pra manipular cada pilha isoladamente.

imagina q você fosse fazer uma funcao q empilhe quatro pilhas de uma vez direto no codigo da propria funcao. você ia ter q colocar aquele codigo 4 vezes. ia ser um codigo muito maior, q ocuparia mais espaco na memoria, mais dificil de ser editado e, se você fizesse alguma alteracao na sua estrutura da pilha, ou se por qualquer outro motivo você precisasse alterar o codigo do empilhamento, você precisaria alterar o codigo 4 vezes.
ai você esquece 1 pequeno detalhe em um deles e ai já viu ne...

ou seja, você pode fazer uma funcao pra empilhar as 4 de uma vez. mas o melhor é q todas elas facam o empilhamento a partir de um codigo semelhante aquele q eu passei.
exemplo:
[code]void EmpilhaQuatroPilhas(pilha *p1, pilha *p2, pilha *p3, pilha *p4, [outros parametros q você quiser])
{
    Empilha(&p1, valor1);
    Empilha(&p2, valor2);
    Empilha(&p3, valor3);
    Empilha(&p4, valor4);

    //e ponha outros codigos q você queira acrescentar
}

ou seja, aquele codigo grandao q você fez, ficaria muito menor se você deixasse uma funcao apenas pro empilhamento de uma unica pilha, certo??

[naldoP]

E ai Kuroi beleza, então consegui fazer aqui mais ou menos a struct, porem não esta funcionando o codigo esta copilando mas quando executa a janela fecha na hora, gostaria de saber se está certa essa forma do codigo, para poder testar eu so estou usando uma pilha para empilhar e desempilhar, apesar de ter tres pilhas, so estou usando uma para teste ok !

Segue abaixo codigo:

#include <stdio.h>
#include <stdlib.h>
#define MAX 3

void InicializarPilhas(void);


typedef struct Pilha {       
      int vet[MAX];      
      int topo;
}Pilha;



Pilha pi1,pi2,pi3;


int main(){
    struct Pilha p; 
    int resp;   
    InicializarPilhas();
    void Menu(Pilha* p, int n);
}        



void  Empilhar(Pilha* p, int n){
      if(p->topo == MAX){
         printf("A pilha esta vazia\n ");
         exit(1);
         }
         p->vet[p->topo] = n;
         p->topo++;
}
                 
      
      

int Desempilhar(Pilha* p){
    int n;
    if(p->topo==0){
       printf("A pilha esta vazia\n");
       exit(1);
       }
       n = p->vet[p->topo-1];
       p->topo--;
       return n;            
    } 


void InicializarPilhas(void ){      
    pi1.topo=0;
    pi2.topo=0;
    pi3.topo=0;
}         
      

void ListarPilhas(Pilha* p){
     int i;
     for(i=p->topo-1;i>=0;i--){
         printf("\n%d",pi1.vet[i]);                      
       }                                                 
     for(i=p->topo-1;i>=0;i--){
         printf("\n\t%d",pi2.vet[i]);
       }
     for(i=p->topo-1;i>=0;i--){
         printf("\n\t\t%d",pi3.vet[i]);
       }
       printf("\n(A)\t(B)\t©");
}                                                      


void Menu(Pilha* p, int n){
     char op;
     printf("\nMenu");
     printf("\n 1 - Empilhar");
     printf("\n 2 - Desempilhar");
     do{                                   
     scanf("%c",&op);
     switch (op){
     
     case '1':
             {
              printf("Digite um valor para empilhar: ");
              scanf("%d",&n);
              Empilhar(&pi1, n);
              ListarPilhas(p);              
              break;
              }
              
     case '2':
             {        
              Desempilhar(&pi1);
              break;                 
            }
          }         
       }                             
       while(op != '1' && op != '2');
       system("pause");     
}

Editado Junho 25, 2011 por kuroi
Adicionar tag CODE

[kuroi]

naldo, não sei exatamente qual parte esta causando o erro, mas vi alguns problemas em seu codigo.

essa parte aqui:

void Menu(Pilha* p, int n);

ela deveria estar antes de abrir o int main(). veja como você fez com o void InicializarPilhas(void);.

acontece q a leitura dos codigos em c pelo compilador é sequencial. ou seja, você não pode chamar, na linha 10, uma funcao q só foi declarada na linha 20. a funcao q você vai chamar tem q aparecer no codigo antes do momento em q você vai chama-la, se não o compilador não sabe q ela existe.

mtos programadores não gostam de inserir todo o codigo da funcao antes de abrir o int main() porque em codigos muito gdes, pode ficar dificil de se encontrar. então, eles declaram apenas o prototipo da funcao antes do main, somente pro compilador saber q ela existe. e então eles colocam o codigo dela no final.

se você reparar, vai ver q foi exatamente assim q você fez com a funcao InicializarPilhas().

sendo assim, você deveria colocar o prototipo tb da funcao Menu() tb antes de abrir o int main(). quanto as demais funcoes (Empilha(), Desempilha(), etc), não teria exatamente necessidade se você só chama-las de dentro do Menu() (porque elas já estao declaradas antes do Menu()), então quando chegar la o compilador deve reconhece-las. mas caso você queira tornar essas funcoes "enxergadas" pelo programa todo, ou talvez pra ter um controle melhor, ai declare tb os prototipos delas antes do main(). assim como você fez com a InicializarPilhas().

e outra coisa. não existe a necessidade de passar a pilha por parametro para o Menu(). se o menu vai usar as tres pilhas, acesse-as diretamente, e por q passar somente uma?? tb não sei se teria a necessidade do parametro n. declare o n dentro do Menu() mesmo, assim como você fez com char op;.

fora isso, dentro de ListaPilhas(), você tb não precisava passar a pilha por parametro, porque ele vai usar as 3 pilhas q já existem. veja q você passa só uma por parametro e checa o topo dela 3 vezes. o certo devia ser checar o topo da propria pilha q você vai listar em cada um dos for.

veja como fica o programa depois dessas alteracoes, e qualquer coisa poste ai.

[naldoP]

Então Kuroi, é o seguinte, quando eu tento prototipar as funçoes com ponteiro, da erro no "*", e não copila então tentei usar essa versao sem ponteiro, copila mas não esta empilhando e aparece 0 nas tres pilhas.

Segue abaixo o codigo Atualizado:

#include <stdio.h>
#include <stdlib.h>
#define MAX 3

void Empilhar(int n);
int Desempilhar(void);
void ExibirPilhas(void);
void InicializarPilhas(void);
void Menu(void);


typedef struct Pilha{
     int vet[MAX];
     int  topo;
}Pilha; 
     

Pilha pi1,pi2,pi3;

struct Pilha p;              

int main(){   
    int n;
    char op;
   
    Menu();
    
                
        do{
           
           scanf("%c",&op);
           switch (op){
                             
                      case '1':
                              {
                               printf("\nDigite um valor para empilhar : ");
                               scanf("%d",&n);
                               Empilhar(n);                            
                               ExibirPilhas();
                               scanf("%c",&op);
                               break;
                             }
                              
                      case '2':
                              {        
                              Desempilhar();
                              scanf("%c",&op);
                              break;
                            }
                          }
                       } 
                       while(op != '1' && op != '2');
                       system("pause");
                 }              
                 
    
    
void Empilhar(int n){ 
     if(p.topo > MAX){
        printf("\nA pilha esta cheia : ");
        return;
        }
        p.vet[p.topo] = n;        
        p.topo++;
}
        

int Desempilhar(void){   
     int n;
     p.topo--;
     if(p.topo < -1){
        printf("\nA pilha esta vazia : ");
        return 0;
        }
        n = p.vet[p.topo];
        return n;
}


void InicializarPilhas(void){    
         pi1.topo=0;
         pi2.topo=0;
         pi3.topo=0;
}             
                                               
void ExibirPilhas(void){    
     int n;
     for(n=p.topo-1;n>=0;n--){
         printf("\n%d",pi1.vet[n]);
     }
     for(n=p.topo-1;n>=0;n--){
         printf("\n\t%d",pi3.vet[n]);
     }
     for(n=p.topo-1;n>=0;n--){
         printf("\n\t\t%d",pi3.vet[n]);
     }
         printf("\n(A)\t©\t(D)");
}


void Menu(void){
     printf("\nMenu : ");
     printf("\n1-Empilhar : ");
     printf("\n2-Desempilhar : ");
   }

Editado Junho 30, 2011 por kuroi
Adicionar tag CODE

[naldoP]

Então Kuroi, fiz exatamente agora a forma que voce citou , eu estava aqui pecando em algumas coisas mas funcionou legal a pilha esta Empilhando e Desempilhando normal, valeu pela dica voce me ajudou de mais meu ! agora eu tenho uma outra duvida em relação a vets[], para eu poder jogar os dados dentro de uma matrix por exemplo mat[3][3],

#define MAX 3

void  Mat_pilhas( Pilha* p,  mat[MAX][3]  ){

Essa assinatura seria correta ? Então segue abaixo o struct pilha da qual voce sugeriu funcionou prefeitamente Kuroi:

#include <stdio.h>
#include <stdlib.h>
#define MAX 3



typedef struct Pilha{
     int vet[MAX];
     int topo;
}Pilha;


Pilha pi1,pi2,pi3;

void Empilhar(Pilha* p, int n);
int Desempilhar(Pilha* p);
void InicializarPilhas(Pilha* p);
void ExibirPilhas(Pilha* p);
void Menu(void);




int main(){
    struct Pilha p;
    int n;
    char op;
    Menu();
    
       
         do{
            scanf("%c",&op);
            switch(op){
        
                    case '1':
                            {
                             printf("\nDigite um valor para empilhar : ");
                             scanf("%d",&n);
                             Empilhar(&pi2,n);
                             InicializarPilhas(&p);
                             ExibirPilhas(&p);
                             scanf("%c",&op);
                             break;
                           }
                   
                    case '2':
                            {
                             Desempilhar(&p);
                             ExibirPilhas(&p);
                             scanf("%c",&op);
                             break;
                           }
                         }
                       }
                       while(op != '1' && op != '2');
                       system("pause");
                }                               
    
    

void Empilhar(Pilha* p, int n){
     if(p->topo > MAX){
        printf("\nA pilha esta cheia : ");
        return;
        }
        p->vet[p->topo] = n;
        p->topo++;
}


int Desempilhar(Pilha* p){
    int n;
    p->topo--;
    if(p->topo<-1){
       printf("\nA pilha esta vazia : ");
       return 0;
       }
       n = p->vet[p->topo];
       return  n;
}                                     
    
            
void InicializarPilhas(Pilha* p){
     pi1.topo=-1;
     pi2.topo=-1;
     pi3.topo=-1;
}  


void ExibirPilhas(Pilha* p){
     int n;
     for(n=p->topo-1;n>=0;n--){
         printf("\n%d",pi1.vet[n]);
     }
     for(n=p->topo-1;n>=0;n--){
         printf("\n\t%d",pi2.vet[n]);
     }
     
     for(n=p->topo-1;n>=0;n--){
         printf("\n\t\t%d",pi3.vet[n]);
     }
          printf("\n(A)\t(B)\t©");      
}                 
                                                                   

void Menu(void){
     int n;
     char op;
     printf("\nMenu : ");
     printf("\n1-Empilhar : ");
     printf("\n2-Desempilhar : ");
}

Editado Junho 30, 2011 por kuroi
Adicionar tag CODE

[kuroi]

naldo, foi mal a demora. não sei se ainda ta interessado em uma resposta, mas...

não entendi exatamente qual a duvida... em q você quer usar essa matriz?? a duvida é como passar a matriz por parametro?? se for o caso acho q você declara assim:

void  Mat_pilhas( Pilha* p,  mat[][3]  ){

você não define o tamanho da primeira dimensao porque pro compilador tanto faz qual é. já as demais são necessarias, se não me engano, porque na memoria as matrizes são alocadas sequencialmente (uma matriz de 2 por 5 é alocada exatamente como um array de 10 posicoes). então o compilador precisa saber as dimensoes pra "entender" como é a divisao do array.

mas na hora de declarar a matriz, você faria mesmo mat[MAX][3].

mas não entendi se era isso mesmo q você tava querendo saber...

[naldoP]

Mais um vez muito obrigado Kuroi sua dicas resolveu meus probelas valeu mesmo, em relação a matrix a duvida era essa mesmo que voce acobou de tirar, agora vou fazer dessa forma que voce citou

Editado Junho 30, 2011 por naldoP