数据结构与算法（七） 栈以及栈的应用
栈的应用非常的广泛，在C++的STL中，提供了用数组实现的栈。把线性表的插入和删除操作都限制在同一端，就得到栈的数据结构。是一个后进先出的数据结构。
因为栈是一种特殊的线性表，所以可以从线性表类派生出stack类。通过派生的方法可以降低栈的开发难度，但是代码的执行效率也会降低。
定义和应用：
栈：一种特殊的线性表，插入和删除操作都限制在表的同一端进行，这端称为栈顶，另一端称为栈底。
应用： 计算机执行递归函数就用到了栈。
1.直接创建基于数组的栈：
arrayStack类:
arraystack.h文件
#ifndef ARRAY_STACK_H
#define ARRAY_STACK_H
#include <iostream>
#include "E:\back_up\code\c_plus_code\sparseMatrix\external_file\stackemptyException.h" // 异常类
using namespace std;
template<typename T=int>
class arrayStack
{
private:
T* element;
int elem_number; // 栈中元素的个数
int capacity; // 栈的容量
void ensureCaoacity();
// stack ADT
public:
arrayStack(int init_capacity=10);
~arrayStack();
arrayStack(const arrayStack& stack); // 拷贝构造函数
bool empty() const;
int size() const; // 返回栈中元素的个数
T top() const; // 返回栈顶元素的值
void pop(); // 删除栈顶元素
void push(T x); // 入栈
void print_stack() const;
// 定义友元函数；
};
// arrayStack实现
template<typename T>
arrayStack<T>::arrayStack(int init_capacity)
{
elem_number = 0;
capacity = init_capacity;
element = new T[capacity];
}
template<typename T>
arrayStack<T>::~arrayStack()
{
delete []element;
}
template<typename T>
arrayStack<T>::arrayStack(const arrayStack& stack)
{
elem_number = stack.elem_number; // 栈中的元素个数
capacity = stack.capacity;
element = new T[capacity];
// 赋值元素
for(int i=0; i<elem_number; i++)
{
element[i] = stack.element[i];
}
}
template<typename T>
void arrayStack<T>::ensureCaoacity()
{
if(elem_number>=capacity)
{
T* old = element;
// delete element;
// delete的本质是： delete之后，下次再重新申请的时候可以
// 再申请这块内存地址，对于这块地址的内容，没有进行清空处理（也没有必要）
capacity = elem_number*2;
element = new T[capacity];
for(int i=0; i<elem_number; i++)
{
element[i] = old[i];
}
delete []old;
}
// 还可以添加栈中数组大小动态减小的代码
}
template<typename T>
bool arrayStack<T>::empty() const
{
return elem_number==0;
}
template<typename T>
int arrayStack<T>::size() const // 返回栈中元素的个数
{
return elem_number;
}
template<typename T>
T arrayStack<T>::top() const
{
if(empty())
throw stack_empty_exception(0);
return element[elem_number-1]; // 返回栈顶元素的值
}
template<typename T>
void arrayStack<T>::pop()
{
if(empty())
throw stack_empty_exception(0);
elem_number--;
}
template<typename T>
void arrayStack<T>::push(T x)
{
ensureCaoacity();
element[elem_number++] = x;
}
template<typename T>
void arrayStack<T>::print_stack() const
{
if(empty())
{
cout << "The stack is empty" << endl;
}
else
{
for(int i=0; i<elem_number; i++)
{
cout << element[i] << " ";
}
cout << endl;
}
}
#endif
在栈为空的时候，不能进行出栈操作，这一功能由异常类实现：
stackemptyException.h文件
// 自定义异常类：
#ifndef STACK_EMPTY_EXCEPTION
#define STACK_EMPTY_EXCEPTION
#include <stdexcept>
using namespace std; // 因为stdexcept
class stack_empty_exception : public runtime_error
{
private:
int current_stack_size;
public:
stack_empty_exception(int stack_size):runtime_error("Stack is empty")
{
this->current_stack_size = stack_size;
}
void display_error_info()
{
cout << "----------------------------" << endl;
cout << "The stack size is " << current_stack_size << endl;
cout << "----------------------------" << endl;
}
};
#endif
测试文件
main.cpp
#include <iostream>
#include "E:\back_up\code\c_plus_code\sparseMatrix\external_file\arraystack.h"
using namespace std;
int main(int argc, char *argv[])
{
arrayStack<int> stack(10);
try // 异常测试
{
stack.pop();
}
catch(stack_empty_exception& ex)
{
cout << ex.what() << endl;
ex.display_error_info();
}
try // 异常测试
{
stack.pop();
}
catch(stack_empty_exception& ex)
{
cout << ex.what() << endl;
ex.display_error_info();
}
stack.print_stack();
for(int i=0; i<13; i++)
{
stack.push(i+1);
}
stack.print_stack();
cout << "stack size: " << stack.size() << endl;
while(!stack.empty()) // 出栈
{
cout << stack.top() << " ";
stack.pop();
}
cout << endl;
}
运行结果：
2
添加新的方法，将stack中的数据分为a,b两部分：
template<typename T>
void arrayStack<T>::split_stack(arrayStack& stack_a, arrayStack& stack_b)
{
if(elem_number<2)
throw stack_empty_exception(2);
int criterion = elem_number/2;
int count = 0;
while(elem_number>0)
{
if(count < criterion)
{
stack_a.push(element[elem_number-1]);
count++;
elem_number--;
}
else
{
stack_b.push(element[elem_number-1]);
count++;
elem_number--;
}
}
}测试函数：
main.cpp
#include <iostream>
#include "E:\back_up\code\c_plus_code\sparseMatrix\external_file\arraystack.h"
using namespace std;
int main(int argc, char *argv[])
{
arrayStack<int> stack(10);
//stack.print_stack();
for(int i=0; i<10; i++)
{
stack.push(i+1);
}
stack.print_stack();
arrayStack<int> a;
arrayStack<int> b;
try
{
stack.split_stack(a, b);
cout << "split stack into two parts" << endl;
cout << "stack_a: ";
a.print_stack();
cout << "stack_b: ";
b.print_stack();
}
catch(stack_empty_exception& ex)
{
cout << ex.what() << endl;
ex.display_error_info();
}
}
运行结果：
2. 此外栈和可以由线性表的类派生而来，如arrayLIst类和chain类
3.栈的应用：
(a). 括号匹配：
例如：(a*(b+c)+d)进行括号匹配：从左到右扫描字符串，没哟个右括号都与最近扫描到的未匹配的左括号进行匹配
#include <iostream>
#include "E:\back_up\code\c_plus_code\sparseMatrix\external_file\arraystack.h"
#include <string>
using namespace std;
void printMatchedPairs(string expr)
{
arrayStack<int> s;
int expr_length = (int)expr.size();
// 扫描表达式
for(int i=0; i<expr_length; i++)
{
if(expr.at(i)=='(')
{
s.push(i); // 左括号的位置
}
else
{
if(expr.at(i)==')') // 如果是右括号，则进行匹配
try
{
cout << s.top() << " " << i << endl;
s.pop();
}
catch(stack_empty_exception& ex)
{
cout << "NO match for ) at " << i << endl;
}
}
}
while(!s.empty())
{
cout << "NO match for left bracket" << s.top() << endl;
s.pop();
}
}
int main(int argc, char *argv[])
{
string expression("((a+b)*2)+3");
printMatchedPairs(expression);
}
输出：
1 5
0 8
