[Swift]LeetCode975. 奇偶跳 | Odd Even Jump

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

You are given an integer array A.  From some starting index, you can make a series of jumps.  The (1st, 3rd, 5th, ...) jumps in the series are called odd numbered jumps, and the (2nd, 4th, 6th, ...) jumps in the series are called even numbered jumps.

You may from index i jump forward to index j (with i < j) in the following way:

• During odd numbered jumps (ie. jumps 1, 3, 5, ...), you jump to the index j such that A[i] <= A[j] and A[j] is the smallest possible value.  If there are multiple such indexes j, you can only jump to the smallest such index j.
• During even numbered jumps (ie. jumps 2, 4, 6, ...), you jump to the index j such that A[i] >= A[j] and A[j] is the largest possible value.  If there are multiple such indexes j, you can only jump to the smallestsuch index j.
• (It may be the case that for some index i, there are no legal jumps.)

A starting index is good if, starting from that index, you can reach the end of the array (index A.length - 1) by jumping some number of times (possibly 0 or more than once.)

Return the number of good starting indexes. 

Example 1:

Input: [10,13,12,14,15]
Output: 2
Explanation: 
From starting index i = 0, we can jump to i = 2 (since A[2] is the smallest among A[1], A[2], A[3], A[4] that is greater or equal to A[0]), then we can't jump any more.
From starting index i = 1 and i = 2, we can jump to i = 3, then we can't jump any more.
From starting index i = 3, we can jump to i = 4, so we've reached the end.
From starting index i = 4, we've reached the end already.
In total, there are 2 different starting indexes (i = 3, i = 4) where we can reach the end with some number of jumps.

Example 2:

Input: [2,3,1,1,4]
Output: 3
Explanation: 
From starting index i = 0, we make jumps to i = 1, i = 2, i = 3:

During our 1st jump (odd numbered), we first jump to i = 1 because A[1] is the smallest value in (A[1], A[2], A[3], A[4]) that is greater than or equal to A[0].

During our 2nd jump (even numbered), we jump from i = 1 to i = 2 because A[2] is the largest value in (A[2], A[3], A[4]) that is less than or equal to A[1].  A[3] is also the largest value, but 2 is a smaller index, so we can only jump to i = 2 and not i = 3.

During our 3rd jump (odd numbered), we jump from i = 2 to i = 3 because A[3] is the smallest value in (A[3], A[4]) that is greater than or equal to A[2].

We can't jump from i = 3 to i = 4, so the starting index i = 0 is not good.

In a similar manner, we can deduce that:
From starting index i = 1, we jump to i = 4, so we reach the end.
From starting index i = 2, we jump to i = 3, and then we can't jump anymore.
From starting index i = 3, we jump to i = 4, so we reach the end.
From starting index i = 4, we are already at the end.
In total, there are 3 different starting indexes (i = 1, i = 3, i = 4) where we can reach the end with some number of jumps.

Example 3:

Input: [5,1,3,4,2]
Output: 3
Explanation: 
We can reach the end from starting indexes 1, 2, and 4. 

Note:

1. 1 <= A.length <= 20000
2. 0 <= A[i] < 100000

---

给定一个整数数组 A，你可以从某一起始索引出发，跳跃一定次数。在你跳跃的过程中，第 1、3、5... 次跳跃称为奇数跳跃，而第 2、4、6... 次跳跃称为偶数跳跃。

你可以按以下方式从索引 i 向后跳转到索引 j（其中 i < j）：

• 在进行奇数跳跃时（如，第 1，3，5... 次跳跃），你将会跳到索引 j，使得 A[i] <= A[j]，A[j] 是可能的最小值。如果存在多个这样的索引 j，你只能跳到满足要求的最小索引 j 上。
• 在进行偶数跳跃时（如，第 2，4，6... 次跳跃），你将会跳到索引 j，使得 A[i] => A[j]，A[j] 是可能的最大值。如果存在多个这样的索引 j，你只能跳到满足要求的最小索引 j 上。
• （对于某些索引 i，可能无法进行合乎要求的跳跃。）

