Ordered Set - Apple Version

https://developer.apple.com/documentation/foundation/nsmutableorderedset

In this repo, the ordered set is actually not the right apple library ordered set. So, I write the one exactly the same as Apple one.

Author: remlostime

Ordered Set/AppleOrderedSet.playground/Contents.swift

@@ -0,0 +1,13 @@
+let s = AppleOrderedSet<Int>()
+
+s.add(1)
+s.add(2)
+s.add(-1)
+s.add(0)
+s.insert(4, at: 3)
+
+s.set(-1, at: 0)
+s.remove(-1)
+
+print(s.object(at: 1))
+

Ordered Set/AppleOrderedSet.playground/Sources/AppleOrderedSet.swift

@@ -0,0 +1,72 @@
+public class AppleOrderedSet<T: Hashable> {
+    private var objects: [T] = []
+    private var indexOfKey: [T: Int] = [:]
+    
+    public init() {}
+    
+    // O(1)
+    public func add(_ object: T) {
+        guard indexOfKey[object] == nil else {
+            return
+        }
+        
+        objects.append(object)
+        indexOfKey[object] = objects.count - 1
+    }
+    
+    // O(n)
+    public func insert(_ object: T, at index: Int) {
+        assert(index < objects.count, "Index should be smaller than object count")
+        assert(index >= 0, "Index should be bigger than 0")
+        
+        guard indexOfKey[object] == nil else {
+            return
+        }
+        
+        objects.insert(object, at: index)
+        indexOfKey[object] = index
+        for i in index+1..<objects.count {
+            indexOfKey[objects[i]] = i
+        }
+    }
+    
+    // O(1)
+    public func object(at index: Int) -> T {
+        assert(index < objects.count, "Index should be smaller than object count")
+        assert(index >= 0, "Index should be bigger than 0")
+        
+        return objects[index]
+    }
+    
+    // O(1)
+    public func set(_ object: T, at index: Int) {
+        assert(index < objects.count, "Index should be smaller than object count")
+        assert(index >= 0, "Index should be bigger than 0")
+        
+        guard indexOfKey[object] == nil else {
+            return
+        }
+        
+        indexOfKey.removeValue(forKey: objects[index])
+        indexOfKey[object] = index
+        objects[index] = object
+    }
+    
+    // O(1)
+    public func indexOf(_ object: T) -> Int {
+        return indexOfKey[object] ?? -1
+    }
+    
+    // O(n)
+    public func remove(_ object: T) {
+        guard let index = indexOfKey[object] else {
+            return
+        }
+        
+        indexOfKey.removeValue(forKey: object)
+        objects.remove(at: index)
+        for i in index..<objects.count {
+            indexOfKey[objects[i]] = i
+        }
+    }
+}

Ordered Set/AppleOrderedSet.playground/contents.xcplayground

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<playground version='5.0' target-platform='ios'>
+    <timeline fileName='timeline.xctimeline'/>
+</playground>

Ordered Set/AppleOrderedSet.swift

@@ -0,0 +1,72 @@
+public class AppleOrderedSet<T: Hashable> {
+    private var objects: [T] = []
+    private var indexOfKey: [T: Int] = [:]
+    
+    public init() {}
+    
+    // O(1)
+    public func add(_ object: T) {
+        guard indexOfKey[object] == nil else {
+            return
+        }
+        
+        objects.append(object)
+        indexOfKey[object] = objects.count - 1
+    }
+    
+    // O(n)
+    public func insert(_ object: T, at index: Int) {
+        assert(index < objects.count, "Index should be smaller than object count")
+        assert(index >= 0, "Index should be bigger than 0")
+        
+        guard indexOfKey[object] == nil else {
+            return
+        }
+        
+        objects.insert(object, at: index)
+        indexOfKey[object] = index
+        for i in index+1..<objects.count {
+            indexOfKey[objects[i]] = i
+        }
+    }
+    
+    // O(1)
+    public func object(at index: Int) -> T {
+        assert(index < objects.count, "Index should be smaller than object count")
+        assert(index >= 0, "Index should be bigger than 0")
+        
+        return objects[index]
+    }
+    
+    // O(1)
+    public func set(_ object: T, at index: Int) {
+        assert(index < objects.count, "Index should be smaller than object count")
+        assert(index >= 0, "Index should be bigger than 0")
+        
+        guard indexOfKey[object] == nil else {
+            return
+        }
+        
+        indexOfKey.removeValue(forKey: objects[index])
+        indexOfKey[object] = index
+        objects[index] = object
+    }
+    
+    // O(1)
+    public func indexOf(_ object: T) -> Int {
+        return indexOfKey[object] ?? -1
+    }
+    
+    // O(n)
+    public func remove(_ object: T) {
+        guard let index = indexOfKey[object] else {
+            return
+        }
+        
+        indexOfKey.removeValue(forKey: object)
+        objects.remove(at: index)
+        for i in index..<objects.count {
+            indexOfKey[objects[i]] = i
+        }
+    }
+}