栈类 - 链式存储

代码：

// linkstack.hpp
// 栈类

#pragma once

#include "linklist.hpp"

template <typename T>
class LinkStack
{
public:
	LinkStack();
	~LinkStack();
public:
	int clear();
	int push(T &t);
	int pop(T &t);
	int top(T &t);
	int size();
protected:
	LinkList<T> *m_list;
};

template <typename T>
LinkStack<T>::LinkStack()
{
	m_list = new LinkList < T > ;
}

template <typename T>
LinkStack<T>::~LinkStack()
{
	clear();
	delete m_list;
	m_list = NULL;
}

template <typename T>
int LinkStack<T>::clear()
{
	T t;
	while (m_list->getLen() > 0) {
		m_list->del(0, t);
	}

	return 0;
}

template <typename T>
int LinkStack<T>::push(T &t)
{
	return m_list->insert(t, 0);
}

template <typename T>
int LinkStack<T>::pop(T &t)
{
	return m_list->del(0, t);
}

template <typename T>
int LinkStack<T>::top(T &t)
{
	return m_list->get(0, t);
}

template <typename T>
int LinkStack<T>::size()
{
	return m_list->getLen();
}

// main.cpp
// 链式存储栈类的测试程序

#include <iostream>
#include <cstdio>
#include "linkstack.hpp"

using namespace std;

struct Student
{
	char name[32];
	int age;
};

void play()
{
	Student s1, s2, s3;
	s1.age = 21;
	s2.age = 22;
	s3.age = 23;

	LinkStack<Student> ls; // 创建栈

	// 入栈
	ls.push(s1);
	ls.push(s2);
	ls.push(s3);

	// 获取栈顶元素
	Student tmp;
	ls.top(tmp);
	cout << "top of stack: " << tmp.age << endl;
	cout << "size of stack: " << ls.size() << endl;

	// 出栈
	while (ls.size() > 0) {
		ls.pop(tmp);
	}

	ls.clear();

}

int main()
{
	play();

	return 0;
}

有关链表类的设计与实现请参看我的另两篇文章：C++链表模板类，线性表链式存储设计与实现 - API实现

// linklist.h
// 链表类

#pragma once

#include <iostream>
#include <cstdio>
using namespace std;

template <typename T>
struct Node
{
	T t;
	Node<T> *next;
};

template <typename T>
class LinkList
{
public:
	LinkList();
	~LinkList();

public:
	int clear();
	int insert(T &t, int pos);
	int get(int pos, T &t);
	int del(int pos, T &t);
	int getLen();

protected:
	Node<T> *header;
	int length;
};

template <typename T>
LinkList<T>::LinkList()
{
	header = new Node < T > ;
	header->next = NULL;
	length = 0;
}

template <typename T>
LinkList<T>::~LinkList()
{
	Node<T> *tmp = NULL;

	while (header) {
		tmp = header->next;
		delete header;
		header = tmp;
	}
}

template <typename T>
int LinkList<T>::clear()
{
	~LinkList();
	LinkList();
	return 0;
}

template <typename T>
int LinkList<T>::insert(T &t, int pos)
{
	Node<T> *cur = NULL;

	// 对pos的容错处理
	if (pos >= length) {
		pos = length;
	}

	cur = header;
	for (int i = 0; i < pos; ++i) {
		cur = cur->next;
	}

	// 把上层应用的t结点缓存到容器中
	Node<T> *node = new Node < T > ;
	node->next = NULL;
	node->t = t; // 把t缓存到容器中

	node->next = cur->next;
	cur->next = node;

	++length;

	return 0;
}

template <typename T>
int LinkList<T>::get(int pos, T &t)
{
	Node<T> *cur = NULL;

	if (pos >= length) {
		return -1;
	}

	cur = header;
	for (int i = 0; i < pos; ++i) {
		cur = cur->next;
	}

	t = cur->next->t; // 把pos位置的结点赋值给t

	return 0;
}

template <typename T>
int LinkList<T>::del(int pos, T &t)
{
	Node<T> *cur = NULL;

	if (pos >= length) {
		return -1;
	}

	cur = header;
	for (int i = 0; i < pos; ++i) {
		cur = cur->next;
	}
	Node<T> *ret = NULL;
	ret = cur->next;
	t = ret->t; // 把缓存的结点给上层应用t

	// 删除操作
	cur->next = ret->next;
	--length;
	delete ret; // 注意释放内存，因为insert的时候new Node<T>

	return 0;
}

template <typename T>
int LinkList<T>::getLen()
{
	return length;
}

版权声明：本文为博主原创文章，未经博主允许不得转载。