Aisó

4 horas atrás, Boko Moko disse:

Seu programa está com a lógica quase correta porém com a implementação errada.

O problema fundamental é que você está confundindo apontar com o que o apontador aponta

 

Por exemplo, a função push para por na pilha

void push (pPilha *p, int x){
// *p é o apontador para o topo da pilha
//  x é valor a ser adicionado a pilha

 pNodo no; // aqui declara-se uma variável que vai ter o apontador para o novo nó
 no = (pNodo) malloc(sizeof (nodo_b)); // aqui criou-se o nó 
 if (no != NULL){       // se der != NULL significa que conseguiu alocar a memória para o novo nó 
    no -> dado = x;     // no não é uma estrutura. Ele aponta para uma então o correto seria (*no)->dado = x;
    no -> prox = *p;    // aqui a mesma coisa (*no)->dado = *p; o próximo passa a apontar para o ex-topo da pilha
    *p = no;            // topo da pilha passa a apontar para o no 
  }
}

Existem vários erros de compilação e inclusão de bibliotecas que não são necessárias. além disso, esqueceu de traduzir "band" para faixa.

 

Dá uma olhada aqui e checa os comentários:
Código:

#include <stdio.h>
#include <stdlib.h>
/* #include <conio.h>
#include <locale.h>
*/

typedef struct nodo_a {
	int dado;
	struct nodo_a *prox;

} nodo_b;

typedef nodo_b *pNodo;
typedef nodo_b *pPilha;

void push(pPilha *p, int x) {
	pNodo no;
	no = (pNodo)malloc(sizeof(nodo_b));
	if (no != NULL) {
		no->dado = x;
		no->prox = *p;
		*p = no;
	}
}

int pop(pPilha *p) {
	pNodo no;
	int x = 0;
	no = *p;
	x = (*p)->dado;
	*p = (*p)->prox;
	free(no);
	return x;
}

int pilha_vazia(pPilha *p) {
	return (*p == NULL ? 1 : 0);
}

void mostra_pilha(pPilha *p) {
  pPilha ponteiro;
  ponteiro = *p;
  
  for( int i=0 ; (ponteiro != NULL) ;i++) {
    printf("Posicao %2i valor=%2i\n",i,(*ponteiro).dado);
    ponteiro = (*ponteiro).prox;
  }
  printf("Fim da pilha\n\n");
  
}

void pilhasIguais(pNodo N1, pNodo N2) {
	double faixa = 1;

	if ((N1 == NULL) || (N2 == NULL)) {
		printf(" Um das Pilhas Está vazia ");
	} else {
		while ((N1 != NULL) && (N2 != NULL) && (faixa)) {
			if (N1->dado != N2->dado) {
				faixa = 0;
			} else {
				N1 = N1->prox;
				N2 = N2->prox;
			}
		}
	}
	if ((N1 == NULL) && (N2 == NULL) && (faixa)) {
		printf("Pilhas Iguais\n");
	} else {
		printf("Pilhas Diferentes\n");
	  
	}
}

void main() {
	pPilha P1 = NULL, P2 = NULL;

	/* cria pilha um */
	push(&P1, 8);
	push(&P1, 23);
	push(&P1, 3);
	
	mostra_pilha(&P1);
	

	push(&P2, 8);
	push(&P2, 23);
	push(&P2, 3);
	mostra_pilha(&P2);

	if (!pilha_vazia(&P1) && !pilha_vazia(&P2)) {
		pilhasIguais(P1, P2);
	}

	pPilha P3 = NULL, P4 = NULL;

	push(&P3, 8);
	push(&P3, 23);
	push(&P3, 4);
	mostra_pilha(&P3);

	pilhasIguais(P1, P3);

	push(&P4, 4);
	push(&P4, 23);
	push(&P4, 8);
	mostra_pilha(&P4);

	pilhasIguais(P1, P4);


	;
}

Código com compilador online:
https://repl.it/@bokomoko/Pilha-usando-apontadores-comparacao

Obrigada  @Boko Moko vou rever com suas sugestões!

 Então, o que eu quero mesmo é que rode.

e não sei o que está faltando para isso.

Oi galera, inicialmente esse código era em visual C++ .

Fui fazendo mudanças para transforma-lo em C, só que agora não consigo mais sair do lugar, alguém pode me ajudar?

/*Codigo para testar se duas pilhas P1 e P2 são iguais.

Duas pilhas são iguais se possuem os mesmos elementos, na mesma ordem.

Você pode utilizar pilhas auxiliares também, se necessário. */

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


typedef struct nodo_a{

int dado;
struct nodo_a *prox;

}nodo_b;


typedef nodo_b *pNodo;
typedef nodo_b *pPilha;


void push (pPilha *p, int x){

 pNodo no;
 no = (pNodo) malloc(sizeof (nodo_b));
 if (no != NULL){
    no -> dado = x;
    no -> prox = *p;
    *p = no;
  }
}


int pop (pPilha *p){
    pNodo no;
    int x = 0;
    no = *p;
    x = (*p)->dado;
    *p = (*p)-> prox;
    free(no);
    return x;
}


int pilha_vazia(pPilha *p){
    return (*p == NULL ? 1:0);
}


void pilhasIguais (pNodo N1, pNodo N2){
    double  faixa = true;

    if ((N1 == NULL) || (N2 == NULL)){

    printf(" Pilhas Estão Vazias", setlocale(LC_ALL,""));
    }
    else{
        while ((N1 != NULL) &&(N2 != NULL) &&(faixa)){
            if(N1 -> dato != N2 -> dato){
                faixa = false;
            }
            else {
                    N1 = N1 -> prox;
                    N2 = N2 -> prox;
            }
        }
    }
    if (( N1 == NULL) && (N2 == NULL) && (band)){
        printf("Pilhas Iguais\n");
}


 void main(){
     pPilha  P1 == NULL, P2 == NULL;

     nodo_b *p = (nodo_b *) malloc(sizeof(nodo_b));

     push(P1,8);
     push(P1,23);
     push(p1,3);
     push(P2,8);
     push(P2,23);
     push(p2,3);      

     if (!= pilha_vazia(&P1) && != pilha_vazia(&P2)){
        pilhasIguais(P1,P2);
     }

  getch();
  }

}