Merge branch 'master' into serialize-with-array

Author: rzaccone

.travis.yml

@@ -12,6 +12,7 @@ script:
 - xcodebuild test -project ./Array2D/Tests/Tests.xcodeproj -scheme Tests
 - xcodebuild test -project ./AVL\ Tree/Tests/Tests.xcodeproj -scheme Tests
 - xcodebuild test -project ./Binary\ Search/Tests/Tests.xcodeproj -scheme Tests
+- xcodebuild test -project ./Boyer-Moore/Tests/Tests.xcodeproj -scheme Tests
 # - xcodebuild test -project ./Binary\ Search\ Tree/Solution\ 1/Tests/Tests.xcodeproj -scheme Tests
 - xcodebuild test -project ./Bloom\ Filter/Tests/Tests.xcodeproj -scheme Tests
 # - xcodebuild test -project ./Bounded\ Priority\ Queue/Tests/Tests.xcodeproj -scheme Tests
@@ -22,21 +23,23 @@ script:
 # - xcodebuild test -project ./Depth-First\ Search/Tests/Tests.xcodeproj -scheme Tests
 # - xcodebuild test -project ./Graph/Graph.xcodeproj -scheme GraphTests
 # - xcodebuild test -project ./Heap/Tests/Tests.xcodeproj -scheme Tests
-# - xcodebuild test -project ./Heap\ Sort/Tests/Tests.xcodeproj -scheme Tests
+- xcodebuild test -project ./Heap\ Sort/Tests/Tests.xcodeproj -scheme Tests
 - xcodebuild test -project ./Insertion\ Sort/Tests/Tests.xcodeproj -scheme Tests
 # - xcodebuild test -project ./K-Means/Tests/Tests.xcodeproj -scheme Tests
 # - xcodebuild test -project ./Linked\ List/Tests/Tests.xcodeproj -scheme Tests
 - xcodebuild test -project ./Longest\ Common\ Subsequence/Tests/Tests.xcodeproj -scheme Tests
-# - xcodebuild test -project ./Minimum\ Spanning\ Tree\ \(Unweighted\)/Tests/Tests.xcodeproj -scheme Tests
+- xcodebuild test -project ./Minimum\ Spanning\ Tree\ \(Unweighted\)/Tests/Tests.xcodeproj -scheme Tests
 # - xcodebuild test -project ./Priority\ Queue/Tests/Tests.xcodeproj -scheme Tests
 - xcodebuild test -project ./Queue/Tests/Tests.xcodeproj -scheme Tests
 # - xcodebuild test -project ./Quicksort/Tests/Tests.xcodeproj -scheme Tests
+- xcodebuild test -project ./Rootish\ Array\ Stack/Tests/Tests.xcodeproj -scheme Tests
 # - xcodebuild test -project ./Run-Length\ Encoding/Tests/Tests.xcodeproj -scheme Tests
 # - xcodebuild test -project ./Select\ Minimum\ Maximum/Tests/Tests.xcodeproj -scheme Tests
 - xcodebuild test -project ./Selection\ Sort/Tests/Tests.xcodeproj -scheme Tests
 # - xcodebuild test -project ./Shell\ Sort/Tests/Tests.xcodeproj -scheme Tests
-# - xcodebuild test -project ./Shortest\ Path\ \(Unweighted\)/Tests/Tests.xcodeproj -scheme Tests
+- xcodebuild test -project ./Shortest\ Path\ \(Unweighted\)/Tests/Tests.xcodeproj -scheme Tests
 # - xcodebuild test -project ./Single-Source\ Shortest\ Paths\ \(Weighted\)/SSSP.xcodeproj -scheme SSSPTests
 - xcodebuild test -project ./Stack/Tests/Tests.xcodeproj -scheme Tests
 - xcodebuild test -project ./Topological\ Sort/Tests/Tests.xcodeproj -scheme Tests
 - xcodebuild test -project ./Treap/Treap/Treap.xcodeproj -scheme Tests
+- xcodebuild test -project ./Palindromes/Test/Test.xcodeproj -scheme Test

AVL Tree/AVLTree.swift

