[Swift]LeetCode1019. 链表中的下一个更大节点 | Next Greater Node In Linked List

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址： https://www.cnblogs.com/strengthen/p/10634379.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

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. 1 <= node.val <= 10^9 for each node in the linked list.
2. The given list has length in the range [0, 10000].

---

给出一个以头节点 head 作为第一个节点的链表。链表中的节点分别编号为：node_1, node_2, node_3, ... 。

每个节点都可能有下一个更大值（next larger value）：对于 node_i，如果其 next_larger(node_i) 是 node_j.val，那么就有 j > i 且  node_j.val > node_i.val，而 j 是可能的选项中最小的那个。如果不存在这样的 j，那么下一个更大值为 0 。

返回整数答案数组 answer，其中 answer[i] = next_larger(node_{i+1}) 。

注意：在下面的示例中，诸如 [2,1,5] 这样的输入（不是输出）是链表的序列化表示，其头节点的值为 2，第二个节点值为 1，第三个节点值为 5 。 

示例 1：

输入：[2,1,5]
输出：[5,5,0]

示例 2：

输入：[2,7,4,3,5]
输出：[7,0,5,5,0]

示例 3：

输入：[1,7,5,1,9,2,5,1]
输出：[7,9,9,9,0,5,0,0] 

提示：

1. 对于链表中的每个节点，1 <= node.val <= 10^9
2. 给定列表的长度在 [0, 10000] 范围内

---

552ms

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public var val: Int
 *     public var next: ListNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.next = nil
 *     }
 * }
 */
class Solution {
    func nextLargerNodes(_ head: ListNode?) -> [Int] {
        guard let head = head else { return [] }
        var result = [0]
        var stack = [(0, head)]
        while let (lastIdx, lastNode) = stack.last, let curr = lastNode.next {
            result.append(0)
            if curr.val > lastNode.val {
                while stack.count > 0 {
                    if let (idx, listNode) = stack.last, curr.val > listNode.val {
                        stack.removeLast()
                        result[idx] = curr.val
                    } else {
                        break
                    }
                }
            }
            stack.append((lastIdx + 1, curr))
        }
        return result
    }
}

604ms

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public var val: Int
 *     public var next: ListNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.next = nil
 *     }
 * }
 */
class Solution {
    func nextLargerNodes(_ head: ListNode?) -> [Int] {
        guard let head = head else { return [] }
        
        var results = [Int]()
        var curr: ListNode? = head
        while curr != nil {
            results.append(0)
            curr = curr?.next
        }
        
        var stack = [(Int, Int)]()
        
        curr = head
        var i = 0
        while let this = curr {
            while let last = stack.last, this.val > last.1 {
                stack.removeLast()
                results[last.0] = this.val
            }
            
            stack.append((i, this.val))
            i += 1
            curr = this.next
        }
        
        return results
    }
}

---

636ms

class Solution {
    func nextLargerNodes(_ head: ListNode?) -> [Int] {
        var arr = [Int]()
        var node = head
        while let n = node {
            arr.append(n.val)
            node = n.next
        }
        var stack = Stack()
        var ans = [Int](repeating: 0, count: arr.count)
        for (index, num) in arr.enumerated().reversed() {
            while let top = stack.top(),
                top <= num {
                    stack.pop()
            }
            if let top = stack.top() {
                ans[index] = top
            }
            stack.push(num)
        }
        return ans
    }
}

struct Stack {
    private var arr = [Int]()
    init() {}
    var count: Int {
        return arr.count
    }
    var isEmpty: Bool {
        return arr.isEmpty
    }
    mutating func push(_ n: Int) {
        arr.append(n)
    }
    func top() -> Int? {
        return arr.last
    }
    mutating func pop() -> Int? {
        if isEmpty { return nil }
        return arr.removeLast()
    }
}

---

644ms

class Solution {
    func length(_ head:ListNode?) -> Int
    {
        var curr = head
        var count = 0
        while curr != nil
        {
            curr = curr?.next
            count += 1
        }
        return count
    }
    
    func nextLargerNodes(_ head: ListNode?) -> [Int] {
        if head == nil
        {
            return []
        }
        if head?.next == nil
        {
            return [0]
        }
        
        var curr = head
        
        var len = length(head)
        
        var list : [Int] = []
        
        var stk = Stack<ListNode>()
        
        while curr != nil
        {
            while !stk.isEmpty() && stk.peek().val < curr!.val
            {
                var poppedItem = stk.pop()
                poppedItem.val = curr!.val
            }
            stk.push(curr!)
            curr = curr?.next
        }
        
        while !stk.isEmpty()
        {
            stk.pop().val = 0
        }
        
        curr = head
        while curr != nil
        {
            list.append(curr!.val)
            curr = curr?.next
        }
        return list
    }
}

struct Stack<T>
{
    var elements:[T] = []
    mutating func push(_ item:T)
    {
        elements.append(item)
    }
    mutating func pop() -> T
    {
       return elements.removeLast() 
    }
    func isEmpty() -> Bool
    {
        return elements.isEmpty
    }
    func peek() -> T
    {
       return elements.last!
    }
}

---

Runtime: 764 ms

Memory Usage: 21.3 MB

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public var val: Int
 *     public var next: ListNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.next = nil
 *     }
 * }
 */
class Solution {
    var ret:[Int] = [Int]()
    var d:[(Int,Int)] = [(Int,Int)]()
    var ans:[Int] = [Int]()
    
    func nextLargerNodes(_ head: ListNode?) -> [Int] {
        var head = head
        while(head != nil)
        {
            ret.append(head!.val)
            head = head?.next
        }
        for i in stride(from:ret.count - 1,through:0,by:-1)
        {
            while(d.count != 0 && d.first!.0 <= ret[i])
            {
                
                d.removeFirst()                
            }
            if d.count != 0
            {
                ans.append(d.first!.0)
            }
            else
            {
                ans.append(0)
            }
            d.insert((ret[i],i),at:0)
        }
        return ans.reversed()
    }
}