ds-algo-study

<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /> <meta name="description" content="A description of the page and its contents" /> <link rel="stylesheet" href="styles.css" /> <title>Page Title</title> <link rel="stylesheet" href="./../../../assets/style.css" /> <link rel="stylesheet" href="./../../../assets/prism.css" /> <script async src="./../../../assets/prism.js"></script> </head> <body> <h1 id="section"><img src="ds-cheat-sheet-operations.png" /></h1> <blockquote> Its always good to have a look at worst-case time complexities of common data structure operations frequently. </blockquote> Its always good to have a look at worst-case time complexities of common data structure operations frequently. <figure> <img src="https://miro.medium.com/max/60/1*6NpRbTpekXG_1l5hh1XeIQ.png?q=20" alt="Image for post" /> <figcaption>Image for post</figcaption> </figure> <figure> <img src="https://miro.medium.com/max/3572/1*6NpRbTpekXG_1l5hh1XeIQ.png" alt="Image for post" /> <figcaption>Image for post</figcaption> </figure> Arrays are one of the basic and important data structures to learn, They take constant time to read and Insert elements at the end and takes a linear time for the remaining. <figure> <img src="https://miro.medium.com/max/60/1*vFbcvaNX-aWr5-wERwKFIA.png?q=20" alt="Image for post" /> <figcaption>Image for post</figcaption> </figure> <figure> <img src="https://miro.medium.com/max/3746/1*vFbcvaNX-aWr5-wERwKFIA.png" alt="Image for post" /> <figcaption>Image for post</figcaption> </figure> Stack takes constant time for Push, Pop & Peek operations. <figure> <img src="https://miro.medium.com/max/60/1*HgkpbE06UCWm2G3U54J8ew.png?q=20" alt="Image for post" /> <figcaption>Image for post</figcaption> </figure> <figure> <img src="https://miro.medium.com/max/2512/1*HgkpbE06UCWm2G3U54J8ew.png" alt="Image for post" /> <figcaption>Image for post</figcaption> </figure> In Queue for Enqueue, Dequeue & Peek operations it takes only Constant time. <figure> <img src="https://miro.medium.com/max/60/1*amq4OYYapQjaN2QXIG5eUw.png?q=20" alt="Image for post" /> <figcaption>Image for post</figcaption> </figure> <figure> <img src="https://miro.medium.com/max/3942/1*amq4OYYapQjaN2QXIG5eUw.png" alt="Image for post" /> <figcaption>Image for post</figcaption> </figure> Here we are considering we are using tails for all single linked lists (Some implementations might not have it). Linked List is the data structure that comes with a lot of different operational scenarios, we have to think about head & tail usage in every operation we are doing. And operation logic and complexity changes at the head, tail, and middle. Typically insertion at head & tail takes constant time and insertion in middle takes linear time. Search can take linear time. Deletion at the head takes constant time and it can take linear time in remaining scenarios. <hr /> <h2 id="trees-basic-concepts"><a class="btn" href="#Trees-basic-concepts" title="Trees: basic concepts"></a>Trees: basic concepts </h2> A tree is a data structure where a node can have zero or more children. Each node contains a value. Like graphs, the connection between nodes is called edges. A tree is a type of graph, but not all of them are trees (more on that later). These data structures are called "trees" because the data structure resembles a tree 🌳. It starts with a root node and branch off with its descendants, and finally, there are leaves. <img src="chrome-extension://cjedbglnccaioiolemnfhjncicchinao/images/tree-parts.jpg" /> Here are some properties of trees: <ul> <li>The top-most node is called root.</li> <li>A node without children is called leaf node or terminal node.</li> <li>Height (h) of the tree is the distance (edge count) between the farthest leaf to the root. <ul> <li><code>A</code> has a height of 3</li> <li><code>I</code> has a height of 0</li> </ul> </li> <li>Depth or level of a node is the distance between the root and the node in question. <ul> <li><code>H</code> has a depth of 2</li> <li><code>B</code> has a depth of 1</li> </ul> </li> </ul> <h3 id="implementing-a-simple-tree-data-structure"><a class="btn" href="#Implementing-a-simple-tree-data-structure" title="Implementing a simple tree data structure"></a>Implementing a simple tree data structure</h3> As we saw earlier, a tree node is just a data structure that has a value and has links to their descendants. Here's an example of a tree node: <table> <tbody> <tr> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">1 2 3 4 5 6 </pre> </td> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">class TreeNode { constructor(value) { this.value = value; this.descendents = []; } } </pre> </td> </tr> </tbody> </table> We can create a tree with 3 descendents as follows: <table> <tbody> <tr> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">1 2 3 4 5 6 7 8 9 10 </pre> </td> <td> pre data-role="codeBlock" data-info="js" class="language-javascript"> const abe = new TreeNode('Abe'); const homer = new TreeNode('Homer'); const bart = new TreeNode('Bart'); const lisa = new TreeNode('Lisa'); const maggie = new TreeNode('Maggie'); abe.descendents.push(homer); homer.descendents.push(bart, lisa, maggie); </pre> </td> </tr> </tbody> </table> That's all; we have a tree data structure! <img src="chrome-extension://cjedbglnccaioiolemnfhjncicchinao/images/simpson2-tree.jpg" title="Simpson tree data structure"/> The node <code>abe</code> is the root and <code>bart</code>, <code>lisa</code> and <code>maggie</code> are the leaf nodes of the tree. Notice that the tree's node can have a different number of descendants: 0, 1, 3, or any other value. Tree data structures have many applications such as: <ul> <li><a href="https://adrianmejia.com/blog/2018/04/28/data-structures-time-complexity-for-beginners-arrays-hashmaps-linked-lists-stacks-queues-tutorial/#HashMaps">Maps</a> </li> <li><a href="https://adrianmejia.com/blog/2018/04/28/data-structures-time-complexity-for-beginners-arrays-hashmaps-linked-lists-stacks-queues-tutorial/#Sets">Sets</a> </li> <li>Databases</li> <li>Priority Queues</li> <li>Querying an LDAP (Lightweight Directory Access Protocol)</li> <li>Representing the Document Object Model (DOM) for HTML on Websites.</li> </ul> <h2 id="binary-trees"><a class="btn" href="#Binary-Trees" title="Binary Trees"></a>Binary Trees</h2> Trees nodes can have zero or more children. However, when a tree has at the most two children, then it's called binary tree. <h3 id="full-complete-and-perfect-binary-trees"><a class="btn" href="#Full-Complete-and-Perfect-binary-trees" title="Full, Complete and Perfect binary trees"></a>Full, Complete and Perfect binary trees</h3> Depending on how nodes are arranged in a binary tree, it can be full, complete and perfect: <ul> <li>Full binary tree: each node has exactly 0 or 2 children (but never 1).</li> <li>Complete binary tree: when all levels except the last one are full with nodes. </li> <li>Perfect binary tree: when all the levels (including the last one) are full of nodes.</li> </ul> Look at these examples: <img src="chrome-extension://cjedbglnccaioiolemnfhjncicchinao/images/full-complete-perfect-binary-tree.jpg" title="Full vs. Complete vs. Perfect Binary Tree"/> These properties are not always mutually exclusive. You can have more than one: <ul> <li>A perfect tree is always complete and full. <ul> <li>Perfect binary trees have precisely 2k-1 nodes, where <code>k</code> is the last level of the tree (starting with 1).</li> </ul> </li> <li>A complete tree is not always <code>full</code>. <ul> <li>Like in our "complete" example, since it has a parent with only one child. If we remove the rightmost gray node, then we would have a complete and full tree but not perfect.</li> </ul> </li> <li>A full tree is not always complete and perfect.</li> </ul> <h2 id="binary-search-tree-bst"><a class="btn" href="#Binary-Search-Tree-BST" title="Binary Search Tree (BST)"></a>Binary Search Tree (BST)</h2> Binary Search Trees or BST for short are a particular application of binary trees. BST has at most two nodes (like all binary trees). However, the values are in such a way that the left children value must be less than the parent, and the right children is must be higher. Duplicates: Some BST doesn't allow duplicates while others add the same values as a right child. Other implementations might keep a count on a case of the duplicity (we are going to do this one later). Let's implement a Binary Search Tree! <h3 id="bst-implementation"><a class="btn" href="#BST-Implementation" title="BST Implementation"></a>BST Implementation </h3> BST are very similar to our previous <a class="btn" href="#Implementing-a-simple-tree-data-structure">implementation of a tree</a>. However, there are some differences: <ul> <li>Nodes can have at most, only two children: left and right.</li> <li>Nodes values has to be ordered as <code>left < parent < right</code>.</li> </ul> Here's the tree node. Very similar to what we did before, but we added some handy getters and setters for left and right children. Notice that is also keeping a reference to the parent and we update it every time add children. TreeNode.js<a href="https://github.com/amejiarosario/dsa.js/blob/master/src/data-structures/trees/tree-node.js">Code</a> <table> <tbody> <tr> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 </pre> </td> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">const LEFT = 0; const RIGHT = 1; class TreeNode { constructor(value) { this.value = value; this.descendents = []; this.parent = null; } get left() { return this.descendents[LEFT]; } set left(node) { this.descendents[LEFT] = node; if (node) { node.parent = this; } } get right() { return this.descendents[RIGHT]; } set right(node) { this.descendents[RIGHT] = node; if (node) { node.parent = this; } } } </pre> </td> </tr> </tbody> </table> Ok, so far we can add a left and right child. Now, let's do the BST class that enforces the <code>left < parent < right</code> rule. BinarySearchTree.js linkUrl linkText <table> <tbody> <tr> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">1 2 3 4 5 6 7 8 9 10 11 12 13 </pre> </td> <td> pre data-role="codeBlock" data-info="js" class="language-javascript"> class BinarySearchTree { constructor() { this.root = null; this.size = 0; } add(value) { } find(value) { } remove(value) { } getMax() { } getMin() { } } </pre> </td> </tr> </tbody> </table> Let's implementing insertion. <h3 id="bst-node-insertion"><a class="btn" href="#BST-Node-Insertion" title="BST Node Insertion"></a>BST Node Insertion </h3> To insert a node in a binary tree, we do the following: <ol type="1"> <li>If a tree is empty, the first node becomes the root and you are done.</li> <li>Compare root/parent's value if it's higher go right, if it's lower go left. If it's the same, then the value already exists so you can increase the duplicate count (multiplicity). </li> <li>Repeat #2 until we found an empty slot to insert the new node.</li> </ol> Let's do an illustration how to insert 30, 40, 10, 15, 12, 50: <img src="chrome-extension://cjedbglnccaioiolemnfhjncicchinao/images/bst2.gif" title="Inserting nodes on a Binary Search Tree (BST)"/> We can implement insert as follows: BinarySearchTree.prototype.add<a href="https://github.com/amejiarosario/dsa.js/blob/master/src/data-structures/trees/binary-search-tree.js#L11">Full Code</a> <table> <tbody> <tr> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 </pre> </td> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">add(value) { const newNode = new TreeNode(value); if (this.root) { const { found, parent } = this.findNodeAndParent(value); if (found) { found.meta.multiplicity = (found.meta.multiplicity || 1) + 1; } else if (value < parent.value) { parent.left = newNode; } else { parent.right = newNode; } } else { this.root = newNode; } this.size += 1; return newNode; } </pre> </td> </tr> </tbody> </table> We are using a helper function called <code>findNodeAndParent</code>. If we found that the node already exists in the tree, then we increase the <code>multiplicity</code> counter. Let's see how this function is implemented: BinarySearchTree.prototype.findNodeAndParent<a href="https://github.com/amejiarosario/dsa.js/blob/master/src/data-structures/trees/binary-search-tree.js#L44">Full Code</a> <table> <tbody> <tr> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">1 2 3 4 5 6 7 8 9 10 11 12 13 14 </pre> </td> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">findNodeAndParent(value) { let node = this.root; let parent; while (node) { if (node.value === value) { break; } parent = node; node = ( value >= node.value) ? node.right : node.left; } return { found: node, parent }; } </pre> </td> </tr> </tbody> </table> <code>findNodeAndParent</code> goes through the tree searching for the value. It starts at the root (line 2) and then goes left or right based on the value (line 10). If the value already exists, it will return the node <code>found</code> and also the parent. In case that the node doesn't exist, we still return the <code>parent</code>. <h3 id="bst-node-deletion"><a class="btn" href="#BST-Node-Deletion" title="BST Node Deletion"></a>BST Node Deletion </h3> We know how to insert and search for value. Now, we are going to implement the delete operation. It's a little trickier than adding, so let's explain it with the following cases: Deleting a leaf node (0 children) <table> <tbody> <tr> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">1 2 3 4 5 6 7 </pre> </td> <td> pre data-role="codeBlock" data-info="js" class="language-javascript"> 30 30 / \ remove(12) / \ 10 40 ---------> 10 40 \ / \ \ / \ 15 35 50 15 35 50 / 12* </pre> </td> </tr> </tbody> </table> We just remove the reference from node's parent (15) to be null. Deleting a node with one child. <table> <tbody> <tr> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">1 2 3 4 5 </pre> </td> <td> pre data-role="codeBlock" data-info="js" class="language-javascript"> 30 30 / \ remove(10) / \ 10* 40 ---------> 15 40 \ / \ / \ 15 35 50 35 50 </pre> </td> </tr> </tbody> </table> In this case, we go to the parent (30) and replace the child (10), with a child's child (15). Deleting a node with two children <table> <tbody> <tr> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">1 2 3 4 5 </pre> </td> <td> pre data-role="codeBlock" data-info="js" class="language-javascript"> 30 30 / \ remove(40) / \ 15 40* ---------> 15 50 / \ / 35 50 35 </pre> </td> </tr> </tbody> </table> We are removing node 40, that has two children (35 and 50). We replace the parent's (30) child (40) with the child's right child (50). Then we keep the left child (35) in the same place it was before, so we have to make it the left child of 50. Another way to do it to remove node 40, is to move the left child (35) up and then keep the right child (50) where it was. <table> <tbody> <tr> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">1 2 3 4 5 </pre> </td> <td> pre data-role="codeBlock" data-info="js" class="language-javascript"> 30 / \ 15 35 \ 50 </pre> </td> </tr> </tbody> </table> Either way is ok as long as you keep the binary search tree property: <code>left < parent < right</code>. Deleting the root. <table> <tbody> <tr> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">1 2 3 4 5 </pre> </td> <td> pre data-role="codeBlock" data-info="js" class="language-javascript"> 30* 50 / \ remove(30) / \ 15 50 ---------> 15 35 / 35 </pre> </td> </tr> </tbody> </table> Deleting the root is very similar to removing nodes with 0, 1, or 2 children that we discussed earlier. The only difference is that afterward, we need to update the reference of the root of the tree. Here's an animation of what we discussed. <img src="chrome-extension://cjedbglnccaioiolemnfhjncicchinao/images/bst-remove.gif" title="Removing a node with 0, 1, 2 children from a binary search tree"/> In the animation, it moves up the left child/subtree and keeps the right child/subtree in place. Now that we have a good idea how it should work, let's implement it: BinarySearchTree.prototype.remove<a href="https://github.com/amejiarosario/dsa.js/blob/master/src/data-structures/trees/binary-search-tree.js#L89">Full Code</a> <table> <tbody> <tr> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 </pre> </td> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">remove(value) { const nodeToRemove = this.find(value); if (!nodeToRemove) return false; const nodeToRemoveChildren = this.combineLeftIntoRightSubtree(nodeToRemove); if (nodeToRemove.meta.multiplicity && nodeToRemove.meta.multiplicity > 1) { nodeToRemove.meta.multiplicity -= 1; } else if (nodeToRemove === this.root) { this.root = nodeToRemoveChildren; this.root.parent = null; } else { const side = nodeToRemove.isParentLeftChild ? 'left' : 'right'; const { parent } = nodeToRemove; parent[side] = nodeToRemoveChildren; } this.size -= 1; return true; } </pre> </td> </tr> </tbody> </table> Here are some highlights of the implementation: <ul> <li>First, we search if the node exists. If it doesn't, we return false and we are done!</li> <li>If the node to remove exists, then combine left and right children into one subtree.</li> <li>Replace node to delete with the combined subtree.</li> </ul> The function that combines left into right subtree is the following: BinarySearchTree.prototype.combineLeftIntoRightSubtree<a href="https://github.com/amejiarosario/dsa.js/blob/master/src/data-structures/trees/binary-search-tree.js#L89">Full Code</a> <table> <tbody> <tr> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">1 2 3 4 5 6 7 8 </pre> </td> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">combineLeftIntoRightSubtree(node) { if (node.right) { const leftmost = this.getLeftmost(node.right); leftmost.left = node.left; return node.right; } return node.left; } </pre> </td> </tr> </tbody> </table> For instance, let's say that we want to combine the following tree and we are about to delete node <code>30</code>. We want to mix 30's left subtree into the right one. The result is this: <table> <tbody> <tr> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">1 2 3 4 5 6 7 </pre> </td> <td> pre data-role="codeBlock" data-info="js" class="language-javascript"> 30* 40 / \ / \ 10 40 combine(30) 35 50 \ / \ -----------> / 15 35 50 10 \ 15 </pre> </td> </tr> </tbody> </table> Now, and if we make the new subtree the root, then node <code>30</code> is no more! <h2 id="binary-tree-transversal"><a class="btn" href="#Binary-Tree-Transversal" title="Binary Tree Transversal"></a>Binary Tree Transversal</h2> There are different ways of traversing a Binary Tree, depending on the order that the nodes are visited: in-order, pre-order, and post-order. Also, we can use them <a href="chrome-extension://cjedbglnccaioiolemnfhjncicchinao/blog/2018/05/14/Data-Structures-for-Beginners-Graphs-Time-Complexity-tutorial/#Depth-first-search-DFS-Graph-search">DFS</a> and <a href="chrome-extension://cjedbglnccaioiolemnfhjncicchinao/blog/2018/05/14/Data-Structures-for-Beginners-Graphs-Time-Complexity-tutorial/#Breadth-frirst-search-BFS-Graph-search">BFS</a> that we learned from the <a href="chrome-extension://cjedbglnccaioiolemnfhjncicchinao/blog/2018/05/14/Data-Structures-for-Beginners-Graphs-Time-Complexity-tutorial/">graph post.</a> Let's go through each one. In-Order Traversal In-order traversal visit nodes on this order: left, parent, right. BinarySearchTree.prototype.inOrderTraversal<a href="https://github.com/amejiarosario/dsa.js/blob/master/src/data-structures/trees/binary-search-tree.js">Full Code</a> <table> <tbody> <tr> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">1 2 3 4 5 </pre> </td> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">* inOrderTraversal(node = this.root) { if (node.left) { yield* this.inOrderTraversal(node.left); } yield node; if (node.right) { yield* this.inOrderTraversal(node.right); } } </pre> </td> </tr> </tbody> </table> Let's use this tree to make the example: <table> <tbody> <tr> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">1 2 3 4 5 6 7 </pre> </td> <td> pre data-role="codeBlock" data-info="js" class="language-javascript"> 10 / \ 5 30 / / \ 4 15 40 / 3 </pre> </td> </tr> </tbody> </table> In-order traversal would print out the following values: <code>3, 4, 5, 10, 15, 30, 40</code>. If the tree is a BST, then the nodes will be sorted in ascendent order as in our example. Post-Order Traversal Post-order traversal visit nodes on this order: left, right, parent. BinarySearchTree.prototype.postOrderTraversal<a href="https://github.com/amejiarosario/dsa.js/blob/master/src/data-structures/trees/binary-search-tree.js">Full Code</a> <table> <tbody> <tr> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">1 2 3 4 5 </pre> </td> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">* postOrderTraversal(node = this.root) { if (node.left) { yield* this.postOrderTraversal(node.left); } if (node.right) { yield* this.postOrderTraversal(node.right); } yield node; } </pre> </td> </tr> </tbody> </table> Post-order traversal would print out the following values: <code>3, 4, 5, 15, 40, 30, 10</code>. Pre-Order Traversal and DFS In-order traversal visit nodes on this order: parent, left, right. BinarySearchTree.prototype.preOrderTraversal<a href="https://github.com/amejiarosario/dsa.js/blob/master/src/data-structures/trees/binary-search-tree.js">Full Code</a> <table> <tbody> <tr> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">1 2 3 4 5 </pre> </td> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">* preOrderTraversal(node = this.root) { yield node; if (node.left) { yield* this.preOrderTraversal(node.left); } if (node.right) { yield* this.preOrderTraversal(node.right); } } </pre> </td> </tr> </tbody> </table> Pre-order traversal would print out the following values: <code>10, 5, 4, 3, 30, 15, 40</code>. This order of numbers is the same result that we would get if we run the Depth-First Search (DFS). BinarySearchTree.prototype.dfs<a href="https://github.com/amejiarosario/dsa.js/blob/master/src/data-structures/trees/binary-search-tree.js">Full Code</a> <table> <tbody> <tr> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">1 2 3 4 5 6 7 8 9 10 11 12 </pre> </td> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">* dfs() { const stack = new Stack(); stack.add(this.root); while (!stack.isEmpty()) { const node = stack.remove(); yield node; node.descendents.reverse().forEach(child => stack.add(child)); } } </pre> </td> </tr> </tbody> </table> If you need a refresher on DFS, we covered in details on <a href="chrome-extension://cjedbglnccaioiolemnfhjncicchinao/blog/2018/05/14/Data-Structures-for-Beginners-Graphs-Time-Complexity-tutorial/#Depth-first-search-DFS-Graph-search">Graph post</a>. Breadth-First Search (BFS) Similar to DFS, we can implement a BFS by switching the <code>Stack</code> by a <code>Queue</code>: BinarySearchTree.prototype.bfs<a href="https://github.com/amejiarosario/dsa.js/blob/master/src/data-structures/trees/binary-search-tree.js">Full Code</a> <table> <tbody> <tr> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">1 2 3 4 5 6 7 8 9 10 11 </pre> </td> <td> pre data-role="codeBlock" data-info="js" class="language-javascript">* bfs() { const queue = new Queue(); queue.add(this.root); while (!queue.isEmpty()) { const node = queue.remove(); yield node; node.descendents.forEach(child => queue.add(child)); } } </pre> </td> </tr> </tbody> </table> The BFS order is: <code>10, 5, 30, 4, 15, 40, 3</code> <h2 id="balanced-vs.-non-balanced-trees"><a class="btn" href="#Balanced-vs-Non-balanced-Trees" title="Balanced vs. Non-balanced Trees"></a>Balanced vs. Non-balanced Trees</h2> So far, we have discussed how to <code>add</code>, <code>remove</code> and <code>find</code> elements. However, we haven't talked about runtimes. Let's think about the worst-case scenarios. Let's say that we want to add numbers in ascending order. <img src="chrome-extension://cjedbglnccaioiolemnfhjncicchinao/images/bst-asc.gif" title="Inserting values in ascending order in a Binary Search Tree"/> We will end up with all the nodes on the left side! This unbalanced tree is no better than a LinkedList, so finding an element would take O(n). 😱 Looking for something in an unbalanced tree is like looking for a word in the dictionary page by page. When the tree is balanced, you can open the dictionary in the middle and from there you know if you have to go left or right depending on the alphabet and the word you are looking for. We need to find a way to balance the tree! If the tree was balanced, then we could find elements in O(log n) instead of going through each node. Let's talk about what balanced tree means. <img src="chrome-extension://cjedbglnccaioiolemnfhjncicchinao/images/balanced-vs-non-balanced-tree.jpg" title="Balanced vs unbalanced Tree"/> If we are searching for <code>7</code> in the non-balanced tree, we have to go from 1 to 7. However, in the balanced tree, we visit: <code>4</code>, <code>6</code>, and <code>7</code>. It gets even worse with larger trees. If you have one million nodes, searching for a non-existing element might require to visit all million while on a balanced tree it just requires 20 visits! That's a huge difference! We are going to solve this issue in the next post using self-balanced trees (AVL trees). <h2 id="big-o-notation">Big O Notation</h2> <h3 id="time-complexity">time complexity</h3> it allow us to talk formally about how the runtime of an algorithm grows as the input grows. n = number of operation the computer has to do can be: f(n) = n f(n) = n^2 f(n) = 1 f(n) = could be something entirely different ! O(n): <div id=">pre data-role=" codeBlock" data-info="js" class="language-javascript"><code><a title=" 1">function addUpToSimple(n: number) {</a> <a title="2"> let total = 0;</a> <a title="3"> for (let i = 0; i < n; i++) {</a> <a title="4"> total += i;</a> <a title="5"> }</a> <a id=-6" title="6"> return total;</a> <a title="7">}</a></code></pre> </div> O(1): <div id=">pre data-role=" codeBlock" data-info="js" class="language-javascript"><code><a title=" 1">function addUpComplex(n: number) {</a> <a id=-2" title="2"> return (n * (n + 1)) / 2;</a> <a id=-3" title="3">}</a></code></pre> </div> O(n): maybe thinking O(2n) but we see big picture! BigONotation doesn't care about precision only about general trends linear? quadric? constant? <div id=">pre data-role=" codeBlock" data-info="js" class="language-javascript"><code><a title=" 1">function printUpAndDown(n: number) {</a> <a title="2"> console.log("Going up");</a> <a title="3"> for (let i = 0; i < n; i++) {</a> <a id=-4" title="4"> console.log(i);</a> <a id=-5" title="5"> }</a> <a id=-6" title="6"> console.log("Going down");</a> <a id=-7" title="7"> for (let j = n - 1; j > 0; j--) {</a> <a id=-8" title="8"> console.log(j);</a> <a id=-9" title="9"> }</a> <a id=-10" title="10">}</a></code></pre> </div> O(n^2) <div id=">pre data-role=" codeBlock" data-info="js" class="language-javascript"><code><a title=" 1">function printAllPairs(n: number) {</a> <a id=-2" title="2"> for (let i = 0; i < n; i++) {</a> <a id=-3" title="3"> console.log(i);</a> <a id=-4" title="4"> for (let j = 0; j < n; j++) {</a> <a id=-5" title="5"> console.log(j);</a> <a id=-6" title="6"> }</a> <a id=-7" title="7"> }</a> <a id=-8" title="8">}</a></code></pre> </div> O(n) : cuz as soon as n grows complexity grows too <div> pre data-role="codeBlock" data-info="js" class="language-javascript"><code><a title="1">function logAtLeastFive(n: number) {</a> <a id=-2" title="2"> for (let i = 0; i <= Math.max(5, n); i++) {</a> <a id=-3" title="3"> console.log(i);</a> <a id=-4" title="4"> }</a> <a id=-5" title="5">}</a></code></pre> </div> O(1) <div id=">pre data-role=" codeBlock" data-info="js" class="language-javascript"><code><a title=" 1">function logAtMostFive(n: number) {</a> <a id=-2" title="2"> for (let i = 0; i <= Math.min(5, n); i++) {</a> <a id=-3" title="3"> console.log(i);</a> <a id=-4" title="4"> }</a> <a id=-5" title="5">}</a></code></pre> </div> <h3 id="space-complexity">space complexity</h3> Rules of Thumb - <==(most primitive booleans numbers undefined null are constant space)==>. - <==(strings and reference types like objects an arrays require O(n) space n is string length or number of keys)==> O(1) <div id="cb7"> pre data-role="codeBlock" data-info="js" class="language-javascript"><code><a title="1">function sum(arr: number[]) {</a> <a id="cb7-2" title="2"> let total = 0;</a> <a id="cb7-3" title="3"> for (let i = 0; i < arr.length; i++) {</a> <a id="cb7-4" title="4"> total += arr[i];</a> <a id="cb7-5" title="5"> }</a> <a id="cb7-6" title="6">}</a></code></pre> </div> O(n) <div id="cb8"> pre data-role="codeBlock" data-info="js" class="language-javascript"><code><a title="1">function double(arr: number[]) {</a> <a id="cb8-2" title="2"> const newArr = [];</a> <a id="cb8-3" title="3"> for (let i = 0; i < arr.length; i++) {</a> <a id="cb8-4" title="4"> array.push(arr[i] * 2);</a> <a id="cb8-5" title="5"> }</a> <a id="cb8-6" title="6"> return newArr;</a> <a id="cb8-7" title="7">}</a></code></pre> </div> <h3 id="quick-note-around-object-array-through-bigo-lens">quick note around object, array through BigO lens!</h3> <ul> <li>object:</li> </ul> <div id="cb9"> pre data-role="codeBlock" data-info="js" class="language-javascript"><code><a title="1">const person = { name: "John", age: 22, hobbies: ["reading", "sleeping"] };</a> <a id="cb9-2" title="2"></a> <a id="cb9-3" title="3">Object.keys(person); // ["name", "age", "hobbies"] ---> O(n)</a> <a id="cb9-4" title="4">Object.values(person); // ["John", 22, Array(2)]---> O(n)</a> <a id="cb9-5" title="5">Object.entries(person); // [Array(2), Array(2), Array(2)]---> O(n)</a> <a id="cb9-6" title="6">person.hasOwnProperty("name"); // true ---> O(1)</a></code></pre> </div> <ul> <li>array: push() and pop() are always faster than unshift() and shift() because inserting or removing element from beginning of an array requires reIndexing all elements</li> </ul> <h2 id="common-patterns">Common Patterns</h2> <div id=0"> pre data-role="codeBlock" data-info="js" class="language-javascript"><code><a id=0-1" title="1">function binarySearch(sortedArr: number[], value: number): number {</a> <a id=0-2" title="2"> let min = 0;</a> <a id=0-3" title="3"> let max = sortedArr.length - 1;</a> <a id=0-4" title="4"></a> <a id=0-5" title="5"> while (min <= max) {</a> <a id=0-6" title="6"> let middle = Math.floor((min + max) / 2);</a> <a id=0-7" title="7"> if (sortedArr[middle] < value) {</a> <a id=0-8" title="8"> min = middle + 1;</a> <a id=0-9" title="9"> } else if (sortedArr[middle] > value) {</a> <a id=0-10" title