feat: add solutions to lc problem: No.1019

No.1019.Next Greater Node In Linked List

Author: yanglbme

solution/1000-1099/1019.Next Greater Node In Linked List/README.md

@@ -48,15 +48,13 @@
 
 **方法一：单调栈**
 
-我们先遍历链表，将链表中的值存入数组 `nums` 中。
+题目要求找到链表中每个节点的下一个更大的节点，即找到链表中每个节点的右边第一个比它大的节点。我们先遍历链表，将链表中的值存入数组 $nums$ 中。那么对于数组 $nums$ 中的每个元素，我们只需要找到它右边第一个比它大的元素即可。求下一个更大的元素的问题可以使用单调栈来解决。
 
-然后从后往前遍历数组 `nums`，维护一个从栈底到栈顶单调递减的栈 `stk`，遍历过程中，如果栈顶元素小于等于当前元素，则将栈顶元素出栈，直到栈顶元素大于当前元素或者栈为空。
+我们从后往前遍历数组 $nums$，维护一个从栈底到栈顶单调递减的栈 $stk$，遍历过程中，如果栈顶元素小于等于当前元素，则循环将栈顶元素出栈，直到栈顶元素大于当前元素或者栈为空。
 
-如果栈为空，则说明当前元素没有下一个更大的元素，否则当前元素的下一个更大的元素就是栈顶元素，更新答案数组 `ans`。
+如果此时栈为空，则说明当前元素没有下一个更大的元素，否则当前元素的下一个更大的元素就是栈顶元素，更新答案数组 $ans$。然后将当前元素入栈，继续遍历。
 
-然后将当前元素入栈，继续遍历。
-
-遍历结束后，返回答案数组 `ans` 即可。
+遍历结束后，返回答案数组 $ans$ 即可。
 
 时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为链表的长度。
 