如果从某一索引开始跳跃一定次数（可能是 0 次或多次），就可以到达数组的末尾（索引 A.length - 1），那么该索引就会被认为是好的起始索引。

返回好的起始索引的数量。 

示例 1：

输入：[10,13,12,14,15]
输出：2
解释： 
从起始索引 i = 0 出发，我们可以跳到 i = 2，（因为 A[2] 是 A[1]，A[2]，A[3]，A[4] 中大于或等于 A[0] 的最小值），然后我们就无法继续跳下去了。
从起始索引 i = 1 和 i = 2 出发，我们可以跳到 i = 3，然后我们就无法继续跳下去了。
从起始索引 i = 3 出发，我们可以跳到 i = 4，到达数组末尾。
从起始索引 i = 4 出发，我们已经到达数组末尾。
总之，我们可以从 2 个不同的起始索引（i = 3, i = 4）出发，通过一定数量的跳跃到达数组末尾。

示例 2：

输入：[2,3,1,1,4]
输出：3
解释：
从起始索引 i=0 出发，我们依次可以跳到 i = 1，i = 2，i = 3：

在我们的第一次跳跃（奇数）中，我们先跳到 i = 1，因为 A[1] 是（A[1]，A[2]，A[3]，A[4]）中大于或等于 A[0] 的最小值。

在我们的第二次跳跃（偶数）中，我们从 i = 1 跳到 i = 2，因为 A[2] 是（A[2]，A[3]，A[4]）中小于或等于 A[1] 的最大值。A[3] 也是最大的值，但 2 是一个较小的索引，所以我们只能跳到 i = 2，而不能跳到 i = 3。

在我们的第三次跳跃（奇数）中，我们从 i = 2 跳到 i = 3，因为 A[3] 是（A[3]，A[4]）中大于或等于 A[2] 的最小值。

我们不能从 i = 3 跳到 i = 4，所以起始索引 i = 0 不是好的起始索引。

类似地，我们可以推断：
从起始索引 i = 1 出发， 我们跳到 i = 4，这样我们就到达数组末尾。
从起始索引 i = 2 出发， 我们跳到 i = 3，然后我们就不能再跳了。
从起始索引 i = 3 出发， 我们跳到 i = 4，这样我们就到达数组末尾。
从起始索引 i = 4 出发，我们已经到达数组末尾。
总之，我们可以从 3 个不同的起始索引（i = 1, i = 3, i = 4）出发，通过一定数量的跳跃到达数组末尾。

示例 3：

输入：[5,1,3,4,2]
输出：3
解释： 
我们可以从起始索引 1，2，4 出发到达数组末尾。 

提示：

1. 1 <= A.length <= 20000
2. 0 <= A[i] < 100000

---

Runtime: 224 ms

Memory Usage: 22.1 MB

class Solution {
    func oddEvenJumps(_ A: [Int]) -> Int {
        var A = A
        let maxNum:Int = rerange(&A)
        var map:[Int] = [Int](repeating:0,count:maxNum + 1)
        var res:Int = 1
        let N:Int = A.count
        map[A[N-1]] = N-1
        var odds:[Bool] = [Bool](repeating:false,count:N)
        var evens:[Bool] = [Bool](repeating:false,count:N)
        odds[N-1] = true
        evens[N-1] = true
        for i in stride(from:N - 2,through:0,by: -1)
        {
            let key:Int = A[i]
            let minGE:Int = ceilingIndex(map,key)
            let maxLE:Int = floorIndex(map,key)
            if minGE != 0 && evens[minGE]
            {
                res += 1
                odds[i] = true
            }
            if maxLE != 0 && odds[maxLE]
            {
                evens[i] = true
            }
            map[key] = i
        }
        return res
    }
    
