c语言 实现有获取最小值功能的栈

准备两个栈，一个栈存数据，另一个栈存最小值，相对与栈顶谁小就存谁。他们同步更新。
一起压栈一起弹栈，数据数量一致。c++封装起来会更好看。本代码移植c++基本不需要修改。

#include <stdio.h>
#include <stdlib.h>
/*by xuyongqi*/


/*实现有获取最小值功能的栈*/

typedef struct node {
	void* data;
	struct node *next;
}node;

typedef struct stack {
	node *head;
	int size;
}stack;

 /*初始化*/
void* init()
{
	stack* st = (stack*)malloc(sizeof(stack));
	if(st == NULL) return NULL;
	st->head = NULL;
	st->size = 0;
	return st;
}

 /*销毁栈*/
void destory(void *st)
{
	if(st == NULL) return;
	stack *p =(stack*)st;
	node *del = p->head;
	node *temp = NULL;
	while (del != NULL)
	{
	   temp = del->next;
	   free(del);
	   del = temp;
	}
	free(p);
	p = NULL;
}

 /*压栈*/
void push(void *st, void *data)
{
	if(st ==NULL || data ==NULL) return;
	stack *p =(stack*)st;
	node *new_node = (node*)malloc(sizeof(node));
	new_node->next = NULL;
	new_node->data = data;

	if (p->head == NULL)
	{
	    p->head = new_node;
	} else {
	    new_node->next = p->head;
	    p->head = new_node;
	}     
	p->size++;
}

 /*弹栈*/
void pop(void *st)
{
	if (st== NULL) return;
	stack *p =(stack*)st;
	if (p->size == 0) return;

	node *del = p->head;
	p->head=del->next;
	free(del);
	del = NULL;
	p->size--;
}

 /*返回栈顶元素*/
void* top(void *st)
{
	if (st== NULL) return NULL;
	stack *p =(stack*)st;
	if (p->size == 0) return NULL;
	return p->head->data;
}

/*栈是否为空*/
int empty(void *st)
{
	if (st== NULL) return 0;
	stack *p =(stack*)st;
	return p->size == 0;
}

/*栈中元素个数*/
int size(void *st)
{
	if (st== NULL) return -1;
	stack *p =(stack*)st;
	return p->size;
}
/*********************上面单链表栈的实现****************************/

typedef struct get_min_stack {
	stack *stack_data;	//数据栈
	stack *stack_min;	//最小值栈
}get_min_stack;


typedef int(*compare)(void *data1, void *data2);
 /*初始化*/
void* init_get_min_stack()
{
	get_min_stack *p = (get_min_stack*)malloc(sizeof(get_min_stack));
	p->stack_data = (stack*)malloc(sizeof(stack));
	p->stack_min = (stack*)malloc(sizeof(stack));
}

 /*销毁栈*/
void destory_get_min_stack(void *st)
{
	if (st == NULL) return;
	get_min_stack *p = (get_min_stack *)st;
	destory(p->stack_data);
	destory(p->stack_min);
	free(p);
	st = NULL;
}

 /*压栈*/
void push_get_min_stack(void *st, void *data, compare func)
{	
	if (st == NULL) return;
	get_min_stack *p = (get_min_stack *)st;
	push(p->stack_data, data);
	void *min = top(p->stack_min);
	/*和最小栈栈顶比较，谁小谁压栈*/
	if (func(data, min))
	{
		push(p->stack_min, min);
	}else{
		push(p->stack_min, data);
	}
	
}

 /*弹栈*/
void pop_get_min_stack(void *st)
{
	if (st == NULL) return;
	get_min_stack *p = (get_min_stack *)st;
	pop(p->stack_data);
	pop(p->stack_min);
}

 /*返回栈顶元素*/
void* top_get_min_stack(void *st)
{
	if (st == NULL) return NULL;
	get_min_stack *p = (get_min_stack *)st;
	return top(p->stack_data);
}

 /*返回最小元素*/
void* get_min(void *st)
{
	if (st == NULL) return NULL;
	get_min_stack *p = (get_min_stack *)st;
	return top(p->stack_min);
}

int int_compare(void *data1, void *data2)
{
	return *(int*)data1 > *(int*)data2;
}

int main()
{
	int d1 = 1;
	int d2 = 2;
	int d3 = 3;
	int d4 = 4;
	int d5 = 5;
	get_min_stack *s= init_get_min_stack();

	push_get_min_stack(s, &d3, &int_compare);
	push_get_min_stack(s, &d2, &int_compare);
	push_get_min_stack(s, &d1, &int_compare);
	push_get_min_stack(s, &d4, &int_compare);
	push_get_min_stack(s, &d5, &int_compare);

	while(!empty(s))
	{
	    int *i = (int*)top_get_min_stack(s);
		int *min = (int*)get_min(s);
	    printf("top %d , min %d\n", *i, *min);
	    pop_get_min_stack(s);
	}
	destory_get_min_stack(s);
}
/*
top 5 , min 1
top 4 , min 1
top 1 , min 1
top 2 , min 2
top 3 , min 3
*/