@@ -202,37 +200,70 @@ func nextLargerNodes(head *ListNode) []int {
 ```js
 /**
  * Definition for singly-linked list.
- * function ListNode(val) {
- *     this.val = val;
- *     this.next = null;
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
  * }
  */
 /**
  * @param {ListNode} head
  * @return {number[]}
  */
 var nextLargerNodes = function (head) {
-    let nums = [];
-    while (head != null) {
+    const nums = [];
+    while (head) {
         nums.push(head.val);
         head = head.next;
     }
+    const stk = [];
     const n = nums.length;
-    let larger = new Array(n).fill(0);
-    let stack = [];
-    for (let i = 0; i < n; i++) {
-        let num = nums[i];
-        while (stack.length > 0 && nums[stack[stack.length - 1]] < num) {
-            larger[stack.pop()] = num;
+    const ans = new Array(n).fill(0);
+    for (let i = n - 1; i >= 0; --i) {
+        while (stk.length && stk[stk.length - 1] <= nums[i]) {
+            stk.pop();
         }
-        stack.push(i);
+        ans[i] = stk.length ? stk[stk.length - 1] : 0;
+        stk.push(nums[i]);
     }
-    return larger;
+    return ans;
 };
 ```
 
 ### **TypeScript**
 
+```ts
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+
+function nextLargerNodes(head: ListNode | null): number[] {
+    const nums: number[] = [];
+    while (head) {
+        nums.push(head.val);
+        head = head.next;
+    }
+    const stk: number[] = [];
+    const n = nums.length;
+    const ans: number[] = new Array(n).fill(0);
+    for (let i = n - 1; ~i; --i) {
+        while (stk.length && stk[stk.length - 1] <= nums[i]) {
+            stk.pop();
+        }
+        ans[i] = stk.length ? stk[stk.length - 1] : 0;
+        stk.push(nums[i]);
+    }
+    return ans;
+}
+```
+
 ```ts
 /**
  * Definition for singly-linked list.

solution/1000-1099/1019.Next Greater Node In Linked List/README_EN.md

@@ -174,37 +174,70 @@ func nextLargerNodes(head *ListNode) []int {
 ```js
 /**
  * Definition for singly-linked list.
- * function ListNode(val) {
- *     this.val = val;
- *     this.next = null;
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
  * }
  */
 /**
  * @param {ListNode} head
  * @return {number[]}
  */
 var nextLargerNodes = function (head) {
-    let nums = [];
-    while (head != null) {
+    const nums = [];
+    while (head) {
         nums.push(head.val);
         head = head.next;
     }
+    const stk = [];
     const n = nums.length;
-    let larger = new Array(n).fill(0);
-    let stack = [];
-    for (let i = 0; i < n; i++) {
-        let num = nums[i];
-        while (stack.length > 0 && nums[stack[stack.length - 1]] < num) {
-            larger[stack.pop()] = num;
+    const ans = new Array(n).fill(0);
+    for (let i = n - 1; i >= 0; --i) {
+        while (stk.length && stk[stk.length - 1] <= nums[i]) {
+            stk.pop();
         }
-        stack.push(i);
+        ans[i] = stk.length ? stk[stk.length - 1] : 0;
+        stk.push(nums[i]);
     }
-    return larger;
+    return ans;
 };
 ```
 
 ### **TypeScript**
 
+```ts
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+
+function nextLargerNodes(head: ListNode | null): number[] {
+    const nums: number[] = [];
+    while (head) {
+        nums.push(head.val);
+        head = head.next;
+    }
+    const stk: number[] = [];
+    const n = nums.length;
+    const ans: number[] = new Array(n).fill(0);
+    for (let i = n - 1; ~i; --i) {
+        while (stk.length && stk[stk.length - 1] <= nums[i]) {
+            stk.pop();
+        }
+        ans[i] = stk.length ? stk[stk.length - 1] : 0;
+        stk.push(nums[i]);
+    }
+    return ans;
+}
+```
+
 ```ts
 /**
  * Definition for singly-linked list.

solution/1000-1099/1019.Next Greater Node In Linked List/Solution.js

@@ -1,29 +1,29 @@
 /**
  * Definition for singly-linked list.
- * function ListNode(val) {
- *     this.val = val;
- *     this.next = null;
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
  * }
  */
 /**
  * @param {ListNode} head
  * @return {number[]}
  */
 var nextLargerNodes = function (head) {
-    let nums = [];
-    while (head != null) {
+    const nums = [];
+    while (head) {
         nums.push(head.val);
         head = head.next;
     }
+    const stk = [];
     const n = nums.length;
-    let larger = new Array(n).fill(0);
-    let stack = [];
-    for (let i = 0; i < n; i++) {
-        let num = nums[i];
-        while (stack.length > 0 && nums[stack[stack.length - 1]] < num) {
-            larger[stack.pop()] = num;
+    const ans = new Array(n).fill(0);
+    for (let i = n - 1; i >= 0; --i) {
+        while (stk.length && stk[stk.length - 1] <= nums[i]) {
+            stk.pop();
         }
-        stack.push(i);
+        ans[i] = stk.length ? stk[stk.length - 1] : 0;
+        stk.push(nums[i]);
     }
-    return larger;
+    return ans;
 };

solution/1000-1099/1019.Next Greater Node In Linked List/Solution.ts

@@ -10,26 +10,21 @@
  * }
  */
 
-interface Item {
-    index: number;
-    val: number;
-}
-
 function nextLargerNodes(head: ListNode | null): number[] {
-    const res: number[] = [];
-    const stack: Item[] = [];
-    let cur = head;
-    for (let i = 0; cur != null; i++) {
-        res.push(0);
-        const { val, next } = cur;
-        while (stack.length !== 0 && stack[stack.length - 1].val < val) {
-            res[stack.pop().index] = val;
+    const nums: number[] = [];
+    while (head) {
+        nums.push(head.val);
+        head = head.next;
+    }
+    const stk: number[] = [];
+    const n = nums.length;
+    const ans: number[] = new Array(n).fill(0);
+    for (let i = n - 1; ~i; --i) {
+        while (stk.length && stk[stk.length - 1] <= nums[i]) {
+            stk.pop();
         }
-        stack.push({
-            val,
-            index: i,
-        });
-        cur = next;
+        ans[i] = stk.length ? stk[stk.length - 1] : 0;
+        stk.push(nums[i]);
     }
-    return res;
+    return ans;
 }