Let L denote the left child.

Let R denote the right child.

Let P denote the parent and position.

To easily remember tree traversal orders, pay attention to the position of P in the following strings.

When P is in the center, it is In Order. When it is first, it is Pre Order. And when it is last, it is Post Order.

L – P – R | In Order

P – L – R | Pre Order

L – R – P | Post Order

Note that L and R are always in the same order. The only element changing order is the parent.

In Order

leftChild -> parent -> rightChild

Integer values come out in order when traversing a Binary Search Tree.

Pre Order

parent -> leftChild -> rightChild

Traverse parent first (pre).

Post Order

leftChild -> rightChild -> parent

Traverse parent last (post).

Code

class BST {
    var value: Int?
    var left: BST?
    var right: BST?
    
    init(value: Int) {
        self.value = value
        left = nil
        right = nil
    }
}

// O(n) time | O(n) space, because we're storing all values in array
// Note: If were were just printing values, space will be O(h), where
// h is the height of the tree.

func inOrderTraversal(tree: BST?, array: inout [Int]) -> [Int] {
    guard let node = tree, let value = node.value else { return array }
    
    inOrderTraversal(tree: node.left, array: &array)
    array.append(value)
    inOrderTraversal(tree: node.right, array: &array)
    
    return array
}

func preOrderTraversal(tree: BST?, array: inout [Int]) -> [Int] {
    guard let node = tree, let value = node.value else { return array }
    
    array.append(value)
    preOrderTraversal(tree: node.left, array: &array)
    preOrderTraversal(tree: node.right, array: &array)
    
    return array
}

func postOrderTraversal(tree: BST?, array: inout [Int]) -> [Int] {
    guard let node = tree, let value = node.value else { return array }
    
    postOrderTraversal(tree: node.left, array: &array)
    postOrderTraversal(tree: node.right, array: &array)
    array.append(value)
    
    return array
}

• Array of Linked Lists
• Array size equal to number of vertices.
• Each index in array corresponds to linked list with vertices connecting to the vertex at this index.

Pros:

• Saves space \(O( |V| + |E| )\), worst case \(O( V^2 )\)
• Adding a vertex is easier.

Cons:

• Checking whether an edge exists between two vertices takes \(O( V )\) time.

References

• https://www.geeksforgeeks.org/graph-and-its-representations/
• https://www.programiz.com/dsa/graph-adjacency-list
• https://en.wikipedia.org/wiki/Adjacency_list

• Represents graph with “V” nodes into a \(V x V\) binary matrix.
• A 1 means the two vertices are connected; and a 0 means they are not connected.

Pros:

• Easy to implement.
• Adding and removing an edge, and checking whether there is an edge from one vertex to another is very efficient. Time complexity is \(O(1)\).
• Good choice of implementation if the graph is dense and there are a large number of edges.
• By performing operations on the adjacency matrix, we can get important insights into the nature of the graph and the relationship between its vertices.

Cons:

• Takes up \(O(V^2)\) space. For large graphs, too much memory is consumed. Most real world applications for graphs do not have many connections. Therefore, in these situations, too much space is wasted.
• Adding vertex takes \(O( V^2 )\) time.

References

• https://www.geeksforgeeks.org/graph-and-its-representations/
• https://github.com/raywenderlich/swift-algorithm-club/blob/master/Graph/Graph/AdjacencyMatrixGraph.swift
• https://www.programiz.com/dsa/graph-adjacency-matrix
• https://en.wikipedia.org/wiki/Adjacency_matrix

Pros:

• Time complexity of edge and vertex insertion \(O(1)\).
• Consumes \(O(E + V)\) space.
• Searching for edge or vertex takes \(O(1)\) time.
• Dynamic size.

Cons:

• Deletion of vertices takes \(O(E)\) in the worst case, when an edge has a vertex to every edge.
• Objects not stored in continuous space in memory. Not cache friendly.

References

• https://www.geeksforgeeks.org/graph-and-its-representations/
• https://www.raywenderlich.com/773-swift-algorithm-club-graphs-with-adjacency-list
• https://en.wikipedia.org/wiki/Graph_(abstract_data_type)

• Constructed from edges (nodes) and vertices that connect them.
• Graph types include:
  • Directed or Undirected
  • Weighted or Unweighted
  • Connected or Disconnected
• Represented in code as:
  • Adjacency List
  • Adjacency Matrix
  • Objects and Pointers
• A tree is a graph, but a graph isn’t always a tree.

Graph Traversal

• Depth First Search (DFS)
• Breadth First Search (BFS)

Shortest Path

• Dijkstra
• A*

Graph Representation

• Adjacency List
• Adjacency Matrix
• Objects and Pointers

Every level of the tree is filled, except for perhaps the last level. The last level must be filled from left to right.

Full Binary Tree

Every node has zero or both children.

Perfect Binary Tree

Every node has a left and right child. It is both a Complete Binary Tree and a Full Binary Tree.

• A tree where each parent node has at most two child nodes.
• The first node is called the root node.
• Any nodes without child nodes are called leaf or terminal nodes.
• Each node stores a pointer to a left child, right child, and data.
• Sometimes nodes will also store a pointer to the parent node.

Binary Tree Enumeration

References

• https://www.geeksforgeeks.org/binary-tree-data-structure/
• https://en.wikipedia.org/wiki/Binary_tree
• https://www.raywenderlich.com/990-swift-algorithm-club-swift-binary-search-tree-data-structure

var isEmpty: Bool

var count: Int

func insert(_ element: Element) -> Bool

func remove(_ element: Element) -> Element?

func removeAll()

func contains(_ element: Element) -> Element?

func union(_ hashSet: HashSet) -> HashSet

func intersection(_ hashSet: HashSet) -> HashSet

func difference(_ hashSet: HashSet) -> HashSet

References

1. https://developer.apple.com/documentation/swift/set
2. https://github.com/raywenderlich/swift-algorithm-club/tree/master/Hash%20Set
3. https://developer.apple.com/documentation/swift/hashable