Sort stack items A and B on stack C

Question

I am learning how to manipulate stacks in the Data Structure discipline, but having difficulties in implementing functions such as sorting and reeling is presenting errors in the scope of the if loop.

#include <stdio.h>
#include<stdlib.h>
#define MAX_SIZE 6

 // Implementando a estrutura
typedef struct
{
       int topo, item[MAX_SIZE];
}stack;

// Função  Inicia Pilha 
void iniciaPilha ( stack *p)
{
     p->topo = -1; // O topo começa em -1,pq em 0 signicaria que estaria já na primeira posição
}

// Função Verifica se a  pilha está Cheia
int pilhaCheia ( stack *p)
{
    if (p->topo == (MAX_SIZE-1))
    {
          printf ("\n\n\t\tA Pilha esta Cheia!!!");
          return 1;
    }else
        return 0;
}

// Função Verifica pilha Vazia 
int pilhaVazia ( stack *p)
{
    if (p->topo == -1)
    {
         printf ("\n\n\t\tA Pilha esta Vazia!!!");
         return 1;
    }
    else
     return 0;
}

//  Função verifica se a 2 está pilha Vazia 
int pilhaVazia2 (stack *p)
{
    if (p->topo == -1) // O topo começa em -1,pq em 0 signicaria que estaria já na primeira posição
       return 1;
    else
       return 0;
}

//   Função Empilha  
int push ( stack *p, int valor)
{
     return (p->item[++(p->topo)] = valor);// retornar ao valor do topo
}

//  Função Desempilha  
int pop ( stack *p)
{
    int aux;
    aux = p->item[(p->topo)--]; //decrementando o topo, ou seja, desempilhando os elementos
    return aux;
}

// Função Mostra Pilha  

int mostra (stack *p)
{
    int aux;
    if (pilhaVazia2 (p))
       return 1;
    else
    {
        aux = pop (p);
        printf ("%d,", aux);
        mostra (p);
        return 0;
    }
}