    func rerange(_ A:inout [Int]) -> Int {
        var minNum:Int = A[0]
        var maxNum:Int = A[0]
        for v in A
        {
            if v < minNum {minNum = v}
            if v > maxNum {maxNum = v}
        }
        var map:[Int] = [Int](repeating:0,count:maxNum - minNum + 1)
        for v in A
        {
            map[v - minNum] = 1
        }
        var ix:Int = 0
        for i in 0..<map.count
        {
            if map[i] != 0
            {
                ix += 1
                map[i] = ix
            }
        }
        for i in 0..<A.count
        {
            A[i] = map[A[i] - minNum]
        }
        return ix
    }
    
    func ceilingIndex(_ map:[Int],_ v:Int) -> Int
    {
         var v = v
        while(v < map.count)
        {
            if map[v] != 0
            {
                return map[v]
            }
            v += 1
        }
        return 0
    }
    
    func floorIndex(_ map:[Int],_ v:Int) -> Int
    {
        var v = v
        while(v > 0)
        {
            if map[v] != 0
            {
                return map[v]
            }
            v -= 1
        }
        return 0
    }
}

---

428ms

class Solution {
    func oddEvenJumps(_ A: [Int]) -> Int {
        var nextHigher = Array(repeating: 0, count: A.count)        
        var stack = [Int]()
        for (i, a) in ((A.enumerated()).sorted { $0.1 < $1.1 }) {
            while !stack.isEmpty && stack.last! < i {
                nextHigher[stack.removeLast()] = i
            }
            stack.append(i)
        }
                
        var nextLower = Array(repeating: 0, count: A.count)
        stack = []
        for (i, a) in ((A.enumerated()).sorted { $0.1 > $1.1 }) {
            while !stack.isEmpty && stack.last! < i {
                nextLower[stack.removeLast()] = i
            }
            stack.append(i)
        }
        
        var higher = Array(repeating: 0, count: A.count)
        var lower = Array(repeating: 0, count: A.count)
        higher[A.count-1] = 1
        lower[A.count-1] = 1
        for i in (0..<(A.count - 1)).reversed() {
            higher[i] = lower[nextHigher[i]]
            lower[i] = higher[nextLower[i]]
        }
        
        return higher.reduce(0, +)
    }
}

---

444ms

class Solution {
    func oddEvenJumps(_ A: [Int]) -> Int {
        guard A.count > 1 else { return A.count }
        
        var map = [(Int, Int)]()
        for (index, item) in A.enumerated() {
            map.append((item, index))
        }
        
        let nextHeigher = generateNextHeigher(map)
        let nextLower = generateNextLower(map)
        
        var heigher = Array(repeating: 0, count: A.count)
        var lower = Array(repeating: 0, count: A.count)
        heigher[A.count - 1] = 1
        lower[A.count - 1] = 1
        
        for i in (0..<A.count - 1).reversed() {
            heigher[i] = lower[nextHeigher[i]]
            lower[i] = heigher[nextLower[i]]
        }
        
        return heigher.reduce(0, +)
        
    }
    
    func generateNextHeigher(_ map: [(Int, Int)]) -> [Int] {
        let map = map.sorted {
            if $0.0 == $1.0 { return $0.1 < $1.1 }
            return $0.0 < $1.0
        }
        
        var nextHeigher = Array(repeating: 0, count: map.count)
        var stack = [Int]()
        
        for (item, index) in map {
            while stack.count > 0 && stack.last! < index {
                nextHeigher[stack.popLast()!] = index
            }
            stack.append(index)
        }
        
        return nextHeigher
    }
    
    func generateNextLower(_ map: [(Int, Int)]) -> [Int] {
        let map = map.sorted {
            if $0.0 == $1.0 { return $0.1 < $1.1 }
            return $0.0 > $1.0
        }
        
        var nextLower = Array(repeating: 0, count: map.count)
        var stack = [Int]()
        
        for (item, index) in map {
            while stack.count > 0 && stack.last! < index {
                nextLower[stack.popLast()!] = index
            }
            stack.append(index)
        }
        
        return nextLower
    }
}

---

800ms

