栈相关功能的实现（C语言+C++）

1.顺序栈

能看到栈这里，肯定有可一定的基础了，废话不多说，接下来直接给出顺序栈的基本功能，

1.初始化栈，压栈，出栈，返回栈顶元素，把栈置空，销毁栈，获取栈中当前元素个数。

代码如下：

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define MAX 10//初始分配的栈的容量

#define ADD 10//每次增加的栈的容量

typedef double Datatype;

typedef struct stack
{
	Datatype *base;//栈顶
	Datatype *top;//栈顶
	int len;//分配的栈的空间的大小
}stack,*ppstack;
void Initstack(ppstack ps)//初始化栈
{
	ps->base = (Datatype*)malloc(sizeof(Datatype)*MAX);//开辟空间
	if (!ps->base)//判断是否开辟成功
	{
		return;
	}
	ps->top = ps->base;//头指针与尾指针指向起始地址
	ps->len = MAX;
}
void pushstack(ppstack ps, Datatype e)//压栈
{
	if (ps->top - ps->base >= ps->len)//先判断栈是否满了
	{
		ps->base = realloc(ps->base, sizeof(Datatype)*(ps->len + ADD));
		if (!ps->base)
		{
		/*	error("use realloc");*/
		}
		ps->top = ps->base + ps->len;//top向上指一个
		ps->len += ADD;
	}
	*(ps->top++) = e;
}
void popstack(ppstack ps, Datatype* e)//出栈操作
{
	if (ps->base == ps->top)//判断栈是否为空
		return;
	*e = *(--ps->top);
}
void gettop(ppstack ps, Datatype* e)//返回栈顶元素
{
	if (ps->base == ps->top)
		return;
	*e = *(ps->top - 1);
}
void clearstack(ppstack ps)//把栈置空
{
	ps->top = ps->base;
}
void destorystack(ppstack ps)//销毁栈
{
	free(ps->base);
}
int getlen(stack s)//获得当前栈中元素
{
	return s.top - s.base;
}

部分测试如下：

int main()
{
	int e;
	stack stack;
	Initstack(&stack);
	pushstack(&stack, 1);//压栈测试
	pushstack(&stack, 2);
	pushstack(&stack, 3);
	pushstack(&stack, 4);
	pushstack(&stack, 5);
	int len = getlen(stack); //和获取栈中元素个数的测试
	for (int i = 0; i <len; i++)//出栈
	{
		popstack(&stack, &e);
		printf("%d ", e);
	}
	system("pause");
	return 0;
}

2.栈的链式储存结构

其实很多人说栈的链式储存结构不重要，因为过于复杂麻烦，没有顺序结构的效率高，开始不信，后来仔细想了一下发现确实挺让人恶心的，实用性和栈的顺序储存结构差的远，所以下面就简单给出栈的基本功能压栈和弹栈。

代码如下：

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

typedef int Datatype;

typedef struct stack//栈结点的定义
{
	Datatype data;//栈中的元素
	struct stack *next;//指向下一个栈结点的指针
}stack,*ppstack;

typedef struct coutstack
{
	ppstack top;//栈顶指针
	int count;//栈中结点的计数器
}Coutstack,*coutstack;
void pushstack(coutstack s, Datatype e)
{
	ppstack p = (ppstack)malloc(sizeof(stack));//开辟一个结点
	p->next = s->top;//指向第个压栈的，因为首先开辟的结点为栈低
	s->top = p;//头指针指向第一个结点
	p->data= e;
	s->count++;
}
void popstack(coutstack s, Datatype *e)
{
	ppstack  p;//创建一个结点指针用来存放结点为后面释放做准备
	p = s->top;
	*e = s->top->data;
	s->top = s->top->next;
	s->count--;
	free(p);
}
int main()
{
	int e;
	int len;
	Coutstack stack;
	stack.count = 0;
	pushstack(&stack, 1);
	pushstack(&stack, 2); 
	pushstack(&stack, 3);
	pushstack(&stack, 4);
	pushstack(&stack, 5);
	len = stack.count;
	for (int i = 0; i < len; i++)
	{
		popstack(&stack, &e);
		printf("%d ", e);
	}
	system("pause");
	return 0;
}

C++版本

//************类型萃取********//
struct Truetype
{
	static bool IsPODType()
	{
		return true;
	}
};
struct Falsetype
{
	static bool IsPODType()
	{
		return false;
	}
};

template<class T>
struct TypeTraits
{
	typedef Falsetype PODtype;//处理自定义类型的
};

template<>
struct TypeTraits<int>
{
	typedef Truetype PODtype;
};
template<>
struct TypeTraits<char>
{
	typedef Truetype PODtype;
};
template<>
struct TypeTraits<double>
{
	typedef Truetype PODtype;
};
//************************************//
template<class T>
class Stack
{
public:
	Stack();//构造函数
	void Push(const T& data);//压栈
	void Pop();//弹栈
	T& Top();//返回栈顶元素
	T& Top()const;
	size_t Size()const;
	bool Empty()const;
	~Stack();
private:
	void CheckCapacity();//判满
	T* _array;
	size_t _capacity;//整体容量
	size_t _size;//元素个数
};
template<class T>
Stack<T>::Stack()
:_array(0)
, _capacity(0)
, _size(0){}
template<class T>
Stack<T>::~Stack()
{
	if (Empty())
	{
		delete[] _array;
		_array = NULL;
		_size = 0;
		_capacity = 0;
	}
}
template<class T>
void Stack<T>::Push(const T& data)
{
	if (_capacity == 0)
	{
		_array = new T[5];
		_capacity = 5;
	}
	CheckCapacity();
	_array[_size] = data;
	_size++;
}

template<class T>
void Stack<T>::Pop()
{
	_size--;
}

template<class T>
T& Stack<T>::Top()//返回栈顶元素
{
	return _array[_size-1];
}

template<class T>
T& Stack<T>::Top()const
{
	return _array[_size-1];
}

template<class T>
size_t Stack<T>::Size()const
{
	return _size;
}
template<class T>
bool Stack<T>::Empty()const
{
	if (_array == 0)
		return true;
	else
		return false;
}
template<class T>
void Stack<T>::CheckCapacity()
{
	if (_size == _capacity)
	{
		T *start = _array;
		_array = new T[_capacity + 5];
		if (TypeTraits<T>::PODtype::IsPODType())
		{
			memcpy(_array, start, sizeof(T)*_size);
		}
		else
		{
			for (size_t i = 0; i < _size; i++)
			{
				_array[i] = start[i];
			}
		}
		delete [] start;
		_capacity += 5;
	}
}
int main()
{
	Stack<int> s;
	for (int i = 0; i < 12; i++)
		s.Push(i);
	cout << s.Size() << endl;
	for (int j = 0; j < 11; j++)
	{
		cout << s.Top() << " ";
		s.Pop();
	}
	system("pause");
	return 0;
}