顺序栈实现机制

栈的定义
       ●只允许在一端插入和删除的线性表；
       ●允许插入和删除的一端称为栈顶(top)，另一端称为栈底(bottom)。
栈的特点
   后进先出 (LIFO)

顺序栈使用顺序表的结构实现栈的功能。

error.h

#ifndef __ERROR_H__
#define __ERROR_H__

#include <stdio.h>
#define ERROR         -1
#define FULL_STACK    -2
#define EMPTY_STACK   -3



int errno;     // 错误号

void myError(char *str);

char* myStrError(int num);


#endif // __ERROR_H__

error.c

#include "error.h"

void myError(char *str)
{
	switch (errno)
	{
		case ERROR:
			printf ("%s: 输入参数错误\n", str);
			break;
		case FULL_STACK:
			printf ("%s: 满栈状态\n", str);
			break;
		case EMPTY_STACK:
			printf ("%s: 空栈状态\n", str);
			break;
	}	
}

char* myStrError(int num)
{
	switch (errno)
	{
		case ERROR:
			return "输入参数错误";
		case FULL_STACK:
			return "满栈状态";
		case EMPTY_STACK:
			return "空栈状态";
	}
}

SqStack.h

#ifndef __SQSTACK_H__
#define __SQSTACK_H__

#include "error.h"

#define TRUE  1
#define FALSE 0

#define SIZE 10
typedef int StackData; 
typedef struct _stack
{
	StackData data[SIZE];    // 栈数组
	int  top;                // 栈顶元素下标
}Stack;

// 置空栈
int InitStack (Stack *S); 		

// 判栈是否空栈
int StackEmpty (Stack *S);

// 判栈是否栈满	
int StackFull (Stack *S);  		

// 进栈
int Push (Stack *S, StackData x);	

// 出栈
int Pop (Stack *S, StackData *x); 	

// 取栈顶
int GetTop (Stack *S, StackData *x); 


#endif // __SQSTACK_H__

SqStack.c

#include "SqStack.h"


int InitStack (Stack *S)	
{
	if (S == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	S->top = -1;   
}

// 空返回真，否则返回假
int StackEmpty (Stack *S)
{
	if (S == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	return S->top == -1;
}

// 满返回真，否则返回假
int StackFull (Stack *s)
{
	if (s == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	return s->top == (SIZE-1);
}




int Push (Stack *s, StackData x)
{
	if (s == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	// 判断是否满栈
	if (StackFull(s))
	{
		errno = FULL_STACK;
		return FALSE;
	}
/*
	s->data[top+1] = x;
	s->top++;
*/
	s->data[++s->top] = x;
	return TRUE;
}

int Pop (Stack *s, StackData *x)
{
	if (s == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	// 判断是否空栈
	if (StackEmpty(s))
	{
		errno = EMPTY_STACK;
		return FALSE;
	}
/*	
	*x = s->data[s->top];
	s->top--;
*/
	*x = s->data[s->top--];
	return TRUE;
}

int GetTop (Stack *s, StackData *x)
{
	if (s == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	// 判断是否空栈
	if (StackEmpty(s))
	{
		errno = EMPTY_STACK;
		return FALSE;
	}
	
	*x = s->data[s->top];
	
	return TRUE;
}

main.c

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



int main()
{
	Stack s;
	if (InitStack(&s) == FALSE)
	{
		printf ("初始化失败\n");
		printf ("错误号：%d\n", errno);
		myError("InitStack");
		char * str = myStrError(errno);
		
		printf ("str: %s\n", str);
	}
	
	
	if (StackEmpty(&s))
	{
		printf ("空栈\n");
	}
	
	if (StackFull(&s))
	{
		printf ("满栈\n");
	}
	
	int x;
	if (Pop(&s, &x) != TRUE)
	{
		myError ("Pop 错误");
	}
	
	
	int i;
	for (i = 0; i < 10; i++)
	{
		Push(&s, i);
	}
	
	if (Push(&s, 100) != TRUE)
	{
		myError("压入第11个元素");
	}
	
	char str[100];
	for (i = 0; i < 12; i++)
	{
		if (Pop (&s, &x) != TRUE)
		{
			sprintf (str, "Pop第%d个元素", i);
			myError (str);
		}
		
		printf ("x : %d\n", x);
	}
	
	
	return 0;
}