1019. Next Greater Node In Linked List--Medium

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].

1.思考

• 先将ListNode中的数提取出来放到vector中；
• 再一开始想到的方法是从后面往回遍历，记录最大的数值。但是后来发现这个方法是错误的，因为题目要求的不是记录当前index之后的最大值，而是记录当前index之后比当前值大的第一个数值。因此该方法不行；
• 然后就一直都想不到更好的办法，只能先写两重循环来找了……这个方法太烂了……
• 后附上REF，时间复杂度为O(N)，空间复杂度也为O(N)。
  
  

2.实现
Runtime: 1076ms(19.49%)
Memory: 25.5 MB(100%)

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> nextLargerNodes(ListNode* head) {
        vector<int> input;
        
        while(head){
            input.push_back(head->val);
            head = head->next;
        }
        
        int len = input.size();
        
        if(len==1){
            input[0] = 0;
            return input;
        }
        
        int point;
        int j;
        vector<int> res = input;
        for(int i=0; i<len; i++){
            point = input[i];
            j = i+1;
            while(j<len && input[j]<=input[i]){
                j++;
            }
            if(j==len){
                res[i] = 0;    
            }
            else{
                res[i] = input[j];                
            }
        }
        
        return res;        
    }
};

//REF
    vector<int> nextLargerNodes(ListNode* head) {
        vector<int> res, stack;
        for (ListNode* node = head; node; node = node->next) {
            while (stack.size() && res[stack.back()] < node->val) {
                res[stack.back()] = node->val;
                stack.pop_back();
            }
            stack.push_back(res.size());
            res.push_back(node->val);
        }
        for (int i: stack) res[i] = 0;
        return res;
    }