单调栈 c++实现

今天学了单调栈，然后自己用c++实现了一下

什么是单调栈，单调栈的作用

单调栈就是一个栈，并且栈内数据元素是从栈底到栈顶是单调递增或递减的。使用单调栈来解决求一个数组的每个元素的左边和右边离它最近的比它大的值。且时间复杂度为O(N)，每个数仅仅入栈出栈1次。以下图为例：

数组arr={5,4,6,7};L表示左边离下为i的数组元素最近比它大的值，R表示右边离下为i的数组元素最近比它大的值

单调栈原理

使用单调栈解决上述问题，可以分为两种情况：一种为数组无重复值时，一种为数组有重复值时。（实际上数组有重复值时的思想也可以用于解决数组无重复值的情况，就是额外空间复杂度高了一些而已）。接下来当用单调栈求此问题时，要求大值时，栈内元素应该从大向小生长。要求小值时，栈内元素应该从小向大生长。

数组无重复值时使用单调栈

以arr[]={5,4,3,6,1,2}为例。
使用一个栈结构来存储arr下标，
<1> 当栈为空时，将元素入栈，当入栈元素比栈顶元素小时，直接入栈。以上为例，即：

<2> 当入栈元素比栈顶元素大时，此时入栈将不满足单调栈规则，则将栈顶元素出栈，且出栈元素的L为下一个栈顶元素，R为入栈元素。依次类推，直至入栈元素比栈顶元素小或者栈为空，再将入栈元素入栈。如图：

<3> 重复<2>过程，直至遍历完arr数组内的所有元素。如图：

<4> 当栈内还有元素时，依次出栈，求出栈元素L
为下一个栈顶元素，R为无

示例代码：

int** getNearGreaterNoRepeat(int *arr,int len)//当数组中没有重复值时
{
 int **re = new int*[2];
 re[0] = new int[len];
 re[1] = new int[len];//开辟2*len的空间用于保存每个数的L与R,0为L.1为R
 stack<int>*s = new stack<int>;//开辟一段栈空间
 for (int i = 0; i < len; ++i)
 {
  while (!s->empty() && arr[s->top()]<arr[i])
  {
   //当栈不为空，且栈顶元素对应的数组元素小于当前数组元素时,说明不满足栈为从大到小上升的规定
   //则对出栈元素就产生了一些信息
   int popIndex = s->top(); s->pop();//出栈下标
   re[0][popIndex] = s->empty() ? -1 : s->top();//出栈元素的L为栈顶元素
   re[1][popIndex] = i;//R为当前下标
  }
  //当满足栈从大到小上升时
  s->push(i);//入栈
 }
 while (!s->empty())
 {
  //当栈依旧不为空时
  int popIndex = s->top(); s->pop();//出栈下标
  re[0][popIndex] = s->empty() ? -1 : s->top();//出栈元素的L为栈顶元素
  re[1][popIndex] = -1;//R为-1
 }
 delete s;
 return re;
}

数组有重复值时使用单调栈

当数组内有重复值时，我们只需额外使用一个链表来存储重复值，且栈内存储的元素为链表。当出栈时，要将每个链表内的元素都进行L和R的赋值，L为栈顶链表的最后一个元素，R为入栈元素。入栈时，当元素重复时，按头插法插入元素，元素不重复时就构建一个链表头，然后入栈即可。

示例代码：

int **getNeatGreaterWithRepeat(int *arr, int len)
{
 int **re = new int*[2];
 re[0] = new int[len];
 re[1] = new int[len];
 stack<list<int>>*s = new stack<list<int>>;
 for (int i = 0; i < len; ++i)
 {
  while (!s->empty()&& arr[s->top().front()]<arr[i])
  {
   //当栈不为空时，又满足以栈顶链表的元素为下标的数组数据小于当前位置的数时，
   //说明不满足单调栈规矩，此时弹栈
   list<int>l = s->top(); s->pop();//获取栈顶元素并弹栈
   int L = s->empty() ? -1 : s->top().back();//L的值当栈为空时为-1，不为空时为栈顶链表的表尾元素
   for (list<int>::iterator it = l.begin(); it != l.end(); ++it)
   {
    //使用迭代器来访问链表元素
    re[0][*it] = L;//左
    re[1][*it] = i;//右
   }
  }
  //当满足栈规则时，向栈内添加元素
  if (!s->empty() && arr[s->top().front()] == arr[i])
  {
   //当入栈元素与栈顶链表内下标对应的数组数据相等，则加入到该链表汇总
   s->top().push_front(i);//使用头插法
  }
  else
  {
   //否则创建一个新链表，链表元素为当前位置，然后将该链表入栈
   list<int>l;
   l.push_front(i);
   s->push(l);
  }
 }
 while (!s->empty())
 {
  //当栈依旧不为空时
  list<int>l = s->top(); s->pop();//依次弹栈
  int L = s->empty() ? -1 : s->top().back();//L的值当栈为空时为-1，不为空时为栈顶链表的表尾元素
  for (list<int>::iterator it = l.begin(); it != l.end(); ++it)
  {
   //使用迭代器来访问链表元素
   re[0][*it] = L;//左
   re[1][*it] = -1;//右
  }
 }
 delete s;
 return re;
}