class Solution {
    private struct Record: CustomStringConvertible {
        var oddFeasible: Bool
        var evenFeasible: Bool
        
        init() {
            self.oddFeasible = false
            self.evenFeasible = false
        }
        
        var description: String {
            return "(oddFeasible) + (evenFeasible)"
        }
    }
    
    func oddEvenJumps(_ A: [Int]) -> Int {
        let path = searchPath(A)
        var records = [Record]()
        
        var lastRecord = Record()
        lastRecord.oddFeasible = true
        lastRecord.evenFeasible = true
        records.append(lastRecord)
        
        for idx in stride(from: A.count-1, to: 0, by: -1) {
            var record = Record()
            
            let nextJumpByOdd = path.oddPath[idx-1]
            if nextJumpByOdd >= 0 {
                record.oddFeasible = records[A.count - 1 - nextJumpByOdd].evenFeasible
            } else {
                record.oddFeasible = false
            }
            
            let nextJumpByEven = path.evenPath[idx-1]
            if nextJumpByEven >= 0 {
                record.evenFeasible = records[A.count - 1 - nextJumpByEven].oddFeasible
            } else {
                record.evenFeasible = false
            }
            
            records.append(record)
        }
        
        return records.reduce(0) {
            if $1.oddFeasible {
                return $0 + 1
            } else {
                return $0
            }
        }
    }
    
    struct Path {
        var evenPath: [Int]
        var oddPath: [Int]
        
        init() {
            oddPath = []
            evenPath = []
        }
    }
    
    struct Node: Comparable, Equatable {
        let num: Int
        let idx: Int
        
        static func <(_ lhs: Node, _ rhs: Node) -> Bool {
            return lhs.num < rhs.num
        }
        
        static func ==(_ lhs: Node, _ rhs: Node) -> Bool {
            return lhs.num == rhs.num
        }
    }
    
    private func searchPath(_ A: [Int]) -> Path {
        var path = Path()
        var sortedSuffix = [Node]()
        
        for idx in stride(from: A.count, to: 0, by: -1) {
            let node = Node(num: A[idx-1], idx: idx-1)
            let index = sortedSuffix.sortedInsert(node)
            if index < sortedSuffix.count-1 {
                let rightNode = sortedSuffix[index+1]
                path.oddPath.insert(rightNode.idx, at: 0)
                if rightNode == node {
                    path.evenPath.insert(rightNode.idx, at: 0)
                    continue
                }
            } else {
                path.oddPath.insert(-1, at: 0)
            }
            
            if index > 0 {
                let leftVal = sortedSuffix[index - 1]
                var leftIdx = index - 2
                while leftIdx >= 0 && leftVal == sortedSuffix[leftIdx] {
                    leftIdx = leftIdx - 1
                }
                
                let leftNode = sortedSuffix[leftIdx + 1]
                path.evenPath.insert(leftNode.idx, at: 0)
            } else {
                path.evenPath.insert(-1, at: 0)
            }
        }
        
        return path
    }
}

extension Array where Element: Comparable {
    mutating func sortedInsert(_ elm: Element) -> Int {
        if count == 0 {
            append(elm)
            return 0
        }
        
        if count == 1 {
            if elm <= self[0] {
                insert(elm, at: 0)
                return 0
            } else {
                append(elm)
                return 1
            }
        }
        
        if count > 1 {
            if elm <= self[0] {
                insert(elm, at: 0)
                return 0
            } else if elm > self[count-1] {
                insert(elm, at: count)
                return count-1
            }
        }
        
        let idx = binarySearch(elm, 0, count-1)
        insert(elm, at: idx)
        return idx
    }
    
    // Invariant: start < elm, end >= elm, end != start
    private func binarySearch(_ elm: Element, _ start: Int, _ end: Int) -> Int {
        if end - start == 1 {
            return end
        }
        
        let mid: Int = (start + end) / 2
        if self[mid] < elm {
            return binarySearch(elm, mid, end)
        } else if self[mid] > elm {
            return binarySearch(elm, start, mid)
        } else {
            return mid
        }
    }
}

