updated README.md

Author: ViktorSimko

B-Tree/README.md

@@ -20,9 +20,9 @@ A second order B-Tree with keys from 1 to 20 looks like this:
 
 ```swift
 class BTreeNode<Key: Comparable, Value> {
-  unowned var ownerTree: BTree<Key, Value>
+  unowned var owner: BTree<Key, Value>
 
-  private var keys = [Key]()
+  fileprivate var keys = [Key]()
   var children: [BTreeNode]?
 
   ...
@@ -55,7 +55,7 @@ This is necessary because nodes have to know the order of the tree.
 
 ### The code
 
-`valueForKey(_:)` method searches for the given key and if it's in the tree,  
+`value(for:)` method searches for the given key and if it's in the tree,  
 it returns the value associated with it, else it returns `nil`.
 
 ## Insertion
@@ -72,7 +72,7 @@ Keys can only be inserted to leaf nodes.
 After insertion we should check if the number of keys in the node is in the correct range.  
 If there are more keys in the node than `order*2`, we need to split the node.
 
-####Splitting a node
+#### Splitting a node
 
 1. Move up the middle key of the node we want to split, to its parent (if it has one).  
 2. If it hasn't got a parent(it is the root), then create a new root and insert to it.  
@@ -90,9 +90,9 @@ An insertion to a first order tree looks like this:
 
 ### The code
 
-The method `insertValue(_:forKey:)` does the insertion.
+The method `insert(_:for:)` does the insertion.
 After it has inserted a key, as the recursion goes up every node checks the number of keys in its child.  
-if a node has too many keys, its parent calls the `splitChild(_:atIndex:)` method on it.
+if a node has too many keys, its parent calls the `split(child:atIndex:)` method on it.
 
 The root node is checked by the tree itself.  
 If the root has too many nodes after the insertion the tree calls the `splitRoot()` method.
@@ -112,7 +112,7 @@ After a key have been removed from a node we should check that the node has enou
 If a node has fewer keys than the order of the tree, then we should move a key to it,  
 or merge it with one of its siblings.
 
-####Moving a key to the child
+#### Moving a key to the child
 
 If the problematic node has a nearest sibling that has more keys than the order of the tree,  
 we should perform this operation on the tree, else we should merge the node with one of its siblings.
@@ -156,13 +156,13 @@ so in the worst case merging also can go up to the root, in which case the heigh
 
 ### The code
 
-- `removeKey(_:)` method removes the given key from the tree. After a key has been deleted,  
+- `remove(_:)` method removes the given key from the tree. After a key has been deleted,  
   every node checks the number of keys in its child. If a child has less nodes than the order of the tree,
-  it calls the `fixChildWithLessNodesThanOrder(_:atIndex:)` method.  
+  it calls the `fix(childWithTooFewKeys:atIndex:)` method.  
 
-- `fixChildWithLessNodesThanOrder(_:atIndex:)` method decides which way to fix the child (by moving a key to it,
-  or by merging it), then calls `moveKeyAtIndex(keyIndex:toNode:fromNode:atPosition:)` or 
-  `mergeChild(_:withIndex:toNodeAtPosition:)` method according to its choice.
+- `fix(childWithTooFewKeys:atIndex:)` method decides which way to fix the child (by moving a key to it,
+  or by merging it), then calls `move(keyAtIndex:to:from:at:)` or 
+  `merge(child:atIndex:to:)` method according to its choice.
 
 ## See also