Merge branch 'dev' into 2025linda

Author: LindaStern

src/algorithms/controllers/AVLTreeSearch.js

@@ -2,6 +2,9 @@
  * This file contains the AVL Tree Search algorithm,
  * alongside the visualisation code.
  *
+ * XXX needs a bunch more fixes. Best ignore height and balance, highlight
+ * nodes at the right points (done), improve display of t if possible,...
+ *
  * The AVL Tree Search algorithm is used to find a node.
  * 
  * The search algorithm is based on the tree created by the insertion algorithm. 
@@ -41,51 +44,62 @@ export default {
         let current = root;
         let parent = null;
 
-        chunker.add('AVL_Search(t, k)', (vis) => {
-            vis.graph.setFunctionInsertText(" (" + target + ") ");
+        chunker.add('AVL_Search(t, k)', (vis, c, p) => {
+            vis.graph.setZoom(0.55);
+            vis.graph.setFunctionInsertText("(t, " + target + ")");
             vis.graph.setFunctionName("AVL_Search");
-        });
-        chunker.add('while t not Empty');
+            vis.graph.visit(c, p);
+        }, [current, parent]);
+        if (!tree)
+            chunker.add('while t not Empty');
 
         let ptr = tree;
         parent = current;
 
-        while (ptr) {
+        /* eslint-disable no-constant-condition */
+        while (true) {
+            chunker.add('while t not Empty');
+
+            if (current === undefined || !ptr) // should use null
+                break;
 
-            chunker.add('n = root(t)', (vis, c, p) => vis.graph.visit(c, p), [current, parent]);
             let node = current;
             chunker.add('if n.key = k');
             if (node === target) {
-                chunker.add('if n.key = k', (vis, c, p) => vis.graph.leave(c, p), [node, parent]);
-                chunker.add('return t', (vis, c, p) => vis.graph.select(c, p), [node, parent]);
+                chunker.add('return t', (vis, c, p) => {
+                    vis.graph.leave(c, p);
+                    vis.graph.select(c, p);
+                    vis.graph.setText('Key found');
+                }, [node, parent]);
                 return 'success';
             }
 
             chunker.add('if n.key > k');
             if (target < node) {
-                if (tree[node].left !== undefined) {
-                    // if current node has left child
-                    parent = node;
-                    current = tree[node].left;
-                    ptr = tree[node];
+                parent = node;
+                current = tree[node].left;
+                ptr = tree[node];
+                if (current !== undefined) {
 
-                    chunker.add('t <- n.left');
+                    chunker.add('t <- n.left', (vis, c, p) => vis.graph.visit(c, p), [current, parent]);
                 } else {
-                    break;
+                    chunker.add('t <- n.left', (vis) => vis.graph.setText('t = Empty'));
                 }
-            } else if (tree[node].right !== undefined) {
-                // if current node has right child
+            } else {
                 parent = node;
                 current = tree[node].right;
                 ptr = tree[node];
-
-                chunker.add('t <- n.right');
-            } else {
-                break;
+                // if current node has right child
+                if (current !== undefined) {
+                    chunker.add('t <- n.right', (vis, c, p) => vis.graph.visit(c, p), [current, parent]);
+                } else {
+                    chunker.add('t <- n.right', (vis) => vis.graph.setText('t = Empty'));
+                }
             }
         }
 
-        chunker.add('return NotFound', (vis) => vis.graph.setText('RESULT NOT FOUND'));
+        chunker.add('return NotFound', (vis) => vis.graph.setText('Key not found'));
         return 'fail';
     },
-};
+};
+

src/algorithms/explanations/QSExp.md

@@ -6,35 +6,53 @@ Quicksort is a divide and conquer algorithm. It first rearranges the input
 array into two smaller sub-arrays: the (relatively) low elements and the
 (relatively) high elements. It then recursively sorts each of the sub-arrays.
 
-### Sorting using Quicksort
+## Algorithm overview
 
-The steps for Quicksort are:
+The steps for basic Quicksort are:
 
-* Pick the rightmost element of the array, called a pivot.
+* Pick the *pivot* element of the sub-array; here it is the rightmost
+ element.
 
-* Partitioning: reorder the array so that all elements with values less than the pivot come before the pivot, while all elements with values greater than the pivot come after it. After this partitioning, the pivot is in its final position.
+* Partitioning: reorder the sub-array so that only elements with values less than or equal to the pivot come before the pivot, while only elements with values greater than or equal to the pivot come after it. After this partitioning, the pivot is in its final position.
 
-* Recursively apply the above steps to the sub-array of elements with smaller values and separately to the sub-array of elements with greater values.
+* Recursively apply the above steps to the sub-array of elements before the pivot and separately to the sub-array of elements after the pivot.
 
-The base case of the recursion is arrays of size one or zero, which are in order by definition, so they never need to be sorted.
+The base case of the recursion is sub-arrays of size one or zero, which are in order by definition, so they never need to be sorted.
 
+## Partitioning
 
-### Complexity
+The way partitioning is done here is to use two pointers/indices to
+scan through the sub-array. One starts at the left and scans right
+in search for "large" elements (greater than or equal to the pivot).
+The other starts at the right and scans left in search for "small"
+elements (less than or equal to the pivot). Whenever a large and a small
+element are found they are swapped.  When the two indices meet, the pivot
+is swapped into that position and partitioning is complete.
 
-Time complexity:
-<code>
-   Average case     <i>O(n log n)</i>
-   Worst case       <i>O(n<sup>2</sup>)</i>
-   Best case        <i>O(n log n)</i>
 
-Note: Worst case in quicksort occurs when a file is already sorted, since the partition is highly asymmetrical. Improvements such as median-of-three quicksort make a significant improvement, although worst case behaviour is still possible.  
-</code>
+## Time complexity
 
-Space complexity is O(1), that is, no extra space is required.
+In the best case, partition divides the sub-array in half at each step,
+resulting in <i>O(log n)</i> levels of recursion and <i>O(n log n)</i>
+complexity overall. In the worst case, partition divides the sub-array
+very unevenly at each step.  The pivot element is either the largest or
+smallest element in the sub-array and one of the resulting partitions
+is always empty, resulting in <i>O(n<sup>2</sup>)</i> complexity.
+This occurs if the input is sorted or reverse-sorted. Refinements such
+as median of three partitioning (shown elsewhere) make the worst case
+less likely.  On average, partitioning is reasonably well balanced and
+<i>O(n log n)</i> complexity results.
 
+## Space complexity
 
+Although there is no explicit additional space required, quicksort is
+recursive, so it uses implicit stack space proportional to the depth of
+recursion. The best and average cases are <i>O(log n)</i> but the worst
+case is <i>O(n)</i>.
 
-### Development of Quicksort
+
+
+## Development of Quicksort
 
 The first version of quicksort was published by Tony Hoare in 1961 and
 quicksort remains the *fastest* sorting algorithm on average (subject to
@@ -43,4 +61,4 @@ done in *many* different ways and the choice of specific implementation
 details and computer hardware can significantly affect the algorithm's
 performance. In 1975, Robert Sedgewick completed a Ph.D. thesis on this
 single algorithm.  Our presentation here is influenced by the original
-Hoare version and some of Sedgewick's adaptations. 
+Hoare version and some of Sedgewick's adaptations.