[Swift]LeetCode341. 压平嵌套链表迭代器 | Flatten Nested List Iterator

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

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

Given a nested list of integers, implement an iterator to flatten it.

Each element is either an integer, or a list -- whose elements may also be integers or other lists.

Example 1:
Given the list [[1,1],2,[1,1]],

By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,1,2,1,1].

Example 2:
Given the list [1,[4,[6]]],

By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,4,6].

---

给定一个嵌套的整数列表，实现一个迭代器来展平它。

每个元素要么是一个整数，要么是一个列表——其元素也可以是整数或其他列表。

例1：

给出列表[[1,1]，2，[1,1]]，

通过反复调用next，直到hasNext返回false，next返回的元素顺序应该是：[1,1,2,1,1]。

例2：

给出清单[1，[4，[6]]]，

通过重复调用next直到hasNext返回false，next返回的元素顺序应该是：[1,4,6]。

---

 52ms

/**
 * // This is the interface that allows for creating nested lists.
 * // You should not implement it, or speculate about its implementation
 * class NestedInteger {
 *     // Return true if this NestedInteger holds a single integer, rather than a nested list.
 *     public func isInteger() -> Bool
 *
 *     // Return the single integer that this NestedInteger holds, if it holds a single integer
 *     // The result is undefined if this NestedInteger holds a nested list
 *     public func getInteger() -> Int
 *
 *     // Set this NestedInteger to hold a single integer.
 *     public func setInteger(value: Int)
 *
 *     // Set this NestedInteger to hold a nested list and adds a nested integer to it.
 *     public func add(elem: NestedInteger)
 *
 *     // Return the nested list that this NestedInteger holds, if it holds a nested list
 *     // The result is undefined if this NestedInteger holds a single integer
 *     public func getList() -> [NestedInteger]
 * }
 */

class NestedIterator {

      var array = [Int]()
      var currentIterator = 0

      init(_ nestedList: [NestedInteger]) {
        flattenList(nestedList)
      }

      func flattenList(_ nestedList: [NestedInteger]) {
        for element in nestedList {
          if element.isInteger() {
            array.append(element.getInteger())
          } else {
            flattenList(element.getList())
          }
        }
      }

      func next() -> Int {
        let val = array[currentIterator]
        currentIterator += 1
        return val
      }

      func hasNext() -> Bool {
        return currentIterator < array.count
      }
}

/**
 * Your NestedIterator object will be instantiated and called as such:
 * let obj = NestedIterator(nestedList)
 * let ret_1: Int = obj.next()
 * let ret_2: Bool = obj.hasNext()
 */

---

56ms

class NestedIterator {
    private var stack = [NestedInteger]()
    private var curr = 0
    private var arr = [NestedInteger]()
    init(_ nestedList: [NestedInteger]) {
        arr = nestedList
    }
    
    
    private func flatternCurrentStack(){
        while !stack.isEmpty && !stack.last!.isInteger(){
            let list = stack.removeLast().getList()
            for i in stride(from: list.count - 1, through: 0 , by: -1){
                stack.append(list[i])
            }
        }
    }
    
    
    func next() -> Int {
        return stack.removeLast().getInteger()
    }
    
    func hasNext() -> Bool {
        flatternCurrentStack()
        while stack.isEmpty && curr < arr.count {
            stack.append(arr[curr])
            flatternCurrentStack()
            curr += 1
        }
        return !stack.isEmpty
    }
}

---

60ms

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!
    }
}
class NestedIterator {

   var stk = Stack<NestedInteger>()
    init(_ nestedList: [NestedInteger]) {
      for ni in stride(from:nestedList.count - 1, through:0, by: -1)
        {
            stk.push(nestedList[ni])
        }
    }
    
    func next() -> Int {
        return stk.pop().getInteger()
    }
    
    func hasNext() -> Bool {
        
        if stk.isEmpty()
        {
            return false
        }
        
       while !stk.isEmpty(){ 
        
        var top = stk.peek()
        if top.isInteger()
        {
            return true
        }
        else
        {
            stk.pop()
            
            var list = top.getList()
            
            for ni in stride(from:list.count - 1, through:0, by: -1)
            {
                stk.push(list[ni])
            }

        }
       }
        return false        
    }
}

---

64ms

class NestedIterator {

    var queue = [Int]()
    
    init(_ nestedList: [NestedInteger]) {
        makeQueue(nestedList)
    }
    
    func next() -> Int {
        return queue.removeFirst()
    }
    
    func hasNext() -> Bool {
        return !queue.isEmpty
    }
    
    func makeQueue(_ nestedList: [NestedInteger]) {
        for n in nestedList {
            if n.isInteger() { queue.append(n.getInteger()) }
            else { makeQueue(n.getList()) }
        }
    }
}

---

68ms

class NestedIterator {
 
    var stack : [NestedInteger]
    init(_ nestedList: [NestedInteger]) {
        stack = []
        append(nestedList)
    }
    
    func next() -> Int {
        var last = stack.first!
        stack.removeFirst()
        return last.getInteger()
        
    }
    
    func append(_ nestedList: [NestedInteger]){
        for ni in  nestedList{
            if ni.isInteger(){
                stack.append(ni)
            } else{
                append(ni.getList())
            }
        }
    }
    func hasNext() -> Bool {
        guard stack.count > 0 else{
            return false
        }
        return true
    }
}

---

72ms

class NestedIterator {

    init(_ nestedList: [NestedInteger]) {
        q =  [NestedInteger]()
        for a in nestedList {
            q.append(a)
        }
    }
    
    func next() -> Int {
        return q.removeFirst().getInteger()
    }
    
    func hasNext() -> Bool {
        while !q.isEmpty {
            let t = q.first!
            if t.isInteger() { return true }
            q.removeFirst()
            for a in t.getList().reversed() {
                q.insert(a, at: 0)
            }
        }
        return false
    }
    private var q: [NestedInteger]
}

---

76ms

class NestedIterator {

    var flattendList: [Int]!
    
    init(_ nestedList: [NestedInteger]) {
        flattendList = flatten(nestedList)
    }
    
    func flatten(_ list: [NestedInteger]) -> [Int] {
        var flatList: [Int] = []
        
        for content in list {
            if content.isInteger() { flatList.append(content.getInteger()) }
            // else { flatList += NestedIterator(content.getList()).flattendList }
            else { flatList += flatten(content.getList()) }
        }
        
        return flatList
    }
    
    func next() -> Int {
        return flattendList.removeFirst()
    }
    
    func hasNext() -> Bool {
        return !flattendList.isEmpty
    }
}

---

80ms

class NestedIterator {
    
    var data = [Int]()

    init(_ nestedList: [NestedInteger]) {
        self.flattenList(nestedList)
    }
    
    func next() -> Int {
        return self.data.removeFirst()
    }
    
    func hasNext() -> Bool {
        return self.data.count > 0
    }
    
    private func flattenList(_ nestedList:[NestedInteger]){
        for n in nestedList{
            if n.isInteger(){
                self.data.append(n.getInteger())
            }else{
                self.flattenList(n.getList())
            }
        }
    }
}