Preciso de ajuda em C - Pilhas

[paulomiguel]

Pessoal!

Nunca postei aqui e realmente estou precisando de ajuda o mais rapido possivel!

Eu preciso fazer um código que faça duas pilhas e compare se são iguais, depois preciso que as duas pilhas se tornem uma pilha na ordem crescente

Eu tenho três paginas de código que meu professor fez de exemplo: Main.c, pilha.c e pilha.h

Vou tentar colocar eles para vocês!

Main:

#include <stdio.h>
#include <stdlib.h>
#include "Pilha.h"

int main ()
{

    // As operações abaixo exemplificam a utilização de uma Pilha

    TipoPilha *Topo1;
    TipoInfo dado;

    Topo1 = InicializaPilha(Topo1);

    Topo1 = PushPilha(Topo1,2);
    Topo1 = PushPilha(Topo1,4);
    Topo1 = PushPilha(Topo1,6);
    Topo1 = PushPilha(Topo1,8);
    Topo1 = PushPilha(Topo1,10);

    ImprimirPilha(Topo1);

    Topo1 = PopPilha(Topo1, &dado);
    printf("elemento %d retirado da pilha\n\n",dado);

    Topo1 = PopPilha(Topo1, &dado);
    printf("elemento %d retirado da pilha\n\n",dado);

    if (Vazia(Topo1))
      printf("a pilha esta vazia\n\n");
    else
       printf("a pilha não esta vazia\n\n");

    Topo1 = PopPilha(Topo1, &dado);
    printf("elemento %d retirado da pilha\n\n",dado);

    Topo1 = PopPilha(Topo1, &dado);
    printf("elemento %d retirado da pilha\n\n",dado);

    Topo1 = PopPilha(Topo1, &dado);
    printf("elemento %d retirado da pilha\n\n",dado);

    if (Vazia(Topo1))
      printf("a pilha esta vazia\n\n");
    else
       printf("a pilha não esta vazia\n\n");

   system("pause");
}

Pilha.c;

#include <stdio.h>
#include <stdlib.h>
#include "Pilha.h"

TipoPilha* InicializaPilha (TipoPilha *Topo)
{
    return NULL;
}

int Vazia (TipoPilha *Topo)
{
    if (Topo==NULL)
       return 1;
    else
       return 0;
}

void ImprimirPilha (TipoPilha *Topo)
{
     TipoPilha *ptaux;

     if (Topo != NULL)
     {
        puts("---Imprimindo pilha---");
        for (ptaux=Topo; ptaux!=NULL; ptaux=ptaux->elo)
            printf("%d\n",ptaux->dado);
        puts("-------Fim pilha------");
     }
     else
       puts("Pilha vazia");

}

TipoPilha* PushPilha (TipoPilha *Topo, TipoInfo Dado)
{
       TipoPilha *novo; //novo elemento

       /*aloca um novo nodo */
       novo = (TipoPilha*) malloc(sizeof(TipoPilha));
       novo->elo = NULL;

       /*insere a informação no novo nodo*/
       novo->dado = Dado;

       /*encaeia o elemento*/
       novo->elo = Topo;
       Topo = novo;
       return Topo;
}

TipoPilha* PopPilha (TipoPilha *Topo, TipoInfo *Dado)
{
   TipoPilha* ptaux;

   if (Topo == NULL)
     return NULL;   //não tem nada na pilha
   else
   {
        *Dado = (Topo)->dado;     //devolve o valor do topo
        ptaux = Topo;          //guarda o endereço do topo
        Topo = (Topo)->elo;     //o próximo passa a ser o topo
        free(ptaux);           //libera o que estava no topo
        ptaux=NULL;
        return Topo;            //retorna novo topo
   }
}

TipoInfo ConsultaPilha (TipoPilha *Topo)
{
 if (Topo==NULL)
   return 0;
 else
   return Topo->dado;

}

TipoPilha* DestroiPilha (TipoPilha *Topo)
{
        TipoPilha *ptaux;
        while (Topo != NULL)
        {
          ptaux = Topo;          //guarda o endereço do topo
          Topo = Topo->elo;     //o próximo passa a ser o topo
          free(ptaux);           //libera o que estava no topo
        }
        return NULL;
}

Pilha.h:

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

typedef int TipoInfo;

struct TPtPilha
{
        TipoInfo dado;
        struct TPtPilha *elo;
};
typedef struct TPtPilha TipoPilha;

TipoPilha* InicializaPilha (TipoPilha *Topo);
int Vazia (TipoPilha *Topo);
TipoPilha* PushPilha (TipoPilha *Topo, TipoInfo Dado);
TipoPilha* PopPilha (TipoPilha *Topo, TipoInfo *Dado);
TipoInfo ConsultaPilha (TipoPilha *Topo);
TipoPilha* DestroiPilha (TipoPilha *Topo);
void ImprimirPilha (TipoPilha *Topo);

Agradeço desde já a todos vocês!

O enunciado seria este:

1) Implemente uma função que receba como entrada duas pilhas e verifique se elas são

iguais. A função deve retornar o valor 1 se as duas pilhas forem iguais, e 0 caso contrário.

2) Considere duas pilhas (por exemplo, P1 e P2) cujos nodos contém números inteiros. Cada

pilha deve estar em ordem crescente a partir da base da pilha. Escrever uma função para

formar uma terceira pilha que contenha todos os elementos das duas pilhas originais. A

pilha resultante também deve estar em ordem crescente a partir da base. Exemplo:

3) Implemente no arquivo main o código necessário para testar essa função utilizando

diferentes casos de teste:

Principais testes:

• Pilha 1 vazia

• Pilha 2 vazia

• Pilha 1 e Pilha 2 vazias

• Pilha 1 com valores iguais e na mesma ordem que a Pilha 2

• Pilha 1 com a mesma quantidade de valores que a Pilha 2, porém valores diferentes (vice-versa)

• Pilha 1 com mais valores do que a Pilha 2, porém os valores da Pilha 2 são subconjunto da Pilha 1

• Outros casos de teste que você imaginar