顺序栈的实现

1.SeqStack.h头文件

#pragma once
#define Capaciti 20		
#define CapIncres  2

#define OK  1
#define ERROR  0
#define OVERFLOW_1  -1
#define NULLPTR  -2

typedef  int ElemType;
typedef  int Status;


typedef struct _Stack {
	int Capicity;
	ElemType* top;
	ElemType* bottem;
}Stack;

Status InitStack(Stack* s);

void ClearStack(Stack* s);

void Destory(Stack* s);

bool is_Empty(Stack* s);

bool is_Full(Stack* s);

Status Cap_Increas(Stack* s);

Status Pushval(Stack* s, ElemType val);

void 	Print_Stack(Stack* s);

Status GetTop(const Stack* s, ElemType* pElem);

Status PopVal(Stack* s, ElemType* pElem);

int GetStack_Len(Stack* s);

2.SeqStack.cpp源文件

#include"SeqStack.h"
#include<assert.h>
#include<iostream>
using namespace std;


Status InitStack(Stack* s) {
	assert(s != NULL);
	s->bottem = (ElemType*)malloc(Capaciti *sizeof(ElemType));
	if (s->bottem == NULL) return OVERFLOW;
	s->Capicity = Capaciti;
	s->top = s->bottem;	 
	return OK;
}

void ClearStack(Stack* s) {
	assert(s != NULL);
	s->top = s->bottem;
}

void Destory(Stack* s) {
	assert(s != NULL);
	free(s->bottem);
	s->bottem = NULL;
	s->top = NULL;
	s->Capicity = 0;
}

bool is_Empty(Stack* s) {
	assert(s != NULL);
	return s->top == s->bottem;
}

bool is_Full(Stack* s) {
	assert(s != NULL);
	return s->Capicity == (s->top - s->bottem);
}

Status Cap_Increas(Stack* s) {
	assert(s != NULL);
	int newsize = s->Capicity * CapIncres;
	ElemType* newdata = (ElemType*)realloc(s->bottem, sizeof(ElemType)*newsize);
	if (newdata == NULL) return OVERFLOW_1;
	s->bottem = newdata;
	s->top = s->bottem + s->Capicity;
	s->Capicity = newsize;
	return true;
}

Status Pushval(Stack* s, ElemType val) {
	assert(s != NULL);
	if (is_Full(s)&&!Cap_Increas(s)) return ERROR;
	*(s->top) = val;
	s->top++;
	return OK;
}

void 	Print_Stack(Stack* s) {
	assert(s != NULL);
	ElemType* p = s->bottem;
	while (p!= s->top) {
		cout << *p << "	";
		p++;
	}
	cout << endl;
}

Status GetTop( Stack* s, ElemType* pElem) {
	assert(s != NULL);
	if (is_Empty(s)) {
		return NULLPTR;
	}
	*pElem = *(s->top - 1);
	return OK;
}

Status PopVal(Stack* s, ElemType* pElem) {
	assert(s != NULL);
	if (is_Empty(s)) {
		return  ERROR;
	}
	s->top--;
	*pElem = *s->top;
	return OK;
}

int GetStack_Len(Stack* s) {
	assert(s != NULL);
	return s->top - s->bottem;
}

3.testStack.cpp源文件

#include"SeqStack.h"
#include<iostream>
using namespace std;
int main() {
	Stack s;
	InitStack(&s);
	for (int i = 0; i < 30; i++) {
		Pushval(&s, i + 1);
	}
	Print_Stack(&s);
}