c和c++实现数据结构栈

C语言实现数据结构栈

c语言实现顺序栈完整可运行代码

#include <stdio.h>
#include <malloc.h>
#define OK 1
#define ERROR 0
#define MAXSIZE 5
typedef int status;
typedef int ElemType;
typedef struct
{
	ElemType data[MAXSIZE];
	int top;
}SqStack;

// 初始化栈
void InitStack(SqStack* s)
{
	s->top = -1;
}

// s元素入栈
status push(SqStack* s, ElemType e)
{
	if (s->top >= MAXSIZE - 1)
		return ERROR;
	else
	{
		s->data[++s->top] = e;

		return OK;
	}
}

// 栈顶元素出栈
status pop(SqStack* s)
{
	if (s->top <= -1)
		return ERROR;
	{
		s->top--;
		return OK;
	}
}

// 获取栈顶元素
ElemType GetTop(SqStack* s, ElemType* e)
{
	if (s->top <= -1)
		return -1;

	*e = s->data[s->top];

	return *e;
}

// 输出栈中元素个数
int length(SqStack* s)
{
	return s->top + 1;
}


int main()
{
	SqStack* s;
	InitStack(s);
	
	for (int i = 0; i < 5; i++)
		push(s, i);
	
	printf("入栈完成后元素个数： %d\n", length(s));

	ElemType topValue;
	for (int i = 0; i < 5; i++) {	
		printf("此时栈顶元素 = %d\n", GetTop(s, &topValue));
		// 栈顶元素出栈
		pop(s);
	}
	printf("出栈完成后元素个数:  %d\n", length(s));
	return 0;
}

c语言实现链式栈完整可运行代码

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

#define OK 1
#define ERROR 0

typedef int status;
typedef int ElemType;
// 链式栈元素结构
typedef struct StackNode
{
	ElemType value;
	// 指向下一个元素
	struct StackNode* next;
}StackNode,*LinkStack;
// 这里的LinkStack是一个结构体指针变量

// 初始化栈
LinkStack Init()
{
	LinkStack ret = (StackNode*)malloc(sizeof(StackNode));
	if (ret) {
		ret->next = NULL;
	} else
	{
		ret = NULL;
	}
	return ret;
}

// 向栈中加入元素e

status push(LinkStack s, ElemType e)
{
	// 从堆空间申请一个栈结点
	StackNode* node = (StackNode*)malloc(sizeof(StackNode));
	if (node != NULL) {
		
		node->value = e;
		node->next = s->next;
		s->next = node;
		
		return OK;
	} else {
		printf("申请空间出错！！！\n");
		return ERROR;
	}
}

status pop(LinkStack s)
{
	if (!s->next)
		return ERROR;
	else
	{
		StackNode* toDel = s->next;
		s->next = toDel->next;
		
		// 释放栈结点
		free(toDel);
		// 置NULL
		toDel = NULL;
		return OK;
	}
}

// 获取栈顶元素
ElemType getTop(LinkStack s, ElemType* e)
{
	if (!s->next) 
		return ERROR;
	else
	{
		*e = s->next->value;
		return OK;
	}
}

int main()
{
	LinkStack s = Init();
	// 向栈中加入元素
	for (int i = 0; i < 5; i++)
		push(s, i);
	
	ElemType e;
	
	for (int i = 0; i < 5; i++) {
		// 获取栈顶元素
		getTop(s, &e);
		// 输出栈顶元素
		printf ("%d\n", e);
		// 栈顶元素出栈
		pop(s);
	}
	return 0;
}

c++实现数据结构栈

c++实现顺序栈完整可运行代码

#include <iostream>
using namespace std;

template <typename T, int N>
class Stack
{
private:
	T m_space[N];
	int m_top;
public:
	Stack() {
		m_top = -1;
    }

	bool push(const T& e) {
		if (m_top >= N - 1)
			return false;
		else
		{
			m_space[++m_top] = e;
			return true;
		}
	}

	bool pop() {
		if (m_top < 0)
			return false;
		else
		{
			m_top--;
			return true;
		}
	}

	T getTop() {
		T ret = -1;
		if (m_top >= 0) {
			ret = m_space[m_top];
		}
		return ret;
	}
	
	void clear() {
		m_top = -1;
	}
	
	// 栈当前元素个数
	int size() const{
		return m_top + 1;
	}

	// 栈可容纳元素个数
	int capacity() const
	{
		return N;
	}
};


int main()
{
	Stack<int, 5> s;
	for (int i = 0; i < s.capacity(); i++)
		s.push(i);
	
	cout << "s.size() = " << s.size() << endl;
	
	for (int i = 0; i < s.capacity(); i++)
	{
		// 打印栈顶元素
		cout << s.getTop() << endl;
		// 栈顶元素出栈
		s.pop();
	}
	
	cout << "s.size() = " << s.size() << endl;

	return 0;
}

C++实现链式栈完整可运行代码

#include <iostream>
using namespace std;

// 栈中元素结点数据结构
template <typename T>
struct StackNode
{
	T value;
	StackNode<T>* next;
	StackNode() {}
	StackNode(const T& val, StackNode<T>* theNext) : value(val),next(theNext) {}
};

template <typename T>
class Stack
{
private:
	// 栈顶指针
	StackNode<T>* m_stackTop;
	// 栈中元素个数
	int m_size;
public:
	Stack() {
		m_stackTop = NULL;
		m_size = 0;
	}

	void push(const T&e) {
		m_stackTop = new StackNode<T>(e, m_stackTop);
		m_size++;
	}

	bool pop() {
		if (isEmpty()) {
			return false;
		}
		// 删除栈顶结点
		StackNode<T>* nextNode = m_stackTop->next;
		delete m_stackTop;
		m_stackTop = nextNode;
		m_size--;
		return true;
	}

	T getTop() {
		if (isEmpty()) {
			cout << "此时栈为空。。。" << endl;
			return -1;
		} else {
			return m_stackTop->value;
		}
	}

	int size() const {
		return m_size;
	}

	bool isEmpty() {
		return m_size == 0;
	}

	~Stack() {
		while (m_stackTop != NULL) {
			// 删除栈顶结点
			StackNode<T>* nextNode = m_stackTop->next;
			delete m_stackTop;
			m_stackTop = nextNode;
			m_size--;
		}
	}

};

int main()
{
	Stack<int> s;
	for (int i = 0; i < 10; i++)
		s.push(i);

	cout << "入栈元素个数为： " << s.size() << endl;
	for (int i = 0; i < 10; i++) {
		cout << "此时栈顶元素为: " << s.getTop() << endl;
		s.pop();
	}
	cout << "全部出栈后元素个数为： " << s.size() << endl;

	return 0;
}

参考资料：
大话数据结构 c语言版
数据结构、算法与应用 c++语言描述