@@ -29,7 +29,7 @@ public class TreeNode<Key: Comparable, Payload> {
   internal var leftChild: Node?
   internal var rightChild: Node?
   fileprivate var height: Int
-  weak fileprivate var parent: Node?
+  fileprivate weak var parent: Node?
 
   public init(key: Key, payload: Payload?, leftChild: Node?, rightChild: Node?, parent: Node?, height: Int) {
     self.key = key

AVL Tree/Images/RotationStep0.jpg

@@ -43,20 +43,44 @@ The difference between the heights of the left and right subtrees is called the
 If after an insertion or deletion the balance factor becomes greater than 1, then we need to re-balance this part of the AVL tree. And that is done with rotations.
 
 ## Rotations
-
 Each tree node keeps track of its current balance factor in a variable. After inserting a new node, we need to update the balance factor of its parent node. If that balance factor becomes greater than 1, we "rotate" part of that tree to restore the balance.
 
-TODO: describe with pictures how these rotations work
+![Rotation0](Images/RotationStep0.jpg)
+
+For the rotation we're using the terminology:
+* *Root* - the parent not of the subtrees that will be rotated;
+* *Pivot* - the node that will become parent (basically will be on the *Root*'s position) after rotation;
+* *RotationSubtree* - subtree of the *Pivot* upon the side of rotation
+* *OppositeSubtree* - subtree of the *Pivot* opposite the side of rotation
+
+Let take an example of balancing the unbalanced tree using *Right* (clockwise direction) rotation: 
+
+![Rotation1](Images/RotationStep1.jpg) ![Rotation2](Images/RotationStep2.jpg) ![Rotation3](Images/RotationStep3.jpg)
+
+The steps of rotation could be described by following:  
+
+1. Assign the *RotationSubtree* as a new *OppositeSubtree* for the *Root*;
+2. Assign the *Root* as a new *RotationSubtree* for the *Pivot*;
+3. Check the final result
+
+
+In pseudocode the algorithm above could be written as follows:
+```
+Root.OS = Pivot.RS
+Pivot.RS = Root
+Root = Pivot
+```
 
-Insertion never needs more than 2 rotations. Removal might require up to *log(n)* rotations.
+This is a constant time operation - __O(1)__
+Insertion never needs more than 2 rotations. Removal might require up to __log(n)__ rotations.
 
 ## The code
 
 Most of the code in [AVLTree.swift](AVLTree.swift) is just regular [binary search tree](../Binary Search Tree/) stuff. You'll find this in any implementation of a binary search tree. For example, searching the tree is exactly the same. The only things that an AVL tree does slightly differently are inserting and deleting the nodes.
 
 > **Note:** If you're a bit fuzzy on the regular operations of a binary search tree, I suggest you [catch up on those first](../Binary Search Tree/). It will make the rest of the AVL tree easier to understand.
 
-The interesting bits are in the `balance()` method which is called after inserting or deleting a node. 
+The interesting bits are in the `balance()` method which is called after inserting or deleting a node.
 
 ## See also
 

AVL Tree/Images/RotationStep1.jpg

@@ -30,14 +30,14 @@ let myCookie = cookies[3][6]
 Actually, you could create the array in a single line of code, like so:
 
 ```swift
-var cookies = [[Int]](count: 9, repeatedValue: [Int](count: 7, repeatedValue: 0))
+var cookies = [[Int]](repeating: [Int](repeating: 0, count: 7), count: 9)
 ```
 
 but that's just ugly. To be fair, you can hide the ugliness in a helper function:
 
 ```swift
 func dim<T>(count: Int, _ value: T) -> [T] {
-  return [T](count: count, repeatedValue: value)
+  return [T](repeating: value, count: count)
 }
 ```
 
@@ -72,7 +72,7 @@ public struct Array2D<T> {
   public init(columns: Int, rows: Int, initialValue: T) {
     self.columns = columns
     self.rows = rows
-    array = .init(count: rows*columns, repeatedValue: initialValue)
+    array = .init(repeating: initialValue, count: rows*columns)
   }
 
   public subscript(column: Int, row: Int) -> T {

AVL Tree/Images/RotationStep2.jpg

@@ -412,7 +412,7 @@ To see how this works, take the following tree:
 
 ![Example](Images/MinimumMaximum.png)
 
-For example, if we look at node `10`, its leftmost descendent is `6`. We get there by following all the `left` pointers until there are no more left children to look at. The leftmost descendent of the root node `7` is `1`. Therefore, `1` is the minimum value in the entire tree.
+For example, if we look at node `10`, its leftmost descendent is `7`. We get there by following all the `left` pointers until there are no more left children to look at. The leftmost descendent of the root node `6` is `1`. Therefore, `1` is the minimum value in the entire tree.
 
 We won't need it for deleting, but for completeness' sake, here is the opposite of `minimum()`:
 
@@ -426,7 +426,7 @@ We won't need it for deleting, but for completeness' sake, here is the opposite
   }
 ```
 
-It returns the rightmost descendent of the node. We find it by following `right` pointers until we get to the end. In the above example, the rightmost descendent of node `2` is `5`. The maximum value in the entire tree is `11`, because that is the rightmost descendent of the root node `7`.
+It returns the rightmost descendent of the node. We find it by following `right` pointers until we get to the end. In the above example, the rightmost descendent of node `2` is `5`. The maximum value in the entire tree is `11`, because that is the rightmost descendent of the root node `6`.
 
 Finally, we can write the code that removes a node from the tree:
 
@@ -500,11 +500,11 @@ if let node2 = tree.search(2) {
 
 First you find the node that you want to remove with `search()` and then you call `remove()` on that object. Before the removal, the tree printed like this:
 
-	((1) <- 2 -> (5)) <- 7 -> ((9) <- 10)
+	((1) <- 2 -> (5)) <- 6 -> ((9) <- 10)
 
 But after `remove()` you get:
 
-	((1) <- 5) <- 7 -> ((9) <- 10)
+	((1) <- 5) <- 6 -> ((9) <- 10)
 
 As you can see, node `5` has taken the place of `2`.
 

AVL Tree/Images/RotationStep3.jpg

@@ -1,7 +1,7 @@
 //: Playground - noun: a place where people can play
 
 // Each time you insert something, you get back a completely new tree.
-var tree = BinarySearchTree.Leaf(7)
+var tree = BinarySearchTree.leaf(7)
 tree = tree.insert(newValue: 2)
 tree = tree.insert(newValue: 5)
 tree = tree.insert(newValue: 10)

AVL Tree/README.markdown

@@ -4,25 +4,25 @@
   The tree is immutable. Any insertions or deletions will create a new tree.
 */
 public enum BinarySearchTree<T: Comparable> {
-  case Empty
-  case Leaf(T)
-  indirect case Node(BinarySearchTree, T, BinarySearchTree)
+  case empty
+  case leaf(T)
+  indirect case node(BinarySearchTree, T, BinarySearchTree)
 
   /* How many nodes are in this subtree. Performance: O(n). */
   public var count: Int {
     switch self {
-    case .Empty: return 0
-    case .Leaf: return 1
-    case let .Node(left, _, right): return left.count + 1 + right.count
+    case .empty: return 0
+    case .leaf: return 1
+    case let .node(left, _, right): return left.count + 1 + right.count
     }
   }
 
   /* Distance of this node to its lowest leaf. Performance: O(n). */
   public var height: Int {
     switch self {
-    case .Empty: return 0
-    case .Leaf: return 1
-    case let .Node(left, _, right): return 1 + max(left.height, right.height)
+    case .empty: return 0
+    case .leaf: return 1
+    case let .node(left, _, right): return 1 + max(left.height, right.height)
     }
   }
 
@@ -32,21 +32,21 @@ public enum BinarySearchTree<T: Comparable> {
   */
   public func insert(newValue: T) -> BinarySearchTree {
     switch self {
-    case .Empty:
-      return .Leaf(newValue)
+    case .empty:
+      return .leaf(newValue)
 
-    case .Leaf(let value):
+    case .leaf(let value):
       if newValue < value {
-        return .Node(.Leaf(newValue), value, .Empty)
+        return .node(.leaf(newValue), value, .empty)
       } else {
-        return .Node(.Empty, value, .Leaf(newValue))
+        return .node(.empty, value, .leaf(newValue))
       }
 
-    case .Node(let left, let value, let right):
+    case .node(let left, let value, let right):
       if newValue < value {
-        return .Node(left.insert(newValue: newValue), value, right)
+        return .node(left.insert(newValue: newValue), value, right)
       } else {
-        return .Node(left, value, right.insert(newValue: newValue))
+        return .node(left, value, right.insert(newValue: newValue))
       }
     }
   }
@@ -57,11 +57,11 @@ public enum BinarySearchTree<T: Comparable> {
   */
   public func search(x: T) -> BinarySearchTree? {
     switch self {
-    case .Empty:
+    case .empty:
       return nil
-    case .Leaf(let y):
+    case .leaf(let y):
       return (x == y) ? self : nil
-    case let .Node(left, y, right):
+    case let .node(left, y, right):
       if x < y {
         return left.search(x: x)
       } else if y < x {
@@ -82,11 +82,11 @@ public enum BinarySearchTree<T: Comparable> {
   public func minimum() -> BinarySearchTree {
     var node = self
     var prev = node
-    while case let .Node(next, _, _) = node {
+    while case let .node(next, _, _) = node {
       prev = node
       node = next
     }
-    if case .Leaf = node {
+    if case .leaf = node {
       return node
     }
     return prev
@@ -98,11 +98,11 @@ public enum BinarySearchTree<T: Comparable> {
   public func maximum() -> BinarySearchTree {
     var node = self
     var prev = node
-    while case let .Node(_, _, next) = node {
+    while case let .node(_, _, next) = node {
       prev = node
       node = next
     }
-    if case .Leaf = node {
+    if case .leaf = node {
       return node
     }
     return prev
@@ -112,9 +112,9 @@ public enum BinarySearchTree<T: Comparable> {
 extension BinarySearchTree: CustomDebugStringConvertible {
   public var debugDescription: String {
     switch self {
-    case .Empty: return "."
-    case .Leaf(let value): return "\(value)"
-    case .Node(let left, let value, let right):
+    case .empty: return "."
+    case .leaf(let value): return "\(value)"
+    case .node(let left, let value, let right):
       return "(\(left.debugDescription) <- \(value) -> \(right.debugDescription))"
     }
   }