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

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 [1,null,2,2],

   1
         2
    /
   2

返回[2].

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

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

 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     public var val: Int
 5  *     public var left: TreeNode?
 6  *     public var right: TreeNode?
 7  *     public init(_ val: Int) {
 8  *         self.val = val
 9  *         self.left = nil
10  *         self.right = nil
11  *     }
12  * }
13  */
14 class Solution {
15     func findMode(_ root: TreeNode?) -> [Int] {
16         var prev: TreeNode?
17         var result: [Int] = []
18         var count = 1
19         var max = 0
20
21         inorder(root, &prev, &result, &count, &max)
22
23         return result
24     }
25
26     func inorder(_ node: TreeNode?, _ prev: inout TreeNode?, _ result: inout [Int], _ count: inout Int, _ max: inout Int) {
27         guard let node = node else {
28             return
29         }
30
31         inorder(node.left, &prev, &result, &count, &max)
32
33         if let prev = prev, prev.val == node.val {
34             count += 1
35         } else {
36             count = 1
37         }
38
39         if count >= max {
40             if count > max {
41                 max = count
42                 result.removeAll()
43             }
44
45             result.append(node.val)
46         }
47
48         prev = node
49
50         inorder(node.right, &prev, &result, &count, &max)
51     }
52 }

 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     public var val: Int
 5  *     public var left: TreeNode?
 6  *     public var right: TreeNode?
 7  *     public init(_ val: Int) {
 8  *         self.val = val
 9  *         self.left = nil
10  *         self.right = nil
11  *     }
12  * }
13  */
14 class Solution {
15   private var prev: TreeNode? = nil
16   private var modes = [Int]()
17   private var countMode = 0
18   private var countTemp = 0
19
20   func findMode(_ root: TreeNode?) -> [Int] {
21     guard let node = root else { return modes }
22     findMode(node.left)
23     visitNode(node)
24     findMode(node.right)
25     return modes
26   }
27
28   private func visitNode(_ root: TreeNode) {
29     defer { prev = root }
30
31     guard let prev = prev else {
32       if modes.isEmpty {
33         modes = [root.val]
34         countTemp = 1
35         countMode = countTemp
36       }
37       return
38     }
39
40     countTemp = prev.val == root.val ? countTemp + 1 : 1
41
42     if countTemp == countMode {
43       modes += [root.val]
44     } else if countMode < countTemp {
45       countMode = countTemp
46       modes = [root.val]
47     }
48   }
49 }

 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     public var val: Int
 5  *     public var left: TreeNode?
 6  *     public var right: TreeNode?
 7  *     public init(_ val: Int) {
 8  *         self.val = val
 9  *         self.left = nil
10  *         self.right = nil
11  *     }
12  * }
13  */
14 class Solution {
15     func findMode(_ root: TreeNode?) -> [Int] {
16         var maxNumCount = 0
17         var currentNum: Int?
18         var currentNumCount: Int?
19         var modes = [Int]()
20         inorderTraversal(root, &maxNumCount, &currentNum, &currentNumCount, &modes)
21         return modes
22     }
23
24     func inorderTraversal(_ root: TreeNode?, _ maxNumCount: inout Int, _ currentNum: inout Int?, _ currentNumCount: inout Int?, _ modes: inout [Int]) {
25         guard let root = root else {
26             return
27         }
28         inorderTraversal(root.left, &maxNumCount, &currentNum, &currentNumCount, &modes)
29         if root.val == currentNum {
30             currentNumCount! += 1
31         } else {
32             currentNum = root.val
33             currentNumCount = 1
34         }
35         if currentNumCount! > maxNumCount {
36             maxNumCount = currentNumCount!
37             modes = [root.val]
38         } else if currentNumCount! == maxNumCount {
39             modes.append(root.val)
40         }
41         inorderTraversal(root.right, &maxNumCount, &currentNum, &currentNumCount, &modes)
42     }
43 }

 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     public var val: Int
 5  *     public var left: TreeNode?
 6  *     public var right: TreeNode?
 7  *     public init(_ val: Int) {
 8  *         self.val = val
 9  *         self.left = nil
10  *         self.right = nil
11  *     }
12  * }
13  */
14 class Solution {
15
16   var maxFrequency = 0
17   var maxCounter = 0
18
19   var lastValue: Int? = nil
20   var lastFrequency = 0
21
22   var result = [Int]()
23   var resultIndex = 0
24
25   func findMaxFrequency(_ root: TreeNode?) {
26     if (root == nil) { return }
27
28     findMaxFrequency(root?.left)
29
30     if(lastValue == nil || root?.val != lastValue) {
31       lastFrequency = 1
32     } else {
33       lastFrequency += 1
34     }
35
36     if(maxFrequency < lastFrequency) {
37       maxFrequency = lastFrequency
38       maxCounter = 1
39     } else if (maxFrequency == lastFrequency) {
40       maxCounter += 1
41     }
42
43     lastValue = root?.val
44
45     findMaxFrequency(root?.right)
46   }
47
48   func fillValues(_ root: TreeNode?) {
49     if (root == nil) { return }
50
51     fillValues(root?.left)
52
53     if(lastValue == nil || root?.val != lastValue) {
54       lastFrequency = 1
55     } else {
56       lastFrequency += 1
57     }
58
59     if(lastFrequency == maxFrequency) {
60       resultIndex += 1
61       if result.count > resultIndex-1 {
62         result[resultIndex-1] = root?.val ?? 0
63       }
64     }
65
66     lastValue = root?.val
67
68     fillValues(root?.right)
69   }
70
71   func findMode(_ root: TreeNode?) -> [Int] {
72     findMaxFrequency(root)
73
74     result = [Int](repeating: 0, count: maxCounter)
75     lastValue = nil
76     fillValues(root)
77
78     return result
79   }
80 }

 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     public var val: Int
 5  *     public var left: TreeNode?
 6  *     public var right: TreeNode?
 7  *     public init(_ val: Int) {
 8  *         self.val = val
 9  *         self.left = nil
10  *         self.right = nil
11  *     }
12  * }
13  */
14 class Solution {
15     //记录当前的“可能的众数”节点值
16     var pre:Int? = nil
17     //记录当前“确定的众数”出现的次数
18     var maxTimes = 0
19     //记录“可能的众数”出现的次数
20     var count:Int = 1
21     func findMode(_ root: TreeNode?) -> [Int] {
22         if root == nil {return [Int]()}
23         var list:[Int] = [Int]()
24         dfs(root,&list)
25
26         let len = list.count
27         var res:[Int] = Array(repeating: 0,count:len)
28         for i in 0..<len
29         {
30             res[i] = list[i]
31         }
32         return res
33     }
34     func dfs(_ node: TreeNode?,_ list: inout [Int])
35     {
36         if node == nil {return}
37         dfs(node!.left,&list)
38         if pre != nil
39         {
40            if node!.val == pre
41             {
42                 count += 1
43             }
44             else
45             {
46                 count = 1
47             }
48         }
49         if count > maxTimes
50         {
51             //清空数组
52             list = [Int]()
53             list.append(node!.val)
54             maxTimes = count
55         }
56         else if count == maxTimes
57         {
58            list.append(node!.val)
59         }
60         pre = node!.val
61         dfs(node!.right,&list)
62     }
63 }

原文地址：https://www.cnblogs.com/strengthen/p/9807156.html