C++数据结构——栈
前言
最近计划再复习一遍数据结构,看到一篇博客:https://www.cnblogs.com/QG-whz/p/5170418.html#_label0。
1. 栈的简介
1.1栈(Stack)是一种线性存储结构,它具有如下特点:
(1)栈中的数据元素遵守“先进后出"(First In Last Out)的原则,简称FILO结构。
(2)限定只能在栈顶进行插入和删除操作。
1.2、栈的相关概念:
(1)栈顶与栈底:允许元素插入与删除的一端称为栈顶,另一端称为栈底。
(2)压栈:栈的插入操作,叫做进栈,也称压栈、入栈。
(3)弹栈:栈的删除操作,也叫做出栈。
1.3、栈的常用操作为:
(1)弹栈,通常命名为pop
(2)压栈,通常命名为push
(3)求栈的大小
(4)判断栈是否为空
(5)获取栈顶元素的值
1.4、栈的常见分类:
(1)基于数组的栈——以数组为底层数据结构时,通常以数组头为栈底,数组头到数组尾为栈顶的生长方向
(2)基于单链表的栈——以链表为底层的数据结构时,以链表头为栈顶,便于节点的插入与删除,压栈产生的新节点将一直出现在链表的头部
2. 基于数组的栈实现
当以数组为底层数据结构时,通常以数组头为栈底,数组头到数组尾为栈顶的生长方向:
2.1 栈的抽象数据类型
栈提供了如上所述操作的相应接口。
template<typename T>
class ArrayStack
{
public:
ArrayStack(int s = 10); //默认的栈容量为10
~ArrayStack();
public:
T top(); //获取栈顶元素
void push(T t); //压栈操作
T pop(); //弹栈操作
bool isEmpty(); //判空操作
int size(); //求栈的大小
private:
int count; //栈的元素数量
int capacity; //栈的容量
T * array; //底层为数组
};
count 为栈的元素数量,capacity为栈的容量,count<=capacity,当栈满的时候,count = capacity。
本实现中不支持栈的动态扩容,栈满的时候无法再插入元素。栈的容量在定义栈的时候就需要指定,默认的栈容量为10。
2.2 栈的具体实现
栈的实现还是相对简单的,很容易理解。这里就不再画蛇添足了。
/*栈的判空操作*/
template <typename T>
bool ArrayStack<T>::isEmpty()
{
return count == 0; //栈元素为0时为栈空
};
/*返回栈的大小*/
template <typename T>
int ArrayStack<T>::size()
{
return count;
};
/*插入元素*/
template <typename T>
void ArrayStack<T>::push(T t)
{
if (count != capacity) //先判断是否栈满
{
array[count++] = t;
}
};
/*弹栈*/
template <typename T>
T ArrayStack<T>::pop()
{
if (count != 0) //先判断是否是空栈
{
return array[--count];
}
};
/*获取栈顶元素*/
template <typename T>
T ArrayStack<T>::top()
{
if (count != 0)
{
return array[count - 1];
}
};
2.3 栈的代码测试
int _tmain(int argc, _TCHAR* argv[])
{
ArrayStack <int> p(5);
for (int i = 0; i < 5; i++)
{
p.push(i);
}
cout << "栈的大小:"<<p.size() << endl;
cout << "栈是否为空:"<<p.isEmpty() << endl;
cout << "栈顶元素:"<<p.top() << endl;
cout << "依次出栈:" << endl;
while (!p.isEmpty())
{
cout << p.pop() << endl;
}
getchar();
return 0;
}
测试结果:
栈的大小:5
栈是否为空:0
栈顶元素:4
依次出栈:
4
3
2
1
0
3. 基于单链表的栈
以链表为底层的数据结构时,以链表头为作为栈顶较为合适,这样方便节点的插入与删除。压栈产生的新节点将一直出现在链表的头部;
3.1 链表节点
/*链表节点结构*/
template <typename T>
struct Node
{
Node(T t) :value(t), next(nullptr){};
Node() :next(nullptr){};
public:
T value;
Node<T>* next;
};
value:栈中元素的值
next:链表节点指针,指向直接后继
3.2 栈的抽象数据类型
基于链表的栈提供的接口与基于数组的栈一致。
/*栈的抽象数据结构*/
template <typename T>
class LinkStack
{
public:
LinkStack();
~LinkStack();
public:
bool isEmpty();
int size();
void push(T t);
T pop();
T top();
private:
Node<T>* phead;
int count;
};
3.3 栈的具体实现
/*返回栈的大小*/
template <typename T>
int LinkStack<T>::size()
{
return count;
};
/*栈的判空操作*/
template <typename T>
bool LinkStack<T>::isEmpty()
{
return count == 0;
};
/*插入元素*/
template<typename T>
void LinkStack<T>::push(T t)
{
Node <T> *pnode = new Node<T>(t);
pnode->next = phead->next;
phead->next = pnode;
count++;
};
/*弹栈*/
template <typename T>
T LinkStack<T>::pop()
{
if (phead->next != nullptr) //栈空判断
{
Node<T>* pdel = phead->next;
phead->next = phead->next->next;
T value = pdel->value;
delete pdel;
count--;
return value;
}
};
/*获取栈顶元素*/
template <typename T>
T LinkStack<T>::top()
{
if (phead->next!=nullptr)
return phead->next->value;
};
3.4 栈的代码测试
int _tmain(int argc, _TCHAR* argv[])
{
LinkStack <string> lstack;
lstack.push("hello");
lstack.push("to");
lstack.push("you!");
cout << "栈的大小:" << lstack.size() << endl;
cout <<"栈顶元素:"<< lstack.top() << endl;
while (!lstack.isEmpty())
{
lstack.pop();
}
cout << "栈的大小:" << lstack.size() << endl;
getchar();
return 0;
}
测试结果:
栈的大小:3
栈顶元素:you!
栈的大小:0
4. 栈的完整代码
基于数组的栈: https://github.com/huanzheWu/Data-Structure/blob/master/Stack/Main/Main/ArrayStack.h
基于单链表的栈:https://github.com/huanzheWu/Data-Structure/blob/master/singleList/singleList/singleList.h
5、实例分析
使用标准库的栈时, 应包含相关头文件,在栈中应包含头文件: #include< stack > 。定义:stack< int > s;
s.empty(); //如果栈为空则返回true, 否则返回false;
s.size(); //返回栈中元素的个数
s.top(); //返回栈顶元素, 但不删除该元素
s.pop(); //弹出栈顶元素, 但不返回其值
s.push(); //将元素压入栈顶
(1)基于数组的栈
#include <stack>
#include <iostream>
using namespace std;
int main()
{
stack<int> mystack;
int sum = 0;
for (int i = 0; i <= 10; i++){
mystack.push(i);
}
cout << "size is " << mystack.size() << endl;
while (!mystack.empty()){
cout << " " << mystack.top();
mystack.pop();
}
cout << endl;
system("pause");
return 0;
}
//size is 11
// 10 9 8 7 6 5 4 3 2 1 0
(2)基于单链表的栈
#include <iostream>
using namespace std;
template<class T>class Stack
{
private:
struct Node
{
T data;
Node *next;
};
Node *head;
Node *p;
int length;
public:
Stack()
{
head = NULL;
length = 0;
}
void push(T n)//入栈
{
Node *q = new Node;
q->data = n;
if (head == NULL)
{
q->next = head;
head = q;
p = q;
}
else
{
q->next = p;
p = q;
}
length++;
}
T pop()//出栈并且将出栈的元素返回
{
if (length <= 0)
{
abort();
}
Node *q;
int data;
q = p;
data = p->data;
p = p->next;
delete(q);
length--;
return data;
}
int size()//返回元素个数
{
return length;
}
T top()//返回栈顶元素
{
return p->data;
}
bool isEmpty()//判断栈是不是空的
{
if (length == 0)
{
return true;
}
else
{
return false;
}
}
void clear()//清空栈中的所有元素
{
while (length > 0)
{
pop();
}
}
};
int main()
{
Stack<char> s;
s.push('a');
s.push('b');
s.push('c');
while (!s.isEmpty())
{
cout << s.pop() << endl;
}
system("pause");
return 0;
}