顺序栈和链式栈的实现与基本运算

---

栈的定义

---

栈是限制在一端进行插入操作和删除的线性表，允许进行操作的一端称之为栈顶，另一端固定为栈底，当栈中没有元素时称为空栈。栈的特点是后进先出（LIFO）。

---

顺序栈

---

---

1.顺序栈的描述

---

typedef int datatype;         //定义栈的数据元素的数据类型
typedef struct
{
	datatype* data;         //用指针指向栈的存储空间
	int maxlen;             //当前栈的最大元素个数
	int top;                //指示栈顶位置（数组下标）的变量
}sqstack;                   // 顺序栈的类型定义

---

2.顺序栈的基本运算

---

顺序栈它是顺序表的一种，具有顺序表同样的存储结构，由数组定义，配合用数组下标表示的栈顶指针top(相对指针)完成各种操作。

1.顺序栈的创建
算法思路：

代码实现;

sqstack* stack_create(int len)
{
	sqstack* S;
	S = (sqstack*)malloc(sizeof(sqstack));
	if(NULL == S)
	{
		printf("malloc failed\n");
		return NULL;
	}
	S->data = (datatype*)malloc(len*sizeof(datatype));
	if(NULL == S->data)
	{
		printf("malloc failed\n");
		return NULL;
	}
	S->maxlen = len;
	S->top = -1;

	return NULL;
}

2.判断顺序栈是否为空

int stack_empty(sqstack* S)
{
	return (S->top == -1?1:0);
}

3.判断顺序栈是否为满

int stack_full(sqstack* S)
{
	return (S->top == S->maxlen-1?1:0);
}

4.清空栈

void stack_clear(sqstack* S)
{
	S->top = -1;
}

5.压栈

算法思路：先赋值，指针在栈顶移动

实现代码：

int stack_push(sqstack* S,datatype value)
{
	if(S->top == S->maxlen-1)
	{
		printf("stack full\n");
		return -1;
	}
	S->data[S->top+1] = value;
	S->top ++;
	return 1;
}

6.弹栈
算法思路：指针先往栈底移动，再读取数据
实现代码：

datatype stack_pop(sqstack* S)
{
	S->top --;
	return S->data[S->top+1];
}

7.取出栈顶的数据

datatype stack_top(sqstack* S)
{
	return (S->data[S->top]);
}

8.释放栈使用的内存

void stack_free(sqstack* S)
{
	free(S->data);
	S->data = NULL;
	free(S);
	S = NULL;
}

---

链式栈

---

---

1.链式栈的描述

---

typedef int datatype;
typedef struct node
{
	datatype data;
	struct node* next;
}listnode,*linklist;

---

2.链式栈的基本运算

---

1.链式栈的创建
算法思路：

实现代码：

linklist linkstack_create()
{
	linklist s = (linklist)malloc(sizeof(listnode));
	if(NULL == s)
	{
		printf("malloc failed\n");
		return NULL;
	}
	s->next = NULL;
	return s;
}

2.判断链式栈是否为空

int linkstack_empty(linklist s)
{
	return (s->next == NULL?1:0);
}

3.链式栈的压栈

算法思路：类似于单链表的头插入法

代码实现：

int linkstack_push(linklist s,datatype value)
{
	linklist p = (linklist)malloc(sizeof(listnode));
	if(NULL == p)
	{
		printf("malloc failed\n");
		return -1;
	}
	p->data = value;
	p->next = s->next;
	s->next = p;
	return 0;
}

4.链式栈的弹栈
算法思路：类似单链表删除结点

代码实现：

datatype liststack_pop(linklist s)
{
	linklist p;
	datatype ret;
	p = s->next;
	s->next = p->next;
	ret = p->data;
	free (p);
	p = NULL;
	return ret ;
}

5.取链式栈顶的元素
代码实现：

datatype liststack_top(linklist s)
{
	return (s->next->data);
}

6.链式栈的清空

算法思路：类似于弹栈（原理这里不再累赘），每删除一个结点就free（）。

代码实现：

void linkstack_clear(linklist s)
{
	linklist p;
	p = s->next;
	while(p)
	{
		s->next = p->next;
		free(p);
		p = s->next;
	}
	puts("");
}

6.链式栈的内存释放
算法思路：类似于单链表的遍历，每遍历一个结点就free(),直到P==NULL。

代码实现：

void linkstack_free(linklist s)
{
	linklist p;
	p = s;
	while(p)
	{
		s = s->next ;
		printf("%d\n",p->data);   //打印被free掉内存空间里的数据
		free(p);
		p = s;
	}
	puts("");
}