【数据结构】栈

数据结构定义头文件common.h

#ifndef __HI_COMM_H__
#define __HI_COMM_H__


#include <stdlib.h>
#include <stdio.h>
#include <malloc.h>
#include <string>

#define LIST_INIT_SIZE 100  /*线性表存储空间的初始分配量；*/
#define LIST_INCREMENT 10   /*线性表存储空间的分配增量；*/
#define ElemType int
//#define NULL (void*)0

/*线性表的顺序存储结构*/
typedef struct{
	ElemType *elem;  //线性表的基地址
	int length;      //当前长度
	int MaxSize;    //当前分配的存储容量
}SqList;

/*线性表的链式存储结构*/
typedef struct frankLNode
{
	ElemType data;
	struct frankLNode* next; 
}LNode;   //


/*栈的顺序存储结构*/
typedef struct 
{
	ElemType* base;
	ElemType* top;
	int StackSize;
}FStack;
#define STACK_INIT_SIZE 100  /*栈存储空间的初始分配量；*/
#define STACK_INCREMENT 10   /*栈存储空间的分配增量；*/


/*队列的顺序存储结构*/
typedef struct frankQNode
{
	ElemType data;
	struct frankQNode *next;
}QNode;

typedef struct frankQueueHeader
{
	QNode* front;
	QNode* rear;
}QueueHeader;

/*二叉树的存储结构*/

typedef struct frankBinTreeNode
{
	ElemType data;
	struct frankBinTreeNode *left;
	struct frankBinTreeNode *right;
}BinTreeNode;
typedef BinTreeNode* pBinTreeNode;


#endif

栈的头文件QStack.h

#pragma once
#include "common.h"

class QStack
{
public:
	QStack(void);
	~QStack(void);

	void InitStack(FStack &S);

	void DestroyStack(FStack &S);

	void ClearStack(FStack &S);

	bool isStackEmpty(FStack &S);

	int getStackLength(FStack &S);

	ElemType* GetTop(FStack &S);

	//取出栈顶元素
	ElemType Pop(FStack &S);

	//栈顶插入元素
	void Push(FStack &S,ElemType e);

	//栈顶插入元素
	void AgainMalloc(FStack &S);

};

#include "QStack.h"


QStack::QStack(void)
{
}


QStack::~QStack(void)
{
}

void QStack::InitStack(FStack &S)
{
	S.base = (ElemType*)malloc(sizeof(ElemType)*STACK_INIT_SIZE);
	if (!S.base)
	{
		exit(1);
	}
	S.top = S.base ;
	S.StackSize = STACK_INIT_SIZE;
}

void QStack::DestroyStack(FStack &S)
{
	if (!S.base)
	{
		exit(1);
	}
	free(S.base);
	S.base = NULL;
	S.top = NULL;
	S.StackSize = 0;
}

void QStack::ClearStack(FStack &S)
{	
	if (!S.base)
	{
		exit(1);
	}
	S.top = S.base ;
}

bool QStack::isStackEmpty(FStack &S)
{
	if (!S.base)
	{
		exit(1);
	}
	if (S.base == S.top)
	{
		return true;
	}
	else
	{
		return false;
	}
}

int QStack::getStackLength(FStack &S)
{
	int i = 0;
	//while (S.base != S.top)
	//{
	//	S.top --;
	//	i++;
	//}
	i = S.top - S.base;
	return i;
}

ElemType* QStack::GetTop(FStack &S)
{
	if (!S.base && isStackEmpty(S))
	{
		exit(1);
	}
	return S.top-1;
}

//取出栈顶元素
ElemType QStack::Pop(FStack &S)
{
	if (S.base == S.top)
	{
		exit(1);
	}
	ElemType x = *(S.top-1);
	S.top--;
	return x;
}


//栈顶插入元素
void QStack::Push(FStack &S,ElemType e)
{
	if (getStackLength(S) == S.StackSize)
	{
		AgainMalloc(S);
	}
	*(S.top) = e;
	S.top ++;
}

//栈顶插入元素
void QStack::AgainMalloc(FStack &S)
{
	S.StackSize += STACK_INCREMENT;
	S.base = (ElemType *)realloc(S.base,S.StackSize * sizeof(ElemType));
}

测试函数

void TEST_QStack()
{
	printf("-----------------------------------------------------n");
	printf("-------Here is A Test For QStack---------------------n");
	QStack qSTACK;
	FStack S;

	qSTACK.InitStack(S);
	for (int i = 0;i<10;i++)
	{
		qSTACK.Push(S,i);
	}
	
	for (int i = 0;i<10;i++)
	{
		printf("%d  ",qSTACK.Pop(S));
	}

}