Migrated over to Swift 3

Author: kelvinlauKL

Heap/Heap.swift

@@ -8,14 +8,14 @@ public struct Heap<T> {
   var elements = [T]()
 
   /** Determines whether this is a max-heap (>) or min-heap (<). */
-  private var isOrderedBefore: (T, T) -> Bool
+  fileprivate var isOrderedBefore: (T, T) -> Bool
 
   /**
    * Creates an empty heap.
    * The sort function determines whether this is a min-heap or max-heap.
    * For integers, > makes a max-heap, < makes a min-heap.
    */
-  public init(sort: (T, T) -> Bool) {
+  public init(sort: @escaping (T, T) -> Bool) {
     self.isOrderedBefore = sort
   }
 
@@ -24,9 +24,9 @@ public struct Heap<T> {
    * the elements are inserted into the heap in the order determined by the
    * sort function.
    */
-  public init(array: [T], sort: (T, T) -> Bool) {
+  public init(array: [T], sort: @escaping (T, T) -> Bool) {
     self.isOrderedBefore = sort
-    buildHeap(array)
+    buildHeap(fromArray: array)
   }
 
   /*
@@ -43,9 +43,9 @@ public struct Heap<T> {
    * Converts an array to a max-heap or min-heap in a bottom-up manner.
    * Performance: This runs pretty much in O(n).
    */
-  private mutating func buildHeap(array: [T]) {
+  fileprivate mutating func buildHeap(fromArray array: [T]) {
     elements = array
-    for i in (elements.count/2 - 1).stride(through: 0, by: -1) {
+    for i in stride(from: (elements.count/2 - 1), through: 0, by: -1) {
       shiftDown(index: i, heapSize: elements.count)
     }
   }
@@ -62,7 +62,7 @@ public struct Heap<T> {
    * Returns the index of the parent of the element at index i.
    * The element at index 0 is the root of the tree and has no parent.
    */
-  @inline(__always) func indexOfParent(i: Int) -> Int {
+  @inline(__always) func parentIndex(ofIndex i: Int) -> Int {
     return (i - 1) / 2
   }
 
@@ -71,7 +71,7 @@ public struct Heap<T> {
    * Note that this index can be greater than the heap size, in which case
    * there is no left child.
    */
-  @inline(__always) func indexOfLeftChild(i: Int) -> Int {
+  @inline(__always) func leftChildIndex(ofIndex i: Int) -> Int {
     return 2*i + 1
   }
 
@@ -80,7 +80,7 @@ public struct Heap<T> {
    * Note that this index can be greater than the heap size, in which case
    * there is no right child.
    */
-  @inline(__always) func indexOfRightChild(i: Int) -> Int {
+  @inline(__always) func rightChildIndex(ofIndex i: Int) -> Int {
     return 2*i + 2
   }
 
@@ -96,12 +96,12 @@ public struct Heap<T> {
    * Adds a new value to the heap. This reorders the heap so that the max-heap
    * or min-heap property still holds. Performance: O(log n).
    */
-  public mutating func insert(value: T) {
+  public mutating func insert(_ value: T) {
     elements.append(value)
     shiftUp(index: elements.count - 1)
   }
 
-  public mutating func insert<S: SequenceType where S.Generator.Element == T>(sequence: S) {
+  public mutating func insert<S: Sequence>(_ sequence: S) where S.Iterator.Element == T {
     for value in sequence {
       insert(value)
     }
@@ -123,7 +123,7 @@ public struct Heap<T> {
    * Removes the root node from the heap. For a max-heap, this is the maximum
    * value; for a min-heap it is the minimum value. Performance: O(log n).
    */
-  public mutating func remove() -> T? {
+  @discardableResult public mutating func remove() -> T? {
     if elements.isEmpty {
       return nil
     } else if elements.count == 1 {
@@ -142,14 +142,14 @@ public struct Heap<T> {
    * Removes an arbitrary node from the heap. Performance: O(log n). You need
    * to know the node's index, which may actually take O(n) steps to find.
    */
-  public mutating func removeAtIndex(i: Int) -> T? {
-    guard i < elements.count else { return nil }
+  public mutating func removeAt(index: Int) -> T? {
+    guard index < elements.count else { return nil }
 
     let size = elements.count - 1
-    if i != size {
-      swap(&elements[i], &elements[size])
-      shiftDown(index: i, heapSize: size)
-      shiftUp(index: i)
+    if index != size {
+      swap(&elements[index], &elements[size])
+      shiftDown(index: index, heapSize: size)
+      shiftUp(index: index)
     }
     return elements.removeLast()
   }
@@ -158,15 +158,15 @@ public struct Heap<T> {
    * Takes a child node and looks at its parents; if a parent is not larger
    * (max-heap) or not smaller (min-heap) than the child, we exchange them.
    */
-  mutating func shiftUp(index index: Int) {
+  mutating func shiftUp(index: Int) {
     var childIndex = index
     let child = elements[childIndex]
-    var parentIndex = indexOfParent(childIndex)
+    var parentIndex = self.parentIndex(ofIndex: childIndex)
 
     while childIndex > 0 && isOrderedBefore(child, elements[parentIndex]) {
       elements[childIndex] = elements[parentIndex]
       childIndex = parentIndex
-      parentIndex = indexOfParent(childIndex)
+      parentIndex = self.parentIndex(ofIndex: childIndex)
     }
 
     elements[childIndex] = child
@@ -180,11 +180,11 @@ public struct Heap<T> {
    * Looks at a parent node and makes sure it is still larger (max-heap) or
    * smaller (min-heap) than its childeren.
    */
-  mutating func shiftDown(index index: Int, heapSize: Int) {
+  mutating func shiftDown(index: Int, heapSize: Int) {
     var parentIndex = index
 
     while true {
-      let leftChildIndex = indexOfLeftChild(parentIndex)
+      let leftChildIndex = self.leftChildIndex(ofIndex: parentIndex)
       let rightChildIndex = leftChildIndex + 1
 
       // Figure out which comes first if we order them by the sort function:
@@ -212,16 +212,16 @@ extension Heap where T: Equatable {
   /**
    * Searches the heap for the given element. Performance: O(n).
    */
-  public func indexOf(element: T) -> Int? {
-    return indexOf(element, 0)
+  public func index(of element: T) -> Int? {
+    return index(of: element, 0)
   }
 
-  private func indexOf(element: T, _ i: Int) -> Int? {
+  fileprivate func index(of element: T, _ i: Int) -> Int? {
     if i >= count { return nil }
     if isOrderedBefore(element, elements[i]) { return nil }
     if element == elements[i] { return i }
-    if let j = indexOf(element, indexOfLeftChild(i)) { return j }
-    if let j = indexOf(element, indexOfRightChild(i)) { return j }
+    if let j = index(of: element, self.leftChildIndex(ofIndex: i)) { return j }
+    if let j = index(of: element, self.rightChildIndex(ofIndex: i)) { return j }
     return nil
   }
 }

Heap/README.markdown

@@ -260,7 +260,7 @@ It can be convenient to convert an array into a heap. This just shuffles the arr
 In code it would look like this:
 
 ```swift
-  private mutating func buildHeap(array: [T]) {
+  private mutating func buildHeap(fromArray array: [T]) {
     for value in array {
       insert(value)
     }
@@ -274,7 +274,7 @@ If you didn't gloss over the math section, you'd have seen that for any heap the
 In code:
 
 ```swift
-  private mutating func buildHeap(array: [T]) {
+  private mutating func buildHeap(fromArray array: [T]) {
     elements = array
     for i in (elements.count/2 - 1).stride(through: 0, by: -1) {
       shiftDown(index: i, heapSize: elements.count)

Heap/Tests/HeapTests.swift

@@ -7,38 +7,38 @@ import XCTest
 
 class HeapTests: XCTestCase {
 
-  private func verifyMaxHeap(h: Heap<Int>) -> Bool {
+  fileprivate func verifyMaxHeap(_ h: Heap<Int>) -> Bool {
     for i in 0..<h.count {
-      let left = h.indexOfLeftChild(i)
-      let right = h.indexOfRightChild(i)
-      let parent = h.indexOfParent(i)
+      let left = h.leftChildIndex(ofIndex: i)
+      let right = h.rightChildIndex(ofIndex: i)
+      let parent = h.parentIndex(ofIndex: i)
       if left < h.count && h.elements[i] < h.elements[left] { return false }
       if right < h.count && h.elements[i] < h.elements[right] { return false }
       if i > 0 && h.elements[parent] < h.elements[i] { return false }
     }
     return true
   }
 
-  private func verifyMinHeap(h: Heap<Int>) -> Bool {
+  fileprivate func verifyMinHeap(_ h: Heap<Int>) -> Bool {
     for i in 0..<h.count {
-      let left = h.indexOfLeftChild(i)
-      let right = h.indexOfRightChild(i)
-      let parent = h.indexOfParent(i)
+      let left = h.leftChildIndex(ofIndex: i)
+      let right = h.rightChildIndex(ofIndex: i)
+      let parent = h.parentIndex(ofIndex: i)
       if left < h.count && h.elements[i] > h.elements[left] { return false }
       if right < h.count && h.elements[i] > h.elements[right] { return false }
       if i > 0 && h.elements[parent] > h.elements[i] { return false }
     }
     return true
   }
 
-  private func isPermutation(array1: [Int], _ array2: [Int]) -> Bool {
+  fileprivate func isPermutation(_ array1: [Int], _ array2: [Int]) -> Bool {
     var a1 = array1
     var a2 = array2
     if a1.count != a2.count { return false }
     while a1.count > 0 {
-      if let i = a2.indexOf(a1[0]) {
-        a1.removeAtIndex(0)
-        a2.removeAtIndex(i)
+      if let i = a2.index(of: a1[0]) {
+        a1.remove(at: 0)
+        a2.remove(at: i)
       } else {
         return false
       }
@@ -161,7 +161,7 @@ class HeapTests: XCTestCase {
     XCTAssertEqual(heap.elements, [1, 1, 1, 1, 1])
   }
 
-  private func randomArray(n: Int) -> [Int] {
+  fileprivate func randomArray(_ n: Int) -> [Int] {
     var a = [Int]()
     for _ in 0..<n {
       a.append(Int(arc4random()))
@@ -197,27 +197,27 @@ class HeapTests: XCTestCase {
     XCTAssertEqual(h.elements, [100, 50, 70, 10, 20, 60, 65])
 
     //test index out of bounds
-    let v = h.removeAtIndex(10)
+    let v = h.removeAt(index: 10)
     XCTAssertEqual(v, nil)
     XCTAssertTrue(verifyMaxHeap(h))
     XCTAssertEqual(h.elements, [100, 50, 70, 10, 20, 60, 65])
 
-    let v1 = h.removeAtIndex(5)
+    let v1 = h.removeAt(index: 5)
     XCTAssertEqual(v1, 60)
     XCTAssertTrue(verifyMaxHeap(h))
     XCTAssertEqual(h.elements, [100, 50, 70, 10, 20, 65])
 
-    let v2 = h.removeAtIndex(4)
+    let v2 = h.removeAt(index: 4)
     XCTAssertEqual(v2, 20)
     XCTAssertTrue(verifyMaxHeap(h))
     XCTAssertEqual(h.elements, [100, 65, 70, 10, 50])
 
-    let v3 = h.removeAtIndex(4)
+    let v3 = h.removeAt(index: 4)
     XCTAssertEqual(v3, 50)
     XCTAssertTrue(verifyMaxHeap(h))
     XCTAssertEqual(h.elements, [100, 65, 70, 10])
 
-    let v4 = h.removeAtIndex(0)
+    let v4 = h.removeAt(index: 0)
     XCTAssertEqual(v4, 100)
     XCTAssertTrue(verifyMaxHeap(h))
     XCTAssertEqual(h.elements, [70, 65, 10])
@@ -270,9 +270,9 @@ class HeapTests: XCTestCase {
       let m = (n + 1)/2
       for k in 1...m {
         let i = Int(arc4random_uniform(UInt32(n - k + 1)))
-        let v = h.removeAtIndex(i)!
-        let j = a.indexOf(v)!
-        a.removeAtIndex(j)
+        let v = h.removeAt(index: i)!
+        let j = a.index(of: v)!
+        a.remove(at: j)
 
         XCTAssertTrue(verifyMaxHeap(h))
         XCTAssertEqual(h.count, a.count)

Heap/Tests/Tests.xcodeproj/project.pbxproj

@@ -83,11 +83,12 @@
 			isa = PBXProject;
 			attributes = {
 				LastSwiftUpdateCheck = 0720;
-				LastUpgradeCheck = 0720;
+				LastUpgradeCheck = 0800;
 				ORGANIZATIONNAME = "Swift Algorithm Club";
 				TargetAttributes = {
 					7B2BBC7F1C779D720067B71D = {
 						CreatedOnToolsVersion = 7.2;
+						LastSwiftMigration = 0800;
 					};
 				};
 			};
@@ -145,8 +146,10 @@
 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
 				CLANG_WARN_EMPTY_BODY = YES;
 				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
 				CLANG_WARN_INT_CONVERSION = YES;
 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				CODE_SIGN_IDENTITY = "-";
@@ -189,8 +192,10 @@
 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
 				CLANG_WARN_EMPTY_BODY = YES;
 				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
 				CLANG_WARN_INT_CONVERSION = YES;
 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				CODE_SIGN_IDENTITY = "-";
@@ -209,6 +214,7 @@
 				MACOSX_DEPLOYMENT_TARGET = 10.11;
 				MTL_ENABLE_DEBUG_INFO = NO;
 				SDKROOT = macosx;
+				SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule";
 			};
 			name = Release;
 		};
@@ -220,6 +226,7 @@
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @loader_path/../Frameworks";
 				PRODUCT_BUNDLE_IDENTIFIER = swift.algorithm.club.Tests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_VERSION = 3.0;
 			};
 			name = Debug;
 		};
@@ -231,6 +238,7 @@
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @loader_path/../Frameworks";
 				PRODUCT_BUNDLE_IDENTIFIER = swift.algorithm.club.Tests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_VERSION = 3.0;
 			};
 			name = Release;
 		};

Heap/Tests/Tests.xcodeproj/xcshareddata/xcschemes/Tests.xcscheme

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0720"
+   LastUpgradeVersion = "0800"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"