[Swift]LeetCode501. 二叉搜索树中的众数 | Find Mode in Binary Search Tree

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

Given a binary search tree (BST) with duplicates, find all the mode(s) (the most frequently occurred element) in the given BST.

Assume a BST is defined as follows:

• The left subtree of a node contains only nodes with keys less than or equal to the node's key.
• The right subtree of a node contains only nodes with keys greater than or equal to the node's key.
• Both the left and right subtrees must also be binary search trees.

 For example:

Given BST [1,null,2,2],

   1
    
     2
    /
   2

return [2].

Note: If a tree has more than one mode, you can return them in any order.

Follow up: Could you do that without using any extra space? (Assume that the implicit stack space incurred due to recursion does not count).

---

 给定一个有相同值的二叉搜索树（BST），找出 BST 中的所有众数（出现频率最高的元素）。

假定 BST 有如下定义：

• 结点左子树中所含结点的值小于等于当前结点的值
• 结点右子树中所含结点的值大于等于当前结点的值
• 左子树和右子树都是二叉搜索树

例如：
给定 BST [1,null,2,2],

   1
    
     2
    /
   2

返回[2].

提示：如果众数超过1个，不需考虑输出顺序

进阶：你可以不使用额外的空间吗？（假设由递归产生的隐式调用栈的开销不被计算在内）

---

 40ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {    
    func findMode(_ root: TreeNode?) -> [Int] {
        var prev: TreeNode?
        var result: [Int] = []
        var count = 1
        var max = 0
        
        inorder(root, &prev, &result, &count, &max)
        
        return result
    }
    
    func inorder(_ node: TreeNode?, _ prev: inout TreeNode?, _ result: inout [Int], _ count: inout Int, _ max: inout Int) {
        guard let node = node else {
            return
        }
        
        inorder(node.left, &prev, &result, &count, &max)
        
        if let prev = prev, prev.val == node.val {
            count += 1
        } else {
            count = 1
        }
        
        if count >= max {
            if count > max {
                max = count
                result.removeAll()
            }
            
            result.append(node.val)
        }
        
        prev = node
        
        inorder(node.right, &prev, &result, &count, &max)
    }
}

---

44ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
  private var prev: TreeNode? = nil
  private var modes = [Int]()
  private var countMode = 0
  private var countTemp = 0

  func findMode(_ root: TreeNode?) -> [Int] {
    guard let node = root else { return modes }
    findMode(node.left)
    visitNode(node)
    findMode(node.right)
    return modes
  }

  private func visitNode(_ root: TreeNode) {
    defer { prev = root }

    guard let prev = prev else {
      if modes.isEmpty {
        modes = [root.val]
        countTemp = 1
        countMode = countTemp
      }
      return
    }

    countTemp = prev.val == root.val ? countTemp + 1 : 1

    if countTemp == countMode {
      modes += [root.val]
    } else if countMode < countTemp {
      countMode = countTemp
      modes = [root.val]
    }
  }
}

---

64ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func findMode(_ root: TreeNode?) -> [Int] {
        var maxNumCount = 0
        var currentNum: Int?
        var currentNumCount: Int?
        var modes = [Int]()
        inorderTraversal(root, &maxNumCount, &currentNum, &currentNumCount, &modes)
        return modes
    }
    
    func inorderTraversal(_ root: TreeNode?, _ maxNumCount: inout Int, _ currentNum: inout Int?, _ currentNumCount: inout Int?, _ modes: inout [Int]) {
        guard let root = root else {
            return
        }
        inorderTraversal(root.left, &maxNumCount, &currentNum, &currentNumCount, &modes)
        if root.val == currentNum {
            currentNumCount! += 1
        } else {
            currentNum = root.val
            currentNumCount = 1
        }
        if currentNumCount! > maxNumCount {
            maxNumCount = currentNumCount!
            modes = [root.val]
        } else if currentNumCount! == maxNumCount {
            modes.append(root.val)
        }
        inorderTraversal(root.right, &maxNumCount, &currentNum, &currentNumCount, &modes)
    }
}

---

84ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {

  var maxFrequency = 0
  var maxCounter = 0

  var lastValue: Int? = nil
  var lastFrequency = 0

  var result = [Int]()
  var resultIndex = 0

  func findMaxFrequency(_ root: TreeNode?) {
    if (root == nil) { return }
    
    findMaxFrequency(root?.left)
    
    if(lastValue == nil || root?.val != lastValue) {
      lastFrequency = 1
    } else {
      lastFrequency += 1
    }
    
    if(maxFrequency < lastFrequency) {
      maxFrequency = lastFrequency
      maxCounter = 1
    } else if (maxFrequency == lastFrequency) {
      maxCounter += 1
    }
    
    lastValue = root?.val
    
    findMaxFrequency(root?.right)
  }

  func fillValues(_ root: TreeNode?) {
    if (root == nil) { return }

    fillValues(root?.left)

    if(lastValue == nil || root?.val != lastValue) {
      lastFrequency = 1
    } else {
      lastFrequency += 1
    }

    if(lastFrequency == maxFrequency) {
      resultIndex += 1
      if result.count > resultIndex-1 {
        result[resultIndex-1] = root?.val ?? 0
      }
    }

    lastValue = root?.val

    fillValues(root?.right)
  }

  func findMode(_ root: TreeNode?) -> [Int] {
    findMaxFrequency(root)
    
    result = [Int](repeating: 0, count: maxCounter)
    lastValue = nil
    fillValues(root)

    return result
  }
}

---

96ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    //记录当前的“可能的众数”节点值
    var pre:Int? = nil
    //记录当前“确定的众数”出现的次数
    var maxTimes = 0 
    //记录“可能的众数”出现的次数
    var count:Int = 1
    func findMode(_ root: TreeNode?) -> [Int] {
        if root == nil {return [Int]()}
        var list:[Int] = [Int]()
        dfs(root,&list)
        
        let len = list.count
        var res:[Int] = Array(repeating: 0,count:len)
        for i in 0..<len
        {
            res[i] = list[i]
        }
        return res      
    }
    func dfs(_ node: TreeNode?,_ list: inout [Int])
    {
        if node == nil {return}
        dfs(node!.left,&list)
        if pre != nil
        {
           if node!.val == pre
            {
                count += 1
            }
            else
            {
                count = 1
            }
        }
        if count > maxTimes
        {
            //清空数组
            list = [Int]()
            list.append(node!.val)
            maxTimes = count
        }
        else if count == maxTimes
        {
           list.append(node!.val)
        }
        pre = node!.val
        dfs(node!.right,&list) 
    }
}