两种实现数据结构中的栈（C语言）

/* 栈的实现 2 数组实现 结构体内定义数组 *******
* 通过结构体内指针的移动
*/
typedef struct note  {
char *base;                    /* 字符数组 */
char *top;
int size;
} stack;

/* 栈的实现 1 链表实现 *********
* 通过结构体间指针传递
*/
typedef struct lnote {
char c;
struct lnote *next;
} Stack;

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

#define Maxlen 20
/* 数组实现的函数 */
stack *create_stack(void);
void push_stack(stack *, char);
void print_stack(stack *);
char pop_stack(stack *);
void dispose_stack(stack *);

/* 链表实现的函数 */
Stack *Create_Stack(void);
void Push_Stack(Stack *, char);
void Print_stack(Stack *);
char Pop_Stack(Stack *);
void Dispose_Stack(Stack *);

int main()
{
/***数组实现
char x;
stack *s;
s = create_stack();
push_stack(s,'a');
push_stack(s,'b');
x = pop_stack(s);
push_stack(s,'c');
print_stack(s);
dispose_stack(s);
*/
/* 链表实现 */
char x;
Stack *head;
head = Create_Stack();
Push_Stack(head, 'a');
Push_Stack(head, 'b');
Push_Stack(head, 'c');
x = Pop_Stack(head);
Print_stack(head);
Dispose_Stack(head);
getchar();
return 0;
}

/*********************链表的实现*******************/
/*
*     初始化
*/
Stack *Create_Stack(void)
{
Stack *head;
head = (Stack *)(malloc(sizeof(Stack)));
if (head == NULL)
printf("Out of space");
head->next = NULL;
return head;
}

/*
*     压栈         ***************版本一不含头结点  错误的******
*/
//void Push_Stack(Stack *s, char a)//Push_Stack_w/o_head(Stack *s, char a)
//{
//	Stack *p;
//	p = (Stack *)(malloc(sizeof(Stack)));
//	if (p == NULL) {
//		printf("Out of space");
//		return;
//	}
//	p->c = a;
//	p->next = s;
//	s = p;               /* 此时只改变了形参 s， 实参是没有变的，如果加入头结点就可以用指针改变栈顶了 */
//	printf("%c\n",s->c);
//}

/*
*     压栈         ********不含头结点 ******
*/
void Push_Stack(Stack *s, char a)
{
Stack *p;
p = (Stack *)(malloc(sizeof(Stack)));
if (p == NULL) {
printf("Out of space");
return;
}
p->c = a;
p->next = s->next;                            /* 采用链表的前插法 */
s->next = p;                                  /* 用指针改变栈顶了 */
}

/*
*     打印
*/
void Print_stack(Stack *s)
{
Stack *p;
p = s->next;
while (p) {
printf ("%c\n",p->c);
p = p->next;
}
}

/*
*     出栈
*/
char Pop_Stack(Stack *s)
{
char temp;
Stack *p;
p = s->next;
if(!p) {
printf("Empty stack");
return -1;
}
temp = s->c;
s->next = p->next;                    /* 暂存以前的栈顶，以便释放 */
free(p);
return temp;
}

/*
*     删除栈
*/
void Dispose_Stack(Stack *s)
{
Stack *temp, *p;
p = s->next;
while(p) {
temp = p->next;          /* 暂存下一个地址，因为如果释放s->next 后，下一个元素的地址就消失了 */
free(p);
p = temp;
}
free(s);
}

/********************************数组的实现************************************/
/*
*     初始化
*/
stack *create_stack(void) {                               /* 返回一个空栈（指针） */
stack *head;
head = (stack *)(malloc(sizeof(stack)));              /* 如果是char类型的字符串，那么还要 *字符串的长度 *******/
if (head == NULL)
printf ("Out of space");                          /* 以上为指定栈的结构 */

head->base = (char *)(malloc(Maxlen*sizeof(char)));   /* 以下为指定栈的数组 ********/
if (head->base == NULL)
printf ("Out of space");
head->top = head->base;                               /* 空栈：栈顶和栈底指向同一单元 *******/
head->size = Maxlen;
return head;
}

/*
*     压栈
*/
void push_stack(stack *s, char a)
{
if (s->top - s->base > s->size) {
printf("Full stack");
return;
}
*s->top++ = a;
}

/*
*     出栈
*/
char pop_stack(stack *s)
{
if (s->top == s->base)
printf("Empty stack");
s->top -=1;
return *s->top;
}

void print_stack(stack *s)
{
char *p;                                       /* 注意打印的时候要用指针变量 p 来控制指针的移动 不能用top 因为它会改变栈的结构 */
p = s->top-1;
while (p - s->base >= 0) {
printf ("%c\n", *p--);
}
}

/*
*     释放栈
*/
void dispose_stack(stack *s)
{
if (s) {
free(s->base);             /* 和分配内存顺序相反，先释放数组，再释放结构体*/
free(s);
}
}