C++ como somar duas pilhas?? problema no codigo

[Welington Silva 2002]

Fala galera!

Fiz um código em que eu somo duas pilhas passadas por parâmetro na main.

O problema é que não consigo dar o print na tela com os valores somados e acho que é alguma bobeira kkkk. Quebrei a cabeça dms já.

Ele só imprime a pilha :

1

1

1

 

O código:

#include <cstdlib> //SOMAR DUAS PILHAS 
#include <iostream>
using namespace std;

struct No {
   int Info;
   No *Lig;
};

typedef No *Pilha;

void IniciaPilha(Pilha& Topo){
	Topo = NULL;
}

Pilha TopoPilha(Pilha Topo){
   No *Aux = new No;
   Aux = Topo;
   return Aux;
}

bool PilhaVazia(Pilha Topo){
   if (Topo == NULL)
       return true;
   return false;
}

void Empilha(Pilha& Topo, int Elemento){
   No *Aux = new No;
   Aux->Info = Elemento;
   Aux->Lig = Topo;
   Topo = Aux;
}

bool Desempilha(Pilha& Topo, int& Elemento){
   if (PilhaVazia(Topo))
       return false;
   Elemento = Topo->Info;
   No *Aux = Topo;
   Topo = Topo->Lig;
   delete Aux;
   return true;
}

Pilha somapilhas(Pilha P1, Pilha P2)
{
    int v1, v2;
    Pilha P3;
    IniciaPilha(P3);
     while((P1->Lig!=NULL)&&(P2->Lig!=NULL)){  // ENQUANTO NÃO HOUVER PilhA VAZIA
     Desempilha(P1,v1);
     Desempilha(P2,v2);
     Empilha(P3, v1+v2);
     }
     while(P1->Lig!=NULL){
     Desempilha(P1,v1);
     Empilha(P3,v1);}
     while(P2->Lig!=NULL){
      Desempilha(P2,v2);
      Empilha(P3,v2);}
      return P3;

}

int main()
{
	Pilha P1;
	IniciaPilha(P1);
	Pilha P2;
	Pilha P3;
	IniciaPilha(P2);
    int Elemento;

	Empilha(P1, 1);
	Empilha(P1, 2);
	Empilha(P1, 3);

	Empilha(P2, 4);
	Empilha(P2, 4);
    Empilha(P2, 5);

	somapilhas(P1, P2);


	while(!PilhaVazia(P1)) {
		cout << Desempilha(P1, Elemento) << endl;
	}
	cout << endl;

	while(!PilhaVazia(P2)) {
		cout << Desempilha(P2, Elemento) << endl;
	}
	cout << endl;

	while(!PilhaVazia(P3)) {
		cout <<somapilhas(P1, P2)<< endl;
	}

	return 0;
}

 

[V!OLADOR]

Você precisa dizer ao compilador o que fazer quando der ao operador << dois objetos, um do tipo std::ostream (no caso, std::cout) e outro do tipo Pilha. Por exemplo,

 

std::ostream &operator<<(std::ostream &out, const Pilha &p)
{
	// determinar o comportamento de << aqui
}

 

[Ansi C]

2 horas atrás, Welington Silva 2002 disse:

Pilha TopoPilha(Pilha Topo){
	No *Aux = new No;
  
  	Aux = Topo;
  	return Aux;
}

 

 

Essa operação tem um nome genérico com 3 letras a ‘top’ ; “top” nos dar acesso ao item no topo da pilha, sem desempilhar. Logicamente, se não há itens empilhados, o topo é nulo.

"

 

Em outras palavras, TopoPìlha está equivocada: ela não faz o que deveria e também erra no que está fazendo que por sorte não significa nada porque nem foi utilizada na implementação.

 

Se continuar assim pode apagar TopoPilha.

"

[Welington Silva 2002]

@mauro_b

Eu tinha feito bobeira mesmo.... mt obgd!!!!

Mudei o código, deu certo agora....

 

 

Código:

 

 

#include <cstdlib>
#include <iostream>
using namespace std;

struct No {
    int Info;
    No *Lig;
};

typedef No *Pilha;

void IniciaPilha(Pilha& Topo){
    Topo = NULL;
}

Pilha TopoPilha(Pilha Topo){
    No *Aux = new No;
    Aux = Topo;
    return Aux;
}

bool PilhaVazia(Pilha Topo){
    if (Topo == NULL)
        return true;
    return false;
}

void Empilha(Pilha& Topo, int Elemento){
    No *Aux = new No;
    Aux->Info = Elemento;
    Aux->Lig = Topo;
    Topo = Aux;
}

bool Desempilha(Pilha& Topo, int& Elemento){
    if (PilhaVazia(Topo))
        return false;
    Elemento = Topo->Info;
    No *Aux = Topo;
    Topo = Topo->Lig;
    delete Aux;
    return true;
}

int TamanhoPilha(Pilha Topo){
   int elemento;
   int tam = 0;
   Pilha Aux;
   IniciaPilha(Aux);

   while(Desempilha(Topo,elemento)){
      Empilha(Aux,elemento);
      tam++;
   }

   while(Desempilha(Aux,elemento))
      Empilha(Topo,elemento);

   return tam;
}

Pilha SomaPilhas(Pilha P1, Pilha P2){
    Pilha P3, DadosInvertidos;
    IniciaPilha(P3);
    IniciaPilha(DadosInvertidos);
    int soma = 0, elemento = 0;

    while(P1 != NULL || P2 != NULL){                //ENQUANTO NÃO PERCORRER AS 2 FILAS COMPLETAMENTE

        if(P1 != NULL && P2 == NULL)                //SE P2 ACABOU, EMPILHA SÓ P1
            Empilha(DadosInvertidos, P1->Info);

        if(P2 != NULL && P1 == NULL)                //SE P1 ACABOU, EPILHA SÓ P2
            Empilha(DadosInvertidos, P2->Info);

        if(P1 != NULL && P2 != NULL){               //SE NENHUMA ACABOU, EMPILHA A SOMA
            soma = P1->Info + P2->Info;
            Empilha(DadosInvertidos, soma);
        }

        if(P1 != NULL)                              //INTERTRAVAMENTO P1
            P1 = P1->Lig;

        if(P2 != NULL)                              //INTERTRAVAMENTO P2
            P2 = P2->Lig;

        soma = 0;                                   //ZERANDO SOMA A CADA ITERAÇÃO
    }

    while(Desempilha(DadosInvertidos, elemento)){   //OBTENDO ORDEM CORRETA EM P3
        Empilha(P3, elemento);
    }

    return P3;
}

bool ImprimePilha (Pilha P){
    No *Aux = P;

    if(PilhaVazia(P)){
        cout<<"\nA pilha se encontra vazia!"<<endl;
        return false;
    }
    else{
        while(Aux != NULL){
            cout<<" "<<Aux->Info<<endl;
            Aux = Aux->Lig;
        }
    }
}

int main(){

    Pilha P1, P2, P3;
    IniciaPilha(P1);
    IniciaPilha(P2);
    int Elemento;

    Empilha(P1, 1);
    Empilha(P1, 2);
    Empilha(P1, 3);

    Empilha(P2, 4);
    Empilha(P2, 5);
    Empilha(P2, 6);

    cout<<"EIS A PILHA 1:\n";
    ImprimePilha(P1);

    cout<<"\nEIS A PILHA 2:\n";
    ImprimePilha(P2);

    cout<<"\nEIS A SOMA DAS PILHAS 1 E 2:\n";
    P3 = SomaPilhas(P1, P2);
    ImprimePilha(P3);

    cout<<endl;
    system ("PAUSE");
    return 0;
}