C /C++ 顺序栈

原文

seqStack.h

#include "stdafx.h"

#pragma once //保证头文件被编译一次
//定义函数结果状态代码  
#define TRUE        1  
#define FALSE       0  
#define OK          1  
#define ERROR       0  
#define OVERFLOW    -1  
#define UNDERFLOW   -2  
 
//定义函数返回值类型  
typedef int  Status;  
//定义顺序栈的数据元素的类型  
typedef int  ElemType;
   
//定义顺序栈的存储结构  
#define STACK_INIT_SIZE 100 //初始分配空间大小
#define INCREMENTSIZE   10 //存储空间分配增量  
struct SeqStack{  
    ElemType    *bottom;    //栈底指针  
    ElemType    *top;       //栈顶指针  
    int      size;       //栈存储空间大小  
};
//声明顺序栈的基本操作  
Status  InitStack(SeqStack &s);  
Status  DestroyStack(SeqStack &s);  
Status  ClearStack(SeqStack &s);  
Status  StackEmpty(SeqStack s);  
Status  StackLength(SeqStack s);  
Status  Push(SeqStack &s,ElemType e);  
Status  Pop(SeqStack &s,ElemType &e);  
Status  GetTop(SeqStack s,ElemType &e);  
Status  StackTraverse(SeqStack s);

seqStack.cpp

#include "stdafx.h"
#include "seqStack.h"
#include <iostream>
using namespace std;
 
Status  InitStack(SeqStack &s)  
//操作结果：构造一个空栈S  
{   
    s.bottom=(ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemType));  
    if(s.bottom == NULL){  
        cout<<"严重错误：顺序栈初始存储空间分配失败，程序退出";  
        exit(ERROR);  
    }   
    s.top=s.bottom;
    s.size=STACK_INIT_SIZE;   
    return OK;  
}  
 
Status  DestroyStack(SeqStack &s)  
//初始条件：栈s已存在  
//操作结果：栈s已被销毁  
{  
    free(s.bottom);   
    s.bottom=s.top=NULL;  //s.bottom的值为NULL，表示顺序栈不存在   
    s.size=0;  
    return OK;  
}  
 
Status  ClearStack(SeqStack &s)  
//初始条件：栈s已存在  
//操作结果：将s清为空栈  
{   
    s.top=s.bottom;  //s.top == s.bottom作为顺序栈空的标记  
    return OK;  
}  
 
Status  StackEmpty(SeqStack s)  
//初始条件：栈s已存在  
//操作结果：若栈s为空栈，则返回TRUE，否则FALSE  
{  
    if(s.top == s.bottom)  
        return TRUE;  
    else 
        return FALSE;  
}  
 
Status StackLength(SeqStack s)  
//初始条件：栈s已存在  
//操作结果：返回s的元素个数，即栈的长度  
{  
    return s.top-s.bottom;  
}  
 
Status  Push(SeqStack &s,ElemType e)  
//初始条件：栈s已存在  
//操作结果：插入元素e成为新的栈顶元素  
{       
   if(s.top-s.bottom >= s.size ){   
        s.bottom=(ElemType*)realloc(s.bottom,(s.size+INCREMENTSIZE)*sizeof(ElemType));  
        if(s.bottom == NULL){  
            cout<<"严重错误：顺序栈增量存储空间分配失败，程序退出！";  
            exit(OVERFLOW);  
        }    
        s.top=s.bottom+s.size;   
        s.size+=INCREMENTSIZE;  
    }   
    *s.top=e;
    s.top++;  
    return OK;  
}  
 
Status  Pop(SeqStack &s,ElemType &e)  
//初始条件：栈s已存在且非空  
//操作结果：删除s的栈顶元素，并且用e返回其值  
{  
    if(StackEmpty(s) == TRUE){  
        cout<<"顺序栈为空，出栈失败！"<<endl;  
        exit(UNDERFLOW);  
    }  
    s.top--;
    e=*s.top;  
    return OK;  
}   
 
Status  GetTop(SeqStack s,ElemType &e)  
//初始条件：栈s已存在且非空  
//操作结果：用e返回s的栈顶元素  
{  
    if( StackEmpty(s) == TRUE ){  
        cout<<"访问栈顶元素发生错误：栈为空"<<endl;  
        exit(UNDERFLOW);  
    }   
    return *(s.top-1);  
}  
 
Status  StackTraverse(SeqStack s)  
//初始条件：栈s已存在且非空  
//操作结果：从栈底开始依次输出
{  
    if(s.bottom == NULL){  
        cout<<"严重错误：栈不存在，程序退出！";  
        exit(ERROR);  
    }   
    for(int i=0;i < StackLength(s);i++)   
        cout<<s.bottom[i]<<endl;    
    return OK;  
} 
 

测试用例：

// stack_sequence.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "seqstack.h"   
#include <iostream>
using namespace std;
//获取随机整数  
int RangedRand( int range_min, int range_max)   
{   
   // Generate random numbers in the half-closed interval   
   // [range_min, range_max). In other words,   
   // range_min <= random number < range_max   
   int u =(int)( (double)rand() / (RAND_MAX + 1) * (range_max - range_min)   
            + range_min );    
   return u;   
}   
  

int _tmain(int argc, _TCHAR* argv[])
{
	struct SeqStack s;   
    InitStack(s);     
    ElemType data[10];   
    for(int i=0;i<10;i++){   
        data[i]=RangedRand(-500,500);   
        Push(s,data[i]);   
    }   
  
    StackTraverse(s);   
    cout<<"顺序栈的长度是："<<StackLength(s)<<endl;   
  
    ElemType e;   
    Pop(s,e);   
    cout<<"栈顶元素"<<e<<"出栈"<<endl;   
    cout<<"此时的顺序栈："<<endl;   
    StackTraverse(s);   
    cout<<"顺序栈的长度是："<<StackLength(s)<<endl;   
  
    DestroyStack(s);   
    StackTraverse(s);   
    cout<<"顺序栈的长度是："<<StackLength(s)<<endl;   

	system("pause");
    return 0;   
}