栈和队列专题

声明：部分试题、解决方案来自LeetCode，本文旨在学习

1.Valid Parentheses

Given a string containing just the characters ‘(‘, ‘)’, ‘{‘, ‘}’, ‘[’ and ‘]’, determine if the input string is valid.

The brackets must close in the correct order, “()” and “()[]{}” are all valid but “(]” and “([)]” are not.

Solution：

时间复杂度O（n），空间复杂度O（n）

bool isValid(string const& s){    string left = "([{";    string right = ")]}";    stack<char> stk;    for (int i = 0; i < s.size(); i++)    {        char c = s[i];        if(left.find(c) != string::npos)            stk.push(c);        else        {            if(stk.empty() || stk.top() != left[right.find(c)])                return false;            else                stk.pop();        }    }    return stk.empty();}

2.Longest Valid Parentheses

Given a string containing just the characters ‘(’ and ‘)’, find the length of the longest valid (well-formed) parentheses substring.

For “(()”, the longest valid parentheses substring is “()”, which has length = 2.

Another example is “)()())”, where the longest valid parentheses substring is “()()”, which has length = 4.

Solution：

时间复杂度O（n），空间复杂度O（n）

int longestValidPaarentheses(string s){    int max_len = 0;    int last = -1;      //the position of the last ')'    stack<int> lefts;   //keep track of the positions of non-matching '('s    for (int i = 0; i < s.size(); i++)    {        if(s[i] == '(')            lefts.push(i);        else        {            if(lefts.empty())                last = i;  //no matching left            else            {                //find a matching pair                lefts.pop();                if(lefts.empty())                    max_len = max(max_len,i-last);                else                    max_len = max(max_len,i-lefts.top());            }        }    }    return max_len;}

3. Largest Rectangle in Histogram

Given n non-negative integers representing the histogram’s bar height where the width of each bar is 1, find the area of largest rectangle in the histogram.

Above is a histogram where width of each bar is 1, given height = [2,1,5,6,2,3].

The largest rectangle is shown in the shaded area, which has area = 10 unit.

For example,
Given heights = [2,1,5,6,2,3],
return 10.

分析：

如上图，从左向右处理直方，当i=4时，小于当前栈顶（即直方3），对于直方3，无论后面还是前面的直方，都不能得到比目前栈顶元素更高的高度了，处理掉直方3（计算从直方3到直方4之间的举行的面积，然后从栈里弹出）；对于直方2也是如此；直到碰到比直方4更矮的直方1.

这就意味着，可以维护一个递增的栈，每次比较栈顶与当前元素。如果当前元素大于栈顶元素，则入栈，直至栈顶元素小于当前元素。结尾时入栈元素0，重复合并一次。

Solution：

时间复杂度O（n），空间复杂度O（n）

int largestRectangleArea(vector<int> &height){    stack<int> s;    height.push_back(0); //结尾入栈元素为0    int result = 0;    int i = 0;    while(i < height.size())    {        if(s.empty() || height[i] > height[s.top()])            s.push(i++);        else        {            int tmp = s.top();            s.pop();            result = max(result,height[tmp]*(s.empty() ? i : i-s.top()-1));        }    }    return result;}

下面是二叉树非递归遍历，包括分层层次遍历，非递归先序、中序、后序遍历。先放一张图，是结果截图。

由于主要用到的是栈和队列，故放在本专题

4.层次遍历分层打印

层次遍历用到了队列这一数据结构，分层打印则需要记录当前层和下一层需要打印的个数。

void split_hierarchy_order(Node* root){    queue<Node*> q;    Node* p;    q.push(root);    int cur_hierarchry_count = 1;    int next_hierarchy_count = 0;    while(!q.empty())    {        if(cur_hierarchry_count > 0)        {            p = q.front();            q.pop();            if(p != NULL)                cout << p->val << " ";            else                cout << "#" << " ";            cur_hierarchry_count--;            if(p != NULL  && (p->left != NULL || p->right != NULL))  //这里运行了C++的判断机制：一旦p != NULL不成立，由于后面的 && 操作符就不继续判断了，从而p->left不会报错            {                q.push(p->left);                next_hierarchy_count++;                q.push(p->right);                next_hierarchy_count++;            }        }        else        {            cout << endl;            cur_hierarchry_count = next_hierarchy_count;            next_hierarchy_count = 0;        }    }}

下面的先序、中序、后序遍历的非递归遍历都需要用到栈这一数据结构

5.非递归先序遍历

void inrecur_pre_order(Node* root){    stack<Node*> s;    Node* p = root;    while (!s.empty() || p != NULL)    {        while(p != NULL)        {            cout << p->val << " ";            s.push(p);            p = p->left;        }        if (!s.empty())        {            p = s.top();            p = p->right;            s.pop();        }    }}

6.非递归中序遍历

非递归中序遍历与先序遍历思路基本差不多，对于何时打印节点的值稍微考虑一下就行了。

void inrecur_in_order(Node* root){    stack<Node*> s;    Node* p = root;    while (!s.empty() || p != NULL)    {        while (p != NULL)        {            s.push(p);            p = p->left;        }        if (!s.empty())        {            p = s.top();            cout << p->val << " ";            s.pop();            p = p->right;        }    }}

7.非递归后序遍历

非递归后续遍历应该是非递归遍历中最难的了，为了方便理解思路。我们需要在数据结构做些改动。

struct Node{    int val;    Node* left;    Node* right;    bool isFirst;  //用于记录节点是否是第一次被访问    Node(int value,Node* l = NULL,Node* r = NULL,bool isF = false):val(value),left(l),right(r),isFirst(isF){};};

根据非递归后续遍历的任务，我们可以理解为在节点第二次被访问时进行输出。

void inrecur_post_order(Node* root){    stack<Node*> s;    Node* p = root;    while (p != NULL || !s.empty())    {        while (p != NULL)        {            s.push(p);            p->isFirst = true;            p = p->left;        }        if (!s.empty())        {            p = s.top();            s.pop();            if (p->isFirst == true)    //第一次出现在栈顶            {                s.push(p);                p->isFirst = false;                p = p->right;            }            else       //第二次出现在栈顶            {                cout << p->val << " ";                p = NULL;   //很重要            }        }    }}