完整代码演示：

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<stack>
#include<list>
using namespace std;
int** getNearGreaterNoRepeat(int *arr,int len)//当数组中没有重复值时
{
 int **re = new int*[2];
 re[0] = new int[len];
 re[1] = new int[len];//开辟2*len的空间用于保存每个数的L与R,0为L.1为R
 stack<int>*s = new stack<int>;//开辟一段栈空间
 for (int i = 0; i < len; ++i)
 {
  while (!s->empty() && arr[s->top()]<arr[i])
  {
   //当栈不为空，且栈顶元素对应的数组元素小于当前数组元素时,说明不满足栈为从大到小上升的规定
   //则对出栈元素就产生了一些信息
   int popIndex = s->top(); s->pop();//出栈下标
   re[0][popIndex] = s->empty() ? -1 : s->top();//出栈元素的L为栈顶元素
   re[1][popIndex] = i;//R为当前下标
  }
  //当满足栈从大到小上升时
  s->push(i);//入栈
 }
 while (!s->empty())
 {
  //当栈依旧不为空时
  int popIndex = s->top(); s->pop();//出栈下标
  re[0][popIndex] = s->empty() ? -1 : s->top();//出栈元素的L为栈顶元素
  re[1][popIndex] = -1;//R为-1
 }
 delete s;
 return re;
}
int **getNeatGreaterWithRepeat(int *arr, int len)
{
 int **re = new int*[2];
 re[0] = new int[len];
 re[1] = new int[len];
 stack<list<int>>*s = new stack<list<int>>;
 for (int i = 0; i < len; ++i)
 {
  while (!s->empty()&& arr[s->top().front()]<arr[i])
  {
   //当栈不为空时，又满足以栈顶链表的元素为下标的数组数据小于当前位置的数时，
   //说明不满足单调栈规矩，此时弹栈
   list<int>l = s->top(); s->pop();//获取栈顶元素并弹栈
   int L = s->empty() ? -1 : s->top().back();//L的值当栈为空时为-1，不为空时为栈顶链表的表尾元素
   for (list<int>::iterator it = l.begin(); it != l.end(); ++it)
   {
    //使用迭代器来访问链表元素
    re[0][*it] = L;//左
    re[1][*it] = i;//右
   }
  }
  //当满足栈规则时，向栈内添加元素
  if (!s->empty() && arr[s->top().front()] == arr[i])
  {
   //当入栈元素与栈顶链表内下标对应的数组数据相等，则加入到该链表汇总
   s->top().push_front(i);//使用头插法
  }
  else
  {
   //否则创建一个新链表，链表元素为当前位置，然后将该链表入栈
   list<int>l;
   l.push_front(i);
   s->push(l);
  }
 }
 while (!s->empty())
 {
  //当栈依旧不为空时
  list<int>l = s->top(); s->pop();//依次弹栈
  int L = s->empty() ? -1 : s->top().back();//L的值当栈为空时为-1，不为空时为栈顶链表的表尾元素
  for (list<int>::iterator it = l.begin(); it != l.end(); ++it)
  {
   //使用迭代器来访问链表元素
   re[0][*it] = L;//左
   re[1][*it] = -1;//右
  }
 }
 delete s;
 return re;
}
int main(void)
{
 //int arr[] = { 5, 4, 3, 6, 1, 2 };
 int arr[] = { 5, 4, 3, 4, 5, 3, 5, 6 };
 int **re = NULL;
 re = getNeatGreaterWithRepeat(arr, 8);
 //re = getNearGreaterNoRepeat(arr, 6);
 for (int i = 0; i < 2; ++i)
 {
  for (int j = 0; j < 8; ++j)
  {
   if (re[i][j] != -1)
   {
    cout << arr[re[i][j]]<<" ";
   }
   else
    cout << "无";
  }
  cout << endl;
 }
 if (re != NULL)
 {
  for (int i = 0; i < 2; ++i)
   delete[] re[i];
  delete re;
  re = NULL;
 }
 system("pause");
 return 0;
}