Pilha - o código está correto?

[vouver 0]

Olá... estou aprendendo a trabalhar com estrutura de dados e gostaria que vcs, se possivel, avaliassem o código feito e me dissessem se "adicionei" o código da pilha corretamente:

 

// algoritmo que calcula e escreve o valor de S
S= 1/1+3//2+5/3+7/4+...+99/50

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



/* definicao de tipo */
struct lista
{
    double x;
    struct lista* prox;
};

typedef struct lista Lista;

struct pilha
{
    Lista* prim;
};
typedef struct pilha Pilha;
/* definicao de funcoes */

Pilha* pilha_cria(void)
{
  Pilha* p = (Pilha*)malloc(sizeof(Pilha));
  p-> prim = NULL;
  return p;
}
void pilha_insere(Pilha* p, double dado)
{
  Lista* n = (Lista*)malloc(sizeof(Lista));
  n -> x = dado;
  n -> prox = p->prim;
  p->prim = n;
}
int pilha_libera(Pilha* p)
{
    Lista* q = p->prim;
    while (q != NULL)
    {
        Lista* t = q->prox;
        free(q);
        q = t;
    }
    free(p);
}
void pilha_imprime(Pilha* p)
{
    Lista* q;
    if (p != NULL)
      for (q = p->prim;q != NULL;q = q->prox)
        printf("%2.20lf\n",q->x);
      else
        printf("\nPilha Vazia\n");
    printf("\n");
}

void somatorio(Pilha* p)
{
    Lista* q;
    double soma;
    soma = 0;
    for (q = p->prim;q != NULL;q = q->prox)
        soma = soma + q->x;
    printf("\nSoma = %lf\n",soma);
}



int main()
{
Pilha* p;
int i = 0;
float s = 0;


p = pilha_cria();
for (i = 1; i <= 50; i++)
{
s += (2*i-1)/i;
pilha_insere(p,s);
printf(" %d/%d\n",(2*i-1),i);
}

printf("\n\n Somatorio: %.3f\n\n",s);
pilha_imprime(p);
    somatorio(p);
    pilha_libera(p);
    return 0;

return 0;
}

[_Isis_ 202]

Acho que você colocou coisas desnecessárias aí (tentativa de criar uma pilha encapsulando uma lista).

pilha.h

struct lista {
    double x;
    struct lista* prox;
};

typedef struct lista pilha;

void _malloc_check(pilha *p);
pilha * push(double v, pilha * dest);
pilha * pop(pilha * dest);
size_t is_empty();
void imprime(pilha * dest);
void _destroy(pilha * p);

pilha.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include "pilha.h"

size_t _tamanho = 0;
pilha * tail; // Para otimizar o acesso ao último elemento, já que não são porções contíguas em memória.

void _malloc_check(pilha * p) {
  if (!p) {
      printf("ERRO [%s@%d]: %s\n", __FILE__, __LINE__, strerror(errno));
      exit(EXIT_FAILURE);
    }
}

size_t is_empty() {
  return !_tamanho;
}

pilha * push(double v, pilha * dest) {
  pilha * p;

  if (!dest || is_empty()) {
    dest = malloc(sizeof(pilha));
    _malloc_check(dest);

    dest->x = v;
    dest->prox = NULL;
    tail = dest;

  } else {
    p = malloc(sizeof(pilha));
    _malloc_check(p);

    p->x = v;
    p->prox = NULL;
    
    tail->prox = p;
    tail = p;
  }

  _tamanho++;
  return dest;
}


pilha * pop(pilha * dest) {
  if (!is_empty()) {

    if (_tamanho == 1) {
      free(dest);
      tail = NULL;
      dest = NULL;

    } else {
      pilha *t;

      for(t = dest; t->prox != tail; t = t->prox);

      free(tail);
      tail = NULL;

      tail = t;
      t->prox = NULL;
    }
    _tamanho--;
  }

  return dest;
}

void imprime (pilha * p) {
    pilha * t;
    for(t = p; _tamanho && t!=NULL; t = t->prox) {
      printf("[@%p]:%.2f\n", t, t->x);
    }
}

void _destroy(pilha * p) {
  if (p) {
    pilha * a, *b;

    for(b = p, a = p->prox; a!=NULL;) {
      free(b);
      b = NULL;
      _tamanho--;
      
      if (a) {
        b = a;
        a = b->prox;
      }
    }

    p = NULL;
  }
}

main_pilha.c

#include <stdio.h>
#include "pilha.h"

int main(void) {
	pilha * p = NULL;

	for(int i=1; i<4; i++)
		p = push(i, p);

	imprime(p);
	p = pop(p);
	imprime(p);
	_destroy(p);
	return 0;
}

Compilação: gcc -Wall -Wextra -std=c99 main_pilha.c pilha.c