---

2328ms

class Solution {
    func oddEvenJumps(_ A: [Int]) -> Int {
        guard A.count > 0 else { return 0 }
        
        var map = [Int: Int]()
        
        let tree = AVLTree<Int>()
        
        var minMaxArr: [Int?] = Array(repeating: nil, count: A.count)
        var maxMinArr: [Int?] = Array(repeating: nil, count: A.count)
        
        var i = A.count - 1
        while i >= 0 {
            let this = A[i]
            
            if let node = tree.root?.find(to: this, rule: .closestRight) {
                minMaxArr[i] = map[node.value]
            }
            
            if let node = tree.root?.find(to: this, rule: .closestLeft) {
                maxMinArr[i] = map[node.value]
            }
            
            tree.add(value: this)
            map[this] = i
            i -= 1
        }
        
        var odd = Array(repeating: 0, count: A.count)
        var even = Array(repeating: 1, count: A.count)
        
        for i in 0..<A.count {
            if even[i] > 0, let smallestLarger = minMaxArr[i] {
                odd[smallestLarger] += even[i]
            }
            
            if odd[i] > 0, let largestSmaller = maxMinArr[i] {
                even[largestSmaller] += odd[i]
            }
        }
        
        return odd[A.count - 1] + even[A.count - 1]
    }
}




open class AVLTree<ValueT: Comparable>: Equatable {
    // MARK: - Properties
    fileprivate(set) var root: Node?
    
    // MARK: - Operations
    public var height: Int { return root?.height ?? -1 }
    public var isEmpty: Bool { return root == nil }
    
    /// - Complexity: O(n)
    public var count: Int { return root?.count ?? 0 }
    
    /// Override to provide a different node type
    open func node(for value: ValueT) -> Node {
        return Node(value: value)
    }
    
    /// Returns `false` when no insertion was performed.
    /// - Complexity: O(log n)
    @discardableResult
    open func add(node: Node) -> Bool {
        guard node.tree == nil || node.tree === self else {
            assertionFailure("Node already belongs to another tree")
            return false
        }
        
        node.tree = self
        guard let root = root else {
            self.root = node
            return true
        }
        return root.add(node: node)
    }
    
    /// - Complexity: O(log n)
    public func add(value: ValueT) {
        add(node: node(for: value))
    }
    
    /// - Complexity: O(log n)
    public func find(value: ValueT) -> Node? {
        return root?.find(to: value, rule: .exact)
    }
    
    /// - Complexity: O(*log n*)
    public func min() -> ValueT? { return root?.findMin()?.value }
    /// - Complexity: O(*log n*)
    public func max() -> ValueT? { return root?.findMax()?.value }
    
    /// - Complexity: O(log n)
    open func remove(node: Node) {
        guard node.ancestor === root else {
            // Must be a node under this tree
            return
        }
        
        defer {
            node.parent?.updateProperties()
            node.parent?.restoreBalanceAfterRemoval()
        }
        
        switch (node.left, node.right) {
        case (nil, nil):
            // No children, no-one will mourn its demise
            node.replaceInParent(with: nil)
            
        case let (leftChild, nil):
            // Heir to the throne
            node.replaceInParent(with: leftChild)
        case let (nil, rightChild):
            node.replaceInParent(with: rightChild)
            
        default:
            guard let successor = node.successor else {
                return
            }
            remove(node: successor)
            successor.left = node.left
            successor.right = node.right
            // Old node is dead, long live the successor
            node.replaceInParent(with: successor)
            
            successor.updateProperties()
        }
    }
    
    /// - Complexity: O(1)
    open func removeAll() {
        root = nil // Ez game
    }
    
    /// - Complexity: O(log n)
    @discardableResult
    public func remove(value: ValueT) -> Node? {
        guard let removedNode = root?.find(to: value, rule: .exact) else {
            return nil
        }
        remove(node: removedNode)
        return removedNode
    }
    
