链栈...

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

typedef struct Node {
	int data;
	struct Node* next;
}Node;

typedef struct Stack {
	Node* top;
	int length;
}Stack;

Node* getNewNode(int);
Stack* init_stack();
void clear(Stack*);
int empty(Stack*);
int push(Stack*, int);
int pop(Stack*);
void output(Stack*);
int top(Stack*);

Node* getNewNode(int val) {
	Node* node = (Node*)malloc(sizeof(Node));
	node->data = val;
	node->next = NULL;
	return node;
}

Stack* init_stack() {
	Stack* s = (Stack*)malloc(sizeof(Stack));
	s->length = 0;
	s->top = NULL;
	return s;
}

void clear(Stack* s) {
	if (s == NULL) return;
	Node* p = s->top,*q;
	while (p!= NULL) {
		q = p->next;
		free(p);
		p = q;
	}
	free(s);
	return;
}

int empty(Stack *s) {
	return s->top == NULL;
}

int top(Stack* s) {
	return s->top->data;
}

int push(Stack* s, int val) {
	if (s == NULL) return 0;
	Node* p = getNewNode(val);
	p->next = s->top;
	s->top = p;
	s->length += 1;
	return 1;
}

int pop(Stack* s) {
	if (s == NULL) return 0;
	if (empty(s)) return 0;
	Node* p = s->top;
	s->top = p->next;
	free(p);
	s->length -= 1;
	return 1;
}

void output(Stack* s) {
	if (s == NULL) return ;
	printf("Stack[%d]: ",s->length);
	for (Node* p = s->top; p; p = p->next) {
		p != s->top && printf(" ");
		printf("%d", p->data);
	}
	printf("\n");
	return;
}

int main() {
	srand(time(0));
	#define MAX_OP 20
	Stack* s = init_stack();
	for (int i = 0; i < MAX_OP; i++) {
		int op = rand() % 4;
		int val = rand() % 100;
		switch (op) {
			case 0:
			case 1:
			case 2: {
				printf("push %d to the Stack = %d\n", val, push(s, val));
			}break;
			case 3: {
				if (!empty(s)) {
					printf("pop %d from the Stack = ", top(s));
					printf("%d\n", pop(s));
				}
			}break;
		}
		output(s);
		printf("\n");
	}
	#undef MAX_OP
	free(s);
	return 0;
}