[Swift]LeetCode729. 我的日程安排表 I | My Calendar I

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

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

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

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

Implement a MyCalendar class to store your events. A new event can be added if adding the event will not cause a double booking.

Your class will have the method, book(int start, int end). Formally, this represents a booking on the half open interval [start, end), the range of real numbers x such that start <= x < end.

A double booking happens when two events have some non-empty intersection (ie., there is some time that is common to both events.)

For each call to the method MyCalendar.book, return true if the event can be added to the calendar successfully without causing a double booking. Otherwise, return false and do not add the event to the calendar.

Your class will be called like this: MyCalendar cal = new MyCalendar();MyCalendar.book(start, end)

Example 1:

MyCalendar();
MyCalendar.book(10, 20); // returns true
MyCalendar.book(15, 25); // returns false
MyCalendar.book(20, 30); // returns true
Explanation: 
The first event can be booked.  The second can't because time 15 is already booked by another event.
The third event can be booked, as the first event takes every time less than 20, but not including 20. 

Note:

• The number of calls to MyCalendar.book per test case will be at most 1000.
• In calls to MyCalendar.book(start, end), start and end are integers in the range [0, 10^9].

---

实现一个 MyCalendar 类来存放你的日程安排。如果要添加的时间内没有其他安排，则可以存储这个新的日程安排。

MyCalendar 有一个 book(int start, int end)方法。它意味着在 start 到 end 时间内增加一个日程安排，注意，这里的时间是半开区间，即 [start, end), 实数 x 的范围为，  start <= x < end。

当两个日程安排有一些时间上的交叉时（例如两个日程安排都在同一时间内），就会产生重复预订。

每次调用 MyCalendar.book方法时，如果可以将日程安排成功添加到日历中而不会导致重复预订，返回 true。否则，返回 false 并且不要将该日程安排添加到日历中。

请按照以下步骤调用 MyCalendar 类: MyCalendar cal = new MyCalendar();MyCalendar.book(start, end)

示例 1:

MyCalendar();
MyCalendar.book(10, 20); // returns true
MyCalendar.book(15, 25); // returns false
MyCalendar.book(20, 30); // returns true
解释: 
第一个日程安排可以添加到日历中.  第二个日程安排不能添加到日历中，因为时间 15 已经被第一个日程安排预定了。
第三个日程安排可以添加到日历中，因为第一个日程安排并不包含时间 20 。

说明:

• 每个测试用例，调用 MyCalendar.book 函数最多不超过 100次。
• 调用函数 MyCalendar.book(start, end)时， start 和 end 的取值范围为 [0, 10^9]。

---

552ms

class MyCalendar {
    var root: Node?
    init() {}
    
    func book(_ start: Int, _ end: Int) -> Bool {        
        if self.root == nil{
            self.root = Node(start, end)
            return true
        }
        return self.root?.insert(start: start, end: end) ?? false
    }
}

class Node {
    var start = 0
    var end = 0
    var smallLeft: Node?
    var bigRight: Node?
    init(_ start:Int, _ end:Int) {
        self.start = start
        self.end = end
    }  
    unc insert(start:Int, end:Int) -> Bool {           
        if end <= self.start {
            if self.smallLeft == nil {
                self.smallLeft = Node(start, end)
                return true
            }
            return self.smallLeft?.insert(start: start, end: end) ?? false
        }
        else if start >= self.end {
            if self.bigRight == nil {
                self.bigRight = Node(start, end)
                return true            
            }
            return self.bigRight?.insert(start: start, end: end) ?? false
        }  
        return false
    }
}
/**
 * Your MyCalendar object will be instantiated and called as such:
 * let obj = MyCalendar()
 * let ret_1: Bool = obj.book(start, end)
 */

---

556ms

class MyCalendar {
    var root: Node?
    
    init() {
        root = nil
    }
    
    func book(_ start: Int, _ end: Int) -> Bool {
        var event = Event.init(start, end)        
        if (root == nil) {
            root = Node.init(event)
            return true
        }        
        return root!.insert(root!, event)
    }
}

struct Event {
    var start: Int = 0
    var end: Int = 0
    
    init(_ start: Int, _ end: Int) {
        self.start = start
        self.end = end
    }
    
    func overlaps(_ input: Event)-> Bool {
        if (self.end <= input.start) || (self.start >= input.end) {
            return true
        }
        else {
            return false
        }
    }
}

class Node {
    var event: Event
    var left: Node?
    var right: Node?
    
    init(_ event: Event) {
        self.event = event
        self.left = nil
        self.right = nil
    }
    
    func insert(_ node: Node, _ event: Event)-> Bool {
        if (event.end <= node.event.start) {
            if node.left == nil {
                node.left = Node.init(event)
                return true
            }
            else {
                return insert(node.left!, event)
            }
        }
        else if (event.start >= node.event.end) {
            if (node.right == nil) {
                node.right = Node.init(event)
                return true
            }
            else {
                return insert(node.right!, event)
            }
        }
        else {
            return false
        }
    }
}

---

564ms

class MyCalendar {
    var tree = Tree()
    
    init() {
        
    }   

    func book(_ start: Int, _ end: Int) -> Bool {
        guard start >= 0, end >= 0, end > start else {
            return false 
        } 
        
        let node = Node((start,end))
        return tree.insert(node)        
    }
}

class Node {
    var start: Int
    var end: Int 
    var left: Node?
    var right: Node?
    init(_ book: (Int, Int)) {
        start = book.0
        end = book.1
    }
}

class Tree {    
    var root: Node?

    func insert(_ node: Node, at root: Node) -> Bool {    
        if node.start  >= root.start && node.start < root.end {
            return false 
        }
        
        if node.end <= root.start, let left = root.left {
            return insert(node, at: left)
        } else if node.start >= root.end, let right = root.right {
            return insert(node, at: right)
        } else {
            if node.end <= root.start {
                root.left = node
                return true
            }
            
            if node.start >= root.end {
                root.right = node
                return true
            }
        }
        return false
    }
    
    func insert(_ node: Node) -> Bool {
        guard let root = self.root else {
            self.root = node
            return true
        }        
        return insert(node, at: root)                
    }    
}

---

Runtime: 1104 ms

Memory Usage: 20.1 MB

class MyCalendar {
    var cal:[(Int,Int)]

    init() {
        cal = [(Int,Int)]()        
    }
    
    func book(_ start: Int, _ end: Int) -> Bool {
        for val in cal
        {
            if max(val.0, start) < min(val.1, end)
            {
                return false
            }            
        }
        cal.append((start, end))
        return true      
    }
}
/**
 * Your MyCalendar object will be instantiated and called as such:
 * let obj = MyCalendar()
 * let ret_1: Bool = obj.book(start, end)
 */