1019. 链表中的下一个更大节点

一开始没想到用栈，想的是和数组一样的遍历时间复杂度高

vector<int> nextLargerNodes(ListNode* head) {
    vector<int> res;
    ListNode *p = head;
    while(p->next != nullptr)
    {
        ListNode *cur = p->next;
        int flag = 0;
        while(cur != nullptr)
        {
            int s = 0;
            if(p->val < cur->val)
            {
                s = cur->val;
                res.push_back(s);
                flag = 1;
                break;
            }
            else
            {
                cur =  cur->next;
            }   
        }
        if(flag ==0) res.push_back(0);
        p = p->next;
    }
    res.push_back(0);
    return res;
}

为什么用栈，因为最后一个进入vector的是0，不用比较，前面找的是后面大的元素，
前面跟后面的比较，把后面的放入栈中，进行有序的比较即可，很巧妙.

vector<int> nextLargerNodes(ListNode* head) {
        stack<int> nodes;
        stack<int> stk;
        int length = 0;
        while (head) {
            nodes.push(head->val);
            head = head->next;
            length++;
        }
        vector<int> result(length);
        while (!nodes.empty()) {
            int node = nodes.top();
            nodes.pop();
            while (!stk.empty() && node >= stk.top()) {
                stk.pop();
            }
            result[--length] = stk.empty() ? 0 : stk.top();
            stk.push(node);
        }
        return result;
}