查找下一个更大元素的 Javascript 程序

给定一个数组，打印每个元素的下一个更大元素 (NGE)。元素 x 的下一个更大元素是数组中 x 右侧的第一个更大元素。对于不存在更大元素的元素，将下一个更大的元素视为-1。

例子：

1. 对于数组，最右边的元素总是具有下一个更大的元素为 -1。
2. 对于按降序排序的数组，所有元素的下一个较大元素为 -1。
3. 对于输入数组 [4, 5, 2, 25]，每个元素的下一个更大的元素如下。

Element       NGE
   4      -->   5
   5      -->   25
   2      -->   25
   25     -->   -1

d)对于输入数组 [13, 7, 6, 12}，每个元素的下一个更大的元素如下。

Element        NGE
   13      -->    -1
   7       -->     12
   6       -->     12
   12      -->     -1

方法1（简单）
使用两个循环：外部循环一一挑选所有元素。内循环为外循环选取的元素寻找第一个更大的元素。如果找到更大的元素，则将该元素打印为下一个，否则打印-1。

下面是上述方法的实现：

Javascript

      // Simple JavaScript program to print
      // next greater elements in a
      // given array
  
      /* prints element and NGE pair
      for all elements of arr[] of size n */
      function printNGE(arr, n)
      {
        var next, i, j;
        for (i = 0; i < n; i++) 
        {
          next = -1;
          for (j = i + 1; j < n; j++)
          {
            if (arr[i] < arr[j]) 
            {
              next = arr[j];
              break;
            }
          }
          document.write(arr[i] + " -- " + next);
          document.write("<br>");
        }
      }
  
      // Driver Code
      var arr = [11, 13, 21, 3];
      var n = arr.length;
      printNGE(arr, n);
        
      // This code is contributed by rdtank.
    

输出

11 -- 13
13 -- 21
21 -- -1
3 -- -1

时间复杂度： O(N ² )
辅助空间： O(1)

方法2（使用堆栈）

• 将第一个元素推入堆栈。
• 一个一个地选择其余的元素，然后循环执行以下步骤。
  1. 将当前元素标记为next 。
  2. 如果 stack 不为空，则将 stack 的顶部元素与next进行比较。
  3. 如果 next 大于顶部元素，则从堆栈中弹出元素。 next是弹出元素的下一个更大的元素。
  4. 当弹出的元素小于next时，继续从堆栈中弹出。 next成为所有此类弹出元素的下一个更大元素。
• 最后，压入栈中的下一个。
• 步骤 2 中的循环结束后，从堆栈中弹出所有元素并打印 -1 作为它们的下一个元素。

下图是上述方法的试运行：

下面是上述方法的实现：

Javascript

  
// A Stack based Javascript program to find next
// greater element for all array elements.
  
/* prints element and NGE pair for all
elements of arr[] of size n */
function printNGE(arr, n)
{
    var s = [];
  
    /* push the first element to stack */
    s.push(arr[0]);
  
    // iterate for rest of the elements
    for (var i = 1; i < n; i++) 
    {
  
        if (s.length == 0) {
            s.push(arr[i]);
            continue;
        }
  
        /* if stack is not empty, then
           pop an element from stack.
           If the popped element is smaller
           than next, then
        a) print the pair
        b) keep popping while elements are
        smaller and stack is not empty */
        while (s.length ==0 == false 
               && s[s.length-1] < arr[i]) 
        {
            document.write( s[s.length-1] 
                 + " --> " + arr[i]+"<br>");
            s.pop();
        }
  
        /* push next to stack so that we can find
        next greater for it */
        s.push(arr[i]);
    }
  
    /* After iterating over the loop, the remaining
    elements in stack do not have the next greater
    element, so print -1 for them */
    while (s.length !=0) {
        document.write( s[s.length-1] + " --> " + -1+ "<br>" );
        s.pop();
    }
}
  
/* Driver code */
var arr = [11, 13, 21, 3];
var n = arr.length;
printNGE(arr, n);
  

输出

11 --> 13
13 --> 21
3 --> -1
21 --> -1

时间复杂度： O(N)
辅助空间： O(N)

最坏的情况发生在所有元素都按降序排序时。如果元素按降序排序，则每个元素最多处理 4 次。

1. 最初推入堆栈。
2. 处理下一个元素时从堆栈中弹出。
3. 因为下一个元素更小，所以被推回堆栈。
4. 在算法的第 3 步中从堆栈中弹出。

如何以与输入相同的顺序获取元素？

上述方法可能不会以与输入相同的顺序生成输出元素。要实现相同的顺序，我们可以倒序遍历相同的

下面是上述方法的实现：

Javascript

  
// Javascript program for the above approach
  
    /* prints element and NGE pair for all
    elements of arr[] of size n */
    function printNGE(arr, n)
    {
        var s = [];
        let res = new Array(n);
  
        // iterate for rest of the elements
        for (let i = n - 1; i >= 0; i--)
        {
            /* if stack is not empty, then
            pop an element from stack.
            If the popped element is smaller
            than next, then
            a) print the pair
            b) keep popping while elements are
            smaller and stack is not empty */
            if (s.length != 0)
            {
                while (s.length != 0 
                       && s[s.length-1] <= arr[i])
                {
                    s.pop();
                }
            }
            res[i] = s.length == 0 ? -1 : s[s.length-1];
            s.push(arr[i]);
        }
        for (let i = 0; i < arr.length; i++)
            document.write(arr[i] + 
                               " --> " + res[i] + "<br/>");
    }
      
// Driver Code
  
       let arr = [ 11, 13, 21, 3 ];
    let n = arr.length;
  
    // Function call
    prletNGE(arr, n);
      
    // This code is contributed by splevel62.

输出

11 ---> 13
13 ---> 21
21 ---> -1
3 ---> -1

时间复杂度： O(N)
辅助空间： O(N)

有关详细信息，请参阅有关 Next Greater Element 的完整文章！