数据结构专题（持续更新）

一、堆栈

基本操作：

#include 

stack<int> s;
s.size() // 栈内元素个数
s.empty() // 判断栈是否为空
s.push(x) // 将x入栈
s.pop() // 栈顶出栈
s.top() // 栈顶元素
while(!s.empty()) // 栈的清空（STL中没有实现栈的清空）
{
	s.pop();
} 

注：在使用pop() 和 top() 函数之前，必须先使用 empty() 函数判断栈是否为空。

eg1. 括号匹配问题

思路分析：

建立堆栈，存放左括号的下标值。而对于右括号，只需要判断堆栈中是否还存在元素（左括号）。若存在则匹配成功，否则意味着匹配失败。

代码：

#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

stack<int> s; // 字符下标堆栈 (栈中之存储左括号，如果右括号入栈意味着该括号存在不匹配 
string str;
char ans[105];

int main()
{
	freopen("input.txt", "r", stdin);
	while(cin >> str)
	{
		for(int i=0; i<str.size(); i++)
		{
			if(str[i] == '(')
			{
				s.push(i); // 左括号全部入栈 
				ans[i] = ' '; // 对应显示数组填空格 
			}
			else if(str[i] == ')')
			{
				if(!s.empty()) // 栈非空，有匹配的括号 
				{
					s.pop(); // 元素出栈之前一定要检查栈是否为空！！！
					ans[i] = ' '; 
				}
				else // 栈空，无匹配项
				{
					ans[i] = '?';	
				}
			}
			else 
			{
				ans[i] = ' ';
			}
		}
		while(!s.empty()) // 栈中还存在不匹配的左括号 
		{
			ans[s.top()] = '$';
			s.pop(); 
		}
		ans[str.size()] = '\0';
		cout << str << endl;
		cout << ans << endl;
	}
	fclose(stdin);
	
	return 0;
}

eg2. 表达式求值问题——简单计算器

思路分析：

题目给出的是中缀表达式，但对于计算机而言，表达式求值运用的是后缀表达式，因而求值应包含下面两个步骤：
1）中缀表达式转后缀表达式
2）计算后缀表达式

步骤一：中缀表达式转后缀表达式
① 建立一个操作符栈；设立一个后缀表达式队列。

② 从左向右扫描中缀表达式，遇到操作数，就把该操作数入后缀表达式队列。
注：操作数可能不止一位，因而需要单独处理。

while(i<str.length() && str[i]>='0' && str[i]<='9') // 操作数的读取 
			{
				temp.num = temp.num * 10 + (str[i++] - '0');
			}

③ 遇到操作符op，将其与操作符栈顶元素的优先级比较：

• op优先级 > 栈顶符号优先级： 将op入栈。
• op优先级 <= 栈顶符号优先级： 将操作符栈顶元素不断弹出，直至op优先级高于栈顶符号优先级，将其入栈。

注：因为栈顶符号会被先使用，所以栈顶存放优先级高的符号。

④ 重复上述操作，直至中缀表达式扫描完毕。之后若操作符栈中仍有元素，则将它们依次弹出至后缀表达式。

步骤二：计算后缀表达式
从左向右扫描后缀表达式，读到操作数便将其入栈，读到操作符就连续弹出两个操作数（注：后弹出的是第一操作数，先弹出的是第二操作数），计算和生成的新操作数入栈。反复操作，最终栈中只剩下一个数，就是最终的答案。

代码：

// 简易计算器

#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

struct Node
{
    double num;
    char op;
    bool flag;
};

string str; // 输入字符串
stack<Node> s; // 符号栈
queue<Node> q; // 数字队列
map<char, int> op; // 符号优先级映射

void change() // 中缀表达式 -> 后缀表达式
{
    Node temp;
    for(int i=0; i<str.length(); )
    {
        if(str[i]>='0' && str[i]<='9')
        {
            temp.flag = true; // 数字
            temp.num = str[i] - '0';
            i++;
            while(i<str.length() && str[i]>='0' && str[i]<='9')
            {
                temp.num = temp.num * 10 + (str[i] - '0');
                i++;
            }
            q.push(temp);
        }
        else
        {
            temp.flag = false; // 符号
            temp.op = str[i];
            while(!s.empty() && op[str[i]]<=op[s.top().op]) // 读入符号优先级 ≤ 栈顶符号优先级
            {
                q.push(s.top());
                s.pop();
            }
            s.push(temp);
            i++;
        }
    }
    while(!s.empty()) // 操作符栈中仍有操作符，全部弹出
    {
        q.push(s.top());
        s.pop();
    }
}

double cal() // 计算后缀表达式
{
    double temp1, temp2;
    Node cur, temp;
    while(!q.empty())
    {
        cur = q.front();
        q.pop();
        if(cur.flag == true) // 操作数
        {
            s.push(cur);
        }
        else // 操作符
        {
            temp2 = s.top().num;
            s.pop(); 
            temp1 = s.top().num;
            s.pop(); 
            temp.flag = true;
            if(cur.op == '+')
                temp.num = temp1 + temp2;
            else if(cur.op == '-')
                temp.num = temp1 - temp2;
            else if(cur.op == '*')
                temp.num = temp1 * temp2;
            else 
                temp.num = temp1 / temp2;
            s.push(temp);
        }
    }

    return s.top().num;
}

int main()
{
    op['+'] = op['-'] = 1;
    op['*'] = op['/'] = 2;
    while(getline(cin, str), str != "0") 
    {
        for(string::iterator it = str.end(); it != str.begin(); it--)
        {
            if(*it == ' ')
            {
                str.erase(it);
            }
        }
        while(!s.empty()) // 初始化栈
        {
            s.pop();
        }
        change(); // 转换
        printf("%.2f\n", cal());    
    }

    return 0;
}

eg3. PAT A1051 Pop Sequence

题目大意：

有一个容量限制为M的栈，先分别把1,2,3,…,n依次入栈，并给出一些列出栈的顺序，问这些出栈顺序是否可能。

思路分析：

本题是一道堆栈的模拟题，可以模拟入栈出栈的过程。

若堆栈未满，将数字顺序入栈，并将栈顶元素与题目给出的出栈数组相比较，若相等，则将该数字出栈。

最后若栈为空，表示序列成立，否则不成立。

注意：每次循环的最开始，一定要将栈清空！！！养成随时清空堆栈的习惯。

代码（AC）

#include 
#include 
#include 
#include 
using namespace std;

const int maxn = 1010;
int a[maxn];
stack<int> s;

void stack_clear()
{
	while(!s.empty())
	{
		s.pop();
	}
}

int main()
{
	freopen("input.txt", "r", stdin);
	int m, n, k;
	scanf("%d %d %d", &m, &n, &k);
	for(int i=0; i<k; i++)
	{
		stack_clear(); // 清空堆栈（要养成清空堆栈的习惯） 
		for(int j=0; j<n; j++)
		{
			scanf("%d", &a[j]);
		}
		int index = 0;
		for(int j=1; j<=n; j++)
		{
			if(s.size() < m) // 栈未满
			{
				s.push(j); // 入栈 
			}
			while(!s.empty() && s.top()==a[index]) // 一定要记得堆栈判空！ 
			{
				s.pop();
				index++;
			}
		}
		if(s.empty()) 
		{
			printf("YES\n");
		}
		else // 堆栈中还有残留，就不成立 
		{
			printf("NO\n");
		}
	}
	
	fclose(stdin);
	return 0;
}