    // MARK: - Node Class
    open class Node: Equatable, CustomStringConvertible {
        public let value: ValueT
        
        fileprivate(set) weak var parent: Node?
        fileprivate(set) weak var tree: AVLTree<ValueT>?
        public fileprivate(set) var left: Node? {
            didSet { left?.parent = self }
        }
        public fileprivate(set) var right: Node? {
            didSet { right?.parent = self }
        }
        public private(set) var height: Int = 0
        
        public init(value: ValueT) {
            self.value = value
        }
        
        open func node(for value: ValueT) -> AVLTree.Node {
            return AVLTree.Node(value: value)
        }
        
        open func updateProperties() {
            updateHeight()
        }
        
        // MARK: CustomStringConvertible
        public var description: String {
            return String(describing: value)
        }
    }
}

// MARK: - Node Implementations
extension AVLTree.Node {
    public var isRoot: Bool { return parent == nil }
    
    public var ancestor: AVLTree.Node {
        return parent?.ancestor ?? self
    }
    
    /// - Complexity: O(n)
    public var count: Int {
        return 1 + (left?.count ?? 0) + (right?.count ?? 0)
    }
    
    var leftHeight: Int { return left?.height ?? -1 }
    var rightHeight: Int { return right?.height ?? -1 }
    
    @discardableResult
    func add(node: AVLTree.Node) -> Bool {
        guard self.value != node.value else {
            // Value already exists
            return false
        }
        
        var didInsert = false
        
        if node.value < self.value {
            if let left = left {
                didInsert = left.add(node: node)
            } else {
                left = node
                node.parent = self
                didInsert = true
            }
        } else {
            if let right = right {
                didInsert = right.add(node: node)
            } else {
                right = node
                node.parent = self
                didInsert = true
            }
        }
        guard didInsert else { return false }
        
        updateProperties()
        restoreBalance()
        return true
    }
    
    private func updateHeight() {
        height = max(left?.height ?? -1, right?.height ?? -1) + 1
    }
    
    func add(value: ValueT) {
        add(node: node(for: value))
    }
    
    enum QueryRule {
        case exact
        case closest
        case closestLeft
        case closestRight
    }
    
    func find(to value: ValueT, rule: QueryRule) -> AVLTree.Node? {
        if value == self.value { return self }
        switch rule {
        case .exact:
            if value < self.value {
                return left?.find(to: value, rule: rule)
            } else {
                return right?.find(to: value, rule: rule)
            }
        case .closest:
            if value < self.value { 
                return left?.find(to: value, rule: rule) ?? self
            } else {
                return right?.find(to: value, rule: rule) ?? self
            }
        case .closestLeft:
            if value < self.value {
                return left?.find(to: value, rule: rule)
            } else {
                return right?.find(to: value, rule: rule) ?? self
            }
        case .closestRight:
            if value < self.value {
                return left?.find(to: value, rule: rule) ?? self
            } else {
                return right?.find(to: value, rule: rule)
            }
        }
    }
    
    func replaceInParent(with anotherNode: AVLTree.Node?) {
        if let parent = parent {
            if parent.left?.value == self.value {
                parent.left = anotherNode
                anotherNode?.parent = parent
            } else if parent.right?.value == self.value {
                parent.right = anotherNode
                anotherNode?.parent = parent
            }
        }
            // Self is root! Update the tree instead
        else if let tree = tree, tree.root?.value == self.value {
            tree.root = anotherNode
            anotherNode?.parent = nil
        }
    }
    
    func findMin() -> AVLTree.Node? {
        guard let left = left else { return self }
        return left.findMin()
    }
    
    func findMax() -> AVLTree.Node? {
        guard let right = right else { return self }
        return right.findMax()
    }
}

// MARK: - Traversals
extension AVLTree {
    enum Traversal {
        case preOrder
        case inOrder
        case postOrder
    }
    
