Example. Inserting into a binary search tree

[comp1110-2W]
  • Liam O'Connor, Fabian Muehlboeck

Here BST is our example of a binary search tree type:

BST insert(BST tree, int element) { if(tree == null) { return new BST(element, null, null); } if(tree.value <= element) { tree.right = insert(tree.right, element); return tree; } else { tree.left = insert(tree.left, element); return tree; } }

The above code (almost) always modifies an existing tree. A more "functional" version that always creates a new (slightly modified) copy of the original tree would look as follows:

BST insert(BST tree, int element) { if(tree == null) { return new BST(element, null, null); } if(tree.value <= element) { BST newRight = insert(tree.right, element); return new BST(tree.value, tree.left, newRight); } else { BST newLeft = insert(tree.left, element); return new BST(tree.value, newLeft, tree.right); } }

Either version of the function ensures that the Data Invariant on the BST Definition is preserved.

Context

    Binary Search Trees

    [comp1110-7Q]
    • Fabian Muehlboeck

    Definition. Binary Search Trees

    [comp1110-2V]
    • Liam O'Connor, Fabian Muehlboeck

    While we can replace linear search with binary search on sorted arrays to improve how many comparisons we have to do, this is not so straightforward with linked lists, even if sorted. The structure of the linked list requires linear traversal, rather than the random access required for binary search.

    Instead, we will store sorted data differently so that finding elements can be much more efficient. Each node of a binary tree contains some data (in our case, an integer) and two branches:

    //BST // - null (for an empty tree) // - a BST object (for a tree node) /** * INVARIANT: the values stored in all descendants * on the left are <= v * the values stored in all descendants * on the right are >= v */ class BST { BST(int v, BST l, BST r) { value = v; left = l; right = r; } int value; BST left; BST right; }
    • value is the integer at this node.
    • left is a tree of integers in the tree that are less than or equal to the value in the current node (Null if there are none).
    • right is a tree of integers in the tree that are greater than or equal to the value in the current node (Null if there are none).

    The BST has a Data Invariant to ensure the conditions on the values stored in the left and right children.

    Example. Inserting into a binary search tree

    [comp1110-2W]
    • Liam O'Connor, Fabian Muehlboeck

    Here BST is our example of a binary search tree type:

    BST insert(BST tree, int element) { if(tree == null) { return new BST(element, null, null); } if(tree.value <= element) { tree.right = insert(tree.right, element); return tree; } else { tree.left = insert(tree.left, element); return tree; } }

    The above code (almost) always modifies an existing tree. A more "functional" version that always creates a new (slightly modified) copy of the original tree would look as follows:

    BST insert(BST tree, int element) { if(tree == null) { return new BST(element, null, null); } if(tree.value <= element) { BST newRight = insert(tree.right, element); return new BST(tree.value, tree.left, newRight); } else { BST newLeft = insert(tree.left, element); return new BST(tree.value, newLeft, tree.right); } }

    Either version of the function ensures that the Data Invariant on the BST Definition is preserved.

    Example. Looking up a BST

    [comp1110-2X]
    • Liam O'Connor, Fabian Muehlboeck

    To find out whether a tree contains a value, we determine what subtree of the binary search tree to descend into by comparing the desired value to the value stored in the root of the current subtree.

    boolean contains(BST haystack, int needle) { if(haystack == null) { return false; } if(haystack.value == needle) { return true; } else if(haystack.value < needle) { return contains(haystack.right, needle); } else { return contains(haystack.left, needle); } }

    The correctness of the function depends on the Data Invariant specified in the BST Definition, similar to the precondition on regular binary search that the array be sorted. Here, this condition is implicitly given because haystack is a BST and any argument can always be assumed to satisfy any data invariants on it.

    Backlinks

      Values vs. Entities

      [comp1110-3C]
      • Liam O'Connor, Fabian Muehlboeck

      Think of the number 5. If you add 1 to it, you don't "change" the 5; you simply produce to a completely different value, 6. The number 5 is immutable and has no identity other than its value. Enums behave like this, which is why you can compare them with ==. Strings, on the other hand, are immutable, but have identity, so there can be two String entities that represent the same text, but are different entities, and so == does not work.

      Now think about your bank account. If you deposit 100 dollars into your bank account, you don't get a new bank account, rather, your existing bank account is updated to reflect the new reality. This is also important when there are multiple people accessing the same bank account - they should see the same data, which would not be true if everyone kept creating new copies of it every time they change something. We saw this concept before when sorting arrays and when Inserting into a binary search tree.

      Related

        Definition. Binary Search Trees

        [comp1110-2V]
        • Liam O'Connor, Fabian Muehlboeck

        While we can replace linear search with binary search on sorted arrays to improve how many comparisons we have to do, this is not so straightforward with linked lists, even if sorted. The structure of the linked list requires linear traversal, rather than the random access required for binary search.

        Instead, we will store sorted data differently so that finding elements can be much more efficient. Each node of a binary tree contains some data (in our case, an integer) and two branches:

        //BST // - null (for an empty tree) // - a BST object (for a tree node) /** * INVARIANT: the values stored in all descendants * on the left are <= v * the values stored in all descendants * on the right are >= v */ class BST { BST(int v, BST l, BST r) { value = v; left = l; right = r; } int value; BST left; BST right; }
        • value is the integer at this node.
        • left is a tree of integers in the tree that are less than or equal to the value in the current node (Null if there are none).
        • right is a tree of integers in the tree that are greater than or equal to the value in the current node (Null if there are none).

        The BST has a Data Invariant to ensure the conditions on the values stored in the left and right children.

        Definition. Data invariants

        [comp1110-44]
        • Liam O'Connor

        A data invariant (also called a representation invariant) is a condition on the fields of a class that must hold after every constructor call and after every method call. It is not enforced by the compiler; it is the programmer's responsibility to maintain it.

        Data invariants document the assumptions an implementation relies on internally. Like loop invariants, they make it easier to reason about correctness: if every method both assumes the invariant holds on entry and ensures it holds on exit, then by induction it holds throughout the lifetime of the object.

        bars magnifying-glass caret-down plus minus arrow-right xmark