【数据结构】 栈的基本操作

/*
===============================================================================================
栈的基本操作
By~fanxingzju			2014-04-14
1.构造一个空栈Stack
2.销毁栈Stack
3.把Stack置为空栈
4.若栈Stack为空栈，则返回true，否则返回false
5.用length返回栈中元素的个数，即栈的长度
6.若栈不为空，则用elem返回Stack的栈顶元素，并返回true，否则返回false
7.向栈顶压入值为elem为新元素
8.若栈不为空，则删除S的栈顶元素，用elem返回其值，并返回true，否则返回false

===============================================================================================
说明：
1.我在大部分函数前添加了 “if (NULL == Stack.base)”的条件判断，但正常使用时，这段代码不是必须的，可以删除
2.在Push操作时，对于栈满的情况，进行了追加内存的操作。为了保证堆栈的顺序，引入了中间堆栈tempStack
*/
#include <stdio.h>
#include <stdlib.h>

#define STACK_MAX_SIZE 10
#define STACK_INCREMENT 3
#define SElemType int

typedef struct SqStack
{
SElemType *base;
SElemType *top;
int stacksize;
}SqStack;

//1.构造一个空栈Stack
bool InitStack(SqStack &Stack)
{
Stack.base = new SElemType[STACK_MAX_SIZE];
if (!Stack.base)
{
printf("InitStack()函数运行，内存分配失败\n");
system("pause");
exit(-1);
}
Stack.top = Stack.base;
Stack.stacksize = STACK_MAX_SIZE;
printf("InitStack()函数执行，空栈构造成功\n");
return true;
}

//2.销毁栈Stack
bool DestoyStack(SqStack &Stack)
{
Stack.top = Stack.base;
delete[] Stack.base;
Stack.base = NULL;
Stack.top = NULL;
printf("DestoryStack()函数执行，栈销毁成功\n");
return true;
}

//3.把Stack置为空栈
bool ClearStack(SqStack &Stack)
{
if (NULL == Stack.base)
{
printf("ClearStack()函数执行，栈不存在，无法清空\n");
return false;
}
Stack.top = Stack.base;
printf("ClearStack()函数执行，栈清空成功\n");
return true;
}

//4.若栈Stack为空栈，则返回true，否则返回false
bool StackEmpty(SqStack Stack)
{
if (NULL == Stack.base)
{
printf("StackEmpty()函数执行，栈不存在！！\n");
system("pause");
exit(-1);
}
if (Stack.top == Stack.base)
{
printf("StackEmpty()函数执行，栈为空栈\n");
return true;
}
printf("StackEmpty()函数执行，栈不为空\n");
return false;
}

//5.返回栈中元素的个数，即栈的长度
bool StackLength(SqStack Stack, int &length)
{
if (NULL == Stack.base)
{
printf("StackLength()函数执行，栈不存在，返回长度失败\n");
return false;
}
length = Stack.top - Stack.base;
printf("Stacklength()函数执行，栈的长度为 %d \n", length);
return true;
}

//6.若栈不为空，则用elem返回Stack的栈顶元素，并返回true，否则返回false
bool GetTopStack(SqStack Stack, SElemType &elem)
{
if (NULL == Stack.base)
{
printf("GetTop()函数执行，栈不存在，获取栈顶元素失败\n");
return false;
}
if (Stack.base == Stack.top)
{
printf("GetTop()函数执行，栈为空，获取栈顶元素失败\n");
return false;
}
elem = *(Stack.top - 1);
printf("GetTop()函数执行，栈顶元素为： %d \n", elem);
return true;
}

//7.7.向栈顶压入值为elem为新元素
bool PushStack(SqStack &Stack, SElemType elem)
{
if (NULL == Stack.base)
{
printf("PushStack()函数执行，栈不存在，向栈顶压入元素失败\n");
system("pause");
exit(-1);
}
if (Stack.top - Stack.base >= Stack.stacksize)
{
printf("PushStack()函数执行，原始栈已满，重新给栈分配更大的空间\n");
SqStack tempStack, newStack;
tempStack.base = new SElemType[Stack.stacksize];
newStack.base = new SElemType[Stack.stacksize + STACK_INCREMENT];
if ((!tempStack.base)||(!newStack.base))
{
printf("PushStack()函数运行，内存分配失败\n");
system("pause");
exit(-1);
}
tempStack.top = tempStack.base;
tempStack.stacksize = Stack.stacksize;
newStack.top = newStack.base;
newStack.stacksize = Stack.stacksize + STACK_INCREMENT;
while(Stack.top != Stack.base)
{
SElemType temp = *--Stack.top;
*tempStack.top++ = temp;
}
while(tempStack.top != tempStack.base)
{
SElemType temp = *--tempStack.top;
*newStack.top++ = temp;
}
delete[] Stack.base;
delete[] tempStack.base;
Stack = newStack;
}

*Stack.top++ = elem;
printf("PushStack()函数执行，元素 %d 压入栈顶成功\n", elem);
return true;
}

//8.若栈不为空，则删除S的栈顶元素，用elem返回其值，并返回true，否则返回false
bool PopStack(SqStack &Stack, SElemType &elem)
{
if (NULL == Stack.base)
{
printf("PopStack()函数执行，栈不存在，弹出栈顶元素失败\n");
system("pause");
exit(-1);
}
if (Stack.base == Stack.top)
{
printf("PopStack()函数执行，栈为空，弹出栈顶元素失败\n");
return false;
}
elem = *--Stack.top;
printf("PopStack()函数执行，弹出栈顶元素成功，栈顶的元素为： %d \n", elem);
return true;
}

int main()
{
SqStack Stack;
InitStack(Stack);

for (int i = 0; i != 30; ++i)
{
PushStack(Stack, i);
}
StackEmpty(Stack);

int length = 0;
StackLength(Stack, length);

SElemType elem;
GetTopStack(Stack, elem);

while(PopStack(Stack, elem))
{
//printf("PopStack()函数执行，弹出栈顶元素成功，栈顶的元素为： %d \n", elem);
}

ClearStack(Stack);
DestoyStack(Stack);

system("pause");
return 0;
}