1019. Next Greater Node In Linked List**

1019. Next Greater Node In Linked List**

https://leetcode.com/problems/next-greater-node-in-linked-list/

Title Description

We are given a linked list with head as the first node. Let’s number the nodes in the list: node_1, node_2, node_3, … etc.

Each node may have a next larger value: for node_i, next_larger(node_i) is the node_j.val such that j > i, node_j.val > node_i.val, and j is the smallest possible choice. If such a j does not exist, the next larger value is 0.

Return an array of integers answer, where answer[i] = next_larger(node_{i+1}).

Note that in the example inputs (not outputs) below, arrays such as [2,1,5] represent the serialization of a linked list with a head node value of 2, second node value of 1, and third node value of 5.

Example 1:

Input: [2,1,5]
Output: [5,5,0]

Example 2:

Input: [2,7,4,3,5]
Output: [7,0,5,5,0]

Example 3:

Input: [1,7,5,1,9,2,5,1]
Output: [7,9,9,9,0,5,0,0]

Note:

• 1 <= node.val <= 10^9 for each node in the linked list.
• The given list has length in the range [0, 10000].

C ++ implementation 1

You can consider a look at 496. Next Greater Element I * This question is to get a feel. Use stack to do more convenient.

First with recordthe save each number down the list, and then click Access recordand look NGE each element. Stack holds the index does not yet have NGE find those elements.

class Solution {
public:
    vector<int> nextLargerNodes(ListNode* head) {
        stack<int> st;
        vector<int> record;
        auto p = head;
        while (p) {
            record.push_back(p->val);
            p = p->next;
        }
        vector<int> res(record.size(), 0);
        for (int i = 0; i < record.size(); ++ i) {
            while (!st.empty() && record[i] > record[st.top()]) {
                res[st.top()] = record[i];
                st.pop();
            }
            st.push(i);
        }
        return res;
    }
};

2 in C ++

Stack stto save NGE unfortunately node is not found, recordthe recorded value corresponding to each node of NGE.

class Solution {
public:
    vector<int> nextLargerNodes(ListNode* head) {
        stack<ListNode*> st;
        vector<int> res;
        unordered_map<ListNode*, int> record;
        auto p = head;
        while (p) {
            while (!st.empty() && p->val > st.top()->val) {
                record[st.top()] = p->val;
                st.pop();
            }
            st.push(p);
            p = p->next;
        }
        p = head;
        while (p) {
            if (record.count(p)) res.push_back(record[p]);
            else res.push_back(0);
            p = p->next;
        }
        return res;
    }
};