Runtime: 86 ms (Top 46.9%) | Memory: 54.48 MB (Top 31.0%)

Author: AnasImloul

scripts/algorithms/F/Flatten Nested List Iterator/Flatten Nested List Iterator.js

@@ -1,22 +1,73 @@
+// Runtime: 86 ms (Top 46.9%) | Memory: 54.48 MB (Top 31.0%)
+
+/**
+ * // This is the interface that allows for creating nested lists.
+ * // You should not implement it, or speculate about its implementation
+ * function NestedInteger() {
+ *
+ *     Return true if this NestedInteger holds a single integer, rather than a nested list.
+ *     @return {boolean}
+ *     this.isInteger = function() {
+ *         ...
+ *     };
+ *
+ *     Return the single integer that this NestedInteger holds, if it holds a single integer
+ *     Return null if this NestedInteger holds a nested list
+ *     @return {integer}
+ *     this.getInteger = function() {
+ *         ...
+ *     };
+ *
+ *     Return the nested list that this NestedInteger holds, if it holds a nested list
+ *     Return null if this NestedInteger holds a single integer
+ *     @return {NestedInteger[]}
+ *     this.getList = function() {
+ *         ...
+ *     };
+ * };
+ */
+/**
+ * @constructor
+ * @param {NestedInteger[]} nestedList
+ */
 var NestedIterator = function(nestedList) {
-    this.integers = []
-    this.index = 0
-    this.flatten(nestedList)
+    this.nestedList = []
+    this.ptr = 0
+    const dfs = (elem) => {
+        if(!elem.isInteger()) {
+            let list = elem.getList()
+            for(let i = 0;i<list.length;i++) {
+                dfs(list[i])
+            }
+        }else {
+            this.nestedList.push(elem.getInteger())
+        }
+    }
+    for(let i = 0;i<nestedList.length;i++) {
+        dfs(nestedList[i])
+    }
 };
+
+
+/**
+ * @this NestedIterator
+ * @returns {boolean}
+ */
 NestedIterator.prototype.hasNext = function() {
-    return this.index < this.integers.length;
+    if(this.ptr < this.nestedList.length) return true
+    else return false
 };
 
+/**
+ * @this NestedIterator
+ * @returns {integer}
+ */
 NestedIterator.prototype.next = function() {
-    return this.integers[this.index++];
+    return this.nestedList[this.ptr++]
 };
 
-NestedIterator.prototype.flatten = function(list) {
-    for(member of list){
-        if(member.isInteger()){
-            this.integers.push(member.getInteger())
-        } else {
-            this.flatten(member.getList())
-        }
-    }
-};
+/**
+ * Your NestedIterator will be called like this:
+ * var i = new NestedIterator(nestedList), a = [];
+ * while (i.hasNext()) a.push(i.next());
+*/