//  Função reempilha 
int reempilha ( stack *p,  stack *pPilhaB,  stack *pPilhaC)
{
    int aux;
     if (pilhaVazia (p)&&pilhaVazia (pPilhaB))
       return 1;
    else
    {   
       if ((p->item[p->topo]&&(pPilhaB->item[pPilhaB->topo]))//se o topo estiver com uma valor reempilha os valores de A em B
        {
               aux = pop (p)&&pop(pPilhaB);
               push (pPilhaC, aux); 
           //push (pPilhaB, aux);
        }
        reempilha (p, pPilhaB, pPilhaC); // chamando a função para reempilhar os elementos em 
        return 0;
    }

}

// Funcao para pegar os valores a empilhar 
int empilha ( stack *p)
{
    int valor;
    printf ("\n\nInforme os seis valores para ser empilhado ou -2 para mostrar os valores de B  ");
    scanf ("%d",&valor);
    if (pilhaCheia (p))
       return 1;
    else
    {
        if (valor == -2)// se o numero -2 for digitado então os valores impares e pares serão colocados
                  return 0;
        else
        {
            push (p, valor);
empilha (p);
            return 0;
        }
    }
}
 int ordenar( stack *p,  stack *pPilhaB,  stack *pPilhaC){
// pilhac=para receber os elementos desempilhados e ordenados   
int aux;//variavel para comparar os elementos

     if (pilhaVazia (p)&&pilhaVazia (pPilhaB))//se a pilha estiver vazia retorno 0, não existe ainda ordenação
       return 0;
      pop (p)&&pop(pPilhaB);// Vou ter que desempilhar um unico elemento de cada pilha

     if ((p->item[p->topo]>=(pPilhaB->item[pPilhaB->topo])) //se o topo estiver com uma valor reempilha os valores de A em B

        {

               aux = pop (p)&&pop(pPilhaB);// aux vai receber os elemntos do topo das duas pilhas

               empilha(pPilhaC); 

        }
        ordenar (p, pPilhaB, pPilhaC); // chamando a função para reempilhar os elementos em 
        return 1;
     }


// Função principal

int main ()
{
   stack pilha, pilha_pPilhaB, pilha_pPilhaC;

   iniciaPilha (&pilha);
   iniciaPilha (&pilha_pPilhaB);
   iniciaPilha (&pilha_pPilhaC);

   push(&pilha, 6);
   push(&pilha, 4);
   push(&pilha, 1);
   printf("\nOs valores  da pilha A = :"); // Mostrando na tela os valores 
   mostra(&pilha);
   printf("\n\n\n");

   push(&pilha_pPilhaB, 5);
   push(&pilha_pPilhaB, 3);
   push(&pilha_pPilhaB, 2);
   printf("\nOs valores  da pilha B = :"); // Mostrando na tela os valores 
   mostra(&pilha_pPilhaB);
   printf("\n\n\n");
    iniciaPilha (&pilha_pPilhaC);
    ordenar ( &pilha,&pilha_pPilhaB,&pilha_pPilhaC);
    printf ("\nOs valores ordenados na pilha C = :"); // Mostrando na tela os valores 
    mostra (&pilha_pPilhaC);


   printf("\n\n\n");
    return 0;
}

Answer 1

Follows the (tested) solution of the problem using sorting bubble sort nonrecursive:

/* ****************************************************************** */
/* *                              pilha.c                           * */
/* ****************************************************************** */

#include <stdio.h>
#include <string.h>


#define PILHA_MAX_TAM        (10)

#define SUCESSO              (0)
#define ERRO_PILHA_CHEIA     (-1)
#define ERRO_PILHA_VAZIA     (-2)


typedef struct pilha_s pilha_t;

struct pilha_s
{
    int item[ PILHA_MAX_TAM ];
    int qtd;
};


void pilha_inicializar( pilha_t * p )
{
    memset( p, 0, sizeof(pilha_t) );
}


int pilha_push_item( pilha_t * p, int n )
{
    if( p->qtd == PILHA_MAX_TAM )
        return ERRO_PILHA_CHEIA;

    p->item[ p->qtd++ ] = n;

    return SUCESSO;
}


int pilha_push_pilha( pilha_t * pdst, pilha_t * porig )
{
    int i = 0;

    for( i = 0; i < porig->qtd; i++ )
        pilha_push_item( pdst, porig->item[i] );

    return SUCESSO;
}


int pilha_pop_item( pilha_t * p )
{
    if( p->qtd == 0 )
        return ERRO_PILHA_VAZIA;

    return p->item[ --p->qtd ];
}


void pilha_listar_itens( pilha_t * p )
{
    int i = 0;

    if( !p->qtd )
    {
        printf("Pilha Vazia!\n");
        return;
    }

    printf( "Pilha:\n" );

    for( i = p->qtd - 1; i >= 0; i-- )
        printf( "   Posicao %d / Valor: %d\n", i, p->item[i] );
}


void pilha_ordenar_itens( pilha_t * p )
{
    int i = 0;
    int j = 0;

    for( i = 0; i < p->qtd; i++ )
    {
        for( j = i + 1; j < p->qtd; j++ )
        {
            if( p->item[i] > p->item[j] )
            {
                int aux = p->item[i];
                p->item[i] = p->item[j];
                p->item[j] = aux;
            }
        }
    }
}


int main( int argc, char * argv[] )
{
    pilha_t pa;
    pilha_t pb;
    pilha_t pc;

    pilha_inicializar( &pa );
    pilha_inicializar( &pb );
    pilha_inicializar( &pc );

    pilha_push_item( &pa, 6 );
    pilha_push_item( &pa, 4 );
    pilha_push_item( &pa, 1 );

    pilha_listar_itens( &pa );

    pilha_push_item( &pb, 5 );
    pilha_push_item( &pb, 3 );
    pilha_push_item( &pb, 2 );

    pilha_listar_itens( &pb );

    pilha_push_pilha( &pc, &pa );
    pilha_push_pilha( &pc, &pb );

    pilha_listar_itens( &pc );

    pilha_ordenar_itens( &pc );

    pilha_listar_itens( &pc );

    return 0;
}

/* fim-de-arquivo */

Compiling (on Linux):

$ gcc -Wall pilha.c -o pilha

Exit:

$ ./pilha
Pilha:
        Posicao 2 / Valor: 1
        Posicao 1 / Valor: 4
        Posicao 0 / Valor: 6
Pilha:
        Posicao 2 / Valor: 2
        Posicao 1 / Valor: 3
        Posicao 0 / Valor: 5
Pilha:
        Posicao 5 / Valor: 2
        Posicao 4 / Valor: 3
        Posicao 3 / Valor: 5
        Posicao 2 / Valor: 1
        Posicao 1 / Valor: 4
        Posicao 0 / Valor: 6
Pilha:
        Posicao 5 / Valor: 6
        Posicao 4 / Valor: 5
        Posicao 3 / Valor: 4
        Posicao 2 / Valor: 3
        Posicao 1 / Valor: 2
        Posicao 0 / Valor: 1

I hope it helps!