数组和链表实现Stack

数组的实现

1. 需要先开辟一定的理论空间capacity的数组
2. 当实际空间size大于理论空间capacity时，需要重新分配空间大小
3. 通过size来指向栈顶
4. 压栈就是将新的数值放在size处，然后size++
5. 出栈就是将size处的数值返还，size--

//ArrayStack.h

#pragma once
//栈的两种实现方法之数组实现

template <typename T>
class ArrayStack
{
public:
	ArrayStack(int cap);
	~ArrayStack();

	T top();//获取栈顶元素
	T pop();//弹栈
	void push(T data);//压栈
	bool isEmpty();//判断是否为空栈
	int getSize();//计算大小

private:
	int size;// 当前栈中存储的元素大小
	int capacity;//栈的容量
	T *arr;//实现
 };

template <typename T>
ArrayStack<T>::ArrayStack(int cap)
	:size(0), capacity(cap), arr(nullptr)
{
	arr = new T[capacity];
	memset(arr, 0, sizeof(T) * capacity);
}

template <typename T>
ArrayStack<T>::~ArrayStack()
{
	if (arr != nullptr)
	{
		delete []arr;
		arr = nullptr;
	}
}

template<typename T>
T ArrayStack<T>::top()
{
	return arr[--size];
}

template<typename T>
T ArrayStack<T>::pop()
{
	//不为null则可以弹栈
	if(!isEmpty())
		return arr[size--];
}

template<typename T>
void ArrayStack<T>::push(T data)
{
	//实际存储和理论的相同时需要重新分配空间
	if (size == capacity)
	{
		capacity = capacity << 2;
		//分配并赋值
		T *tmp = new T[capacity];
		memset(tmp, 0, sizeof(T) * capacity);
		memcpy(tmp, arr, sizeof(T) * size);

		delete []arr;
		arr = nullptr;
		arr = tmp;
	}
	arr[size++] = data;
}

template<typename T>
bool ArrayStack<T>::isEmpty()
{
	return (size == 0);
}

template<typename T>
int ArrayStack<T>::getSize()
{
	return size;
}

链表的实现

1. 链表的实现需要首先创建一个哨兵节点，即pHead=null，该处设为pTop，pTop一直指向头
2. 压栈相当于链表的头插法，每次都分配空间，然后将新的数值插在pTop的后面，size++
3. 出栈就是将pTop指向的下一个有数值的点弹出，size--

//ListStack.h

#pragma once
//栈的两种实现方法之链表实现
template <typename T>
struct Node
{
	T value;
	Node<T> *next;

	Node<T>()
	{
		value = 0;
		next = nullptr;
	}

	Node(T data):value(data)
	{
		next = nullptr;
	}
};

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

	T top();//获取栈顶元素
	T pop();//弹栈
	void push(T data);//压栈
	bool isEmpty();//判断是否为空栈
	int getSize();//计算大小

private:
	int size;// 当前栈中存储的元素大小
	Node<T> *pTop;//实现
};

template <typename T>
ListStack<T>::ListStack()
{
	pTop = new Node<T>();
	size = 0;
}

template <typename T>
ListStack<T>::~ListStack()
{
	while (pTop->next != nullptr)
	{
		Node<T>* pDel = pTop->next;
		pTop->next = pTop->next->next;
		delete pDel;
	}
	pTop = nullptr;
}

template<typename T>
T ListStack<T>::top()
{
	return pTop->next->value;
}

//从链表头部删除
template<typename T>
T ListStack<T>::pop()
{
	//非空才可以删除
	if (!isEmpty())
	{
		Node<T> *pDel = pTop->next;
		pTop->next = pDel->next;

		int val = pDel->value;
		delete pDel;
		pDel = nullptr;
		size--;
		return val;
	}
}

//类似于链表的头插法
template<typename T>
void ListStack<T>::push(T data)
{
	Node<T> *pTmp = new Node<T>(data);
	pTmp->next = pTop->next;
	pTop->next = pTmp;
	size++;
}

template<typename T>
bool ListStack<T>::isEmpty()
{
	return size == 0;
}

template<typename T>
int ListStack<T>::getSize()
{
	return size;
}

#include <iostream>
//#include "ArrayStack.h"
#include "ListStack.h"
using namespace std;

int main()
{
	//ArrayStack<int> myStack(3);
	ListStack<int> myStack;
	for (int i = 0; i < 5; i++)
		myStack.push(i);

	cout << "栈的大小:" << myStack.getSize() << endl;
	cout << "栈是否为空:" << myStack.isEmpty() << endl;
	cout << "栈顶元素：" << myStack.top() << endl;
	cout << "依次出栈:" << endl;
	while (!myStack.isEmpty())
	{
		cout << myStack.pop() << endl;
	}

	system("pause");
}