    func traverse(_ traversal: Traversal, execute block: (AVLTree.Node) -> Void) {
        guard let root = root else { return }
        switch traversal {
        case .inOrder: root.traverseInOrder(execute: block)
        case .preOrder: root.traversePreOrder(execute: block)
        case .postOrder: root.traversePostOrder(execute: block)
        }
    }
}

extension AVLTree.Node {
    fileprivate func traverseInOrder(execute block: (AVLTree.Node) -> Void) {
        left?.traverseInOrder(execute: block)
        block(self)
        right?.traverseInOrder(execute: block)
    }
    
    fileprivate func traversePreOrder(execute block: (AVLTree.Node) -> Void) {
        block(self)
        left?.traversePreOrder(execute: block)
        right?.traversePreOrder(execute: block)
    }
    
    fileprivate func traversePostOrder(execute block: (AVLTree.Node) -> Void) {
        left?.traversePostOrder(execute: block)
        right?.traversePostOrder(execute: block)
        block(self)
    }
}

// MARK: - More Operations
extension AVLTree {
    func findSuccessor(of value: ValueT) -> AVLTree.Node? {
        guard let root = root else { return nil }
        let closestNode = root.find(to: value, rule: .closest)!
        if closestNode.value > value { return closestNode }
        
        guard let closestSuccesor = closestNode.successor else { return nil }
        return closestSuccesor.value > value ? closestSuccesor : nil
    }
    
    func findPredecessor(of value: ValueT) -> AVLTree.Node? {
        guard let root = root else { return nil }
        let closestNode = root.find(to: value, rule: .closest)!
        if closestNode.value < value { return closestNode }
        
        guard let closestPredecessor = closestNode.predecessor else { return nil }
        return closestPredecessor.value < value ? closestPredecessor : nil
    }
}

extension AVLTree.Node {
    var successor: AVLTree.Node? {
        if let right = right { return right.findMin() }
        
        var currentParent = parent
        var currentChild = self
        while let parent = currentParent, currentChild.value == parent.right?.value {
            currentChild = parent
            currentParent = currentChild.parent
        }
        return currentParent
    }
    
    var predecessor: AVLTree.Node? {
        if let left = left { return left.findMax() }
        
        var currentParent = parent
        var currentChild = self
        while let parent = currentParent, currentChild.value == parent.left?.value {
            currentChild = parent
            currentParent = currentChild.parent
        }
        return currentParent
    }
}

// MARK: - Rotations
fileprivate extension AVLTree.Node {
    private var isOutOfBalance: Bool {
        return abs(leftHeight - rightHeight) > 1
    }
    
    private enum BalanceState {
        case perfectlyBalanced
        case leftHeavy
        case rightHeavy
    }
    
    private var balanceState: BalanceState {
        let diff = leftHeight - rightHeight
        if diff == 0 { return .perfectlyBalanced }
        else if diff > 0 { return .leftHeavy }
        else { return .rightHeavy }
    }
    
    private func restoreBalance() {
        guard isOutOfBalance else { return }
        
        if let left = left, left.isOutOfBalance {
            left.restoreBalance()
        }
        if let right = right, right.isOutOfBalance {
            right.restoreBalance()
        }
        
        // It is `self` that needs to balance itself
        if case .leftHeavy = balanceState, let left = left {
            switch left.balanceState {
            case .perfectlyBalanced, .leftHeavy:
                rotateRight()
            case .rightHeavy:
                left.rotateLeft()
                rotateRight()
            }
        } else if case .rightHeavy = balanceState, let right = right {
            switch right.balanceState {
            case .perfectlyBalanced, .rightHeavy:
                rotateLeft()
            case .leftHeavy:
                right.rotateRight()
                rotateLeft()
            }
        }
    }
    
    fileprivate func restoreBalanceAfterRemoval() {
        restoreBalance()
        
        guard let parent = parent else { return }
        parent.updateProperties()
        parent.restoreBalanceAfterRemoval()
    }
    
    private func rotateRight() {
        guard let left = left else { return }
        
        left.parent = self.parent
        self.replaceInParent(with: left)
        self.parent = left
        self.left = left.right
        left.right = self
        
        updateProperties()
        left.updateProperties()
    }
    
    private func rotateLeft() {
        guard let right = right else { return }
        
        right.parent = self.parent
        self.replaceInParent(with: right)
        self.parent = right
        self.right = right.left
        right.left = self
        
        updateProperties()
        right.updateProperties()
    }
}

// MARK: - Equatable
extension AVLTree {
    public static func == (lhs: AVLTree, rhs: AVLTree) -> Bool {
        return lhs.root == rhs.root
    }
}

extension AVLTree.Node {
    public static func == (lhs: AVLTree.Node, rhs: AVLTree.Node) -> Bool {
        return lhs.value == rhs.value && lhs.left == rhs.left && lhs.right == rhs.right
    }
}

// MARK: - Sequence
extension AVLTree: Sequence {
    public typealias Element = ValueT
    public typealias Iterator = Queue<ValueT>
    
    public func makeIterator() -> AVLTree<ValueT>.Iterator {
        var queue = Queue<ValueT>()
        traverse(.inOrder) { node in queue.enqueue(node.value) }
        return queue
    }
}

// MARK: - Debugging
extension AVLTree: CustomStringConvertible {
    private func diagram<ValueT>(for node: AVLTree<ValueT>.Node?, top: String = "", root: String = "", bottom: String = "") -> String {
        guard let node = node else { return root + "•
" }
        if node.left == nil && node.right == nil {
            return root + "■(node)
"
        }
        return diagram(for: node.right, top: top + "  ", root: top + "┌─", bottom: top + "│ ") +
            root + "■(node)
" +
            diagram(for: node.left, top: bottom + "│ ", root: bottom + "└─", bottom: bottom + "  ")
        
    }
    
    public var description: String {
        return diagram(for: root)
    }
}

public struct Queue<T> {
    fileprivate var array: [T?]
    fileprivate var head = 0
    
    public init(_ array: [T?] = [T?]()) {
        self.array = array
    }
    
    public var isEmpty: Bool {
        return count == 0
    }
    
    public var count: Int {
        return array.count - head
    }
    
    public mutating func enqueue(_ element: T) {
        array.append(element)
    }
    
    public mutating func dequeue() -> T? {
        guard head < array.count, let element = array[head] else { return nil }
        
        array[head] = nil
        head += 1
        
        let percentage = Double(head)/Double(array.count)
        if array.count > 50 && percentage > 0.25 {
            array.removeFirst(head)
            head = 0
        }
        
        return element
    }
    
    public var front: T? {
        if isEmpty {
            return nil
        } else {
            return array[head]
        }
    }
    
    @discardableResult
    public mutating func removeAll() -> [T] {
        let elements = array[head..<array.count]
        array = []
        head = 0
        return elements.compactMap { $0 }
    }
    
    public func clone() -> Queue<T> {
        var clone = Queue<T>()
        clone.array = Array(array[head..<array.count])
        assert(clone.head == 0)
        return clone
    }
}

// MARK: - Codable
extension Queue: Codable where T: Codable {
    public func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        if head == 0 {
            try container.encode(array.compactMap { $0 })
        } else {
            try container.encode(Array(array[head..<array.count].compactMap { $0 }))
        }
    }
    
    public init(from decoder: Decoder) throws {
        head = 0
        let container = try decoder.singleValueContainer()
        array = try container.decode([T].self)
    }
}

// MARK: - Sequence
extension Queue: Sequence {
    public func makeIterator() -> Queue<T> {
        return clone()
    }
}

extension Queue: IteratorProtocol {
    public typealias Element = T
    
    public mutating func next() -> T? {
        return dequeue()
    }
}

extension Queue: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String {
        var desc: String = "("
        for offset in 0..<count {
            defer { if offset == count - 1 { desc += "
" } }
            guard let element = array[head + offset] else { continue }
            desc += "
	[(offset)] (element)"
        }
        desc += ")"
        return desc
    }
    
    public var debugDescription: String {
        return description
    }
}