Skip to main content
100%

HeapSort implementation

✓ Published0🌍 Public
Aammarasmro
Last edited Nov 14, 2020
Created on Nov 14, 2020

HeapSort implementation demonstrates the classic heapsort algorithm sorting a randomly generated integer array. The code builds a max heap from an unsorted array of ten random integers, then repeatedly extracts the maximum element to produce a sorted sequence. The visualization uses Java's `SimpleWriter` and `SimpleWriter1L` APIs from the components library to output both the initial unsorted values and the final sorted result to the console. The program generates its data source internally using `Math.random()` to create pseudorandom integers between 0 and 199, then prints each stage of the process, showing the array before and after sorting.

AI-generated description

Similar vizzes

Loading thumbnail…

insertion sort in node

This visualization demonstrates an insertion sort algorithm sorting an array of thirteen numbers in ascending order. It uses JavaScript’s native array operations and a while loop to shift elements, showing the step-by-step reordering of the dataset. The code relies on standard JavaScript syntax rather than external libraries, logging the final sorted array to the console via `console.log`. The visualization captures the algorithm’s logic through the source code itself, illustrating the comparison and insertion mechanics without graphical rendering.

VVinodLouis
60% match
Loading thumbnail…

Some data structures and algorithms in Java

This example implements classic data structures and algorithms in Java, including binary search trees, merge sort, quicksort, factorial, exponentiation, Fibonacci sequences, string permutation generation, and range unionization. The code uses Java’s built-in `ArrayList`, `Arrays`, and `Collections` APIs, along with custom classes like `Node`, `Tuple`, and `Unionizer`. Random test arrays are generated via `Math.floor` and `Math.random` to benchmark sorting performance, with results printed to the console. The visualization highlights the logic behind each algorithm through clear method signatures and step-by-step control flow.

KKirkHunter
59% match
Loading thumbnail…

quickSort.js

This example visualizes the recursive quicksort algorithm sorting a small numeric array, showing the step-by-step partition process and final sorted order. The code defines a `quickSort` function that selects a pivot from the middle of the array, uses two pointers to swap elements out of place, and recursively sorts the subarrays on either side. It demonstrates the algorithm’s logic directly in JavaScript with console output, using no external libraries. The rendering approach is textual, logging the unsorted and sorted arrays to the console, while the source data is a hardcoded array `[7, 0, 2, 1, 9, 2]`. The example highlights the algorithm’s core mechanics rather than a graphical chart.

WWill Carter
58% match
Loading thumbnail…

Mergesort w/ color

A random array of 100 values is sorted by the mergesort algorithm, with each value drawn as a colored vertical line whose color transitions from light green to dark green based on its numeric value. The animation shows the sorting process as lines move between two horizontal bands representing the two arrays being merged, with copies and swaps visualized through D3 transitions. The code uses d3.shuffle, d3.scale.ordinal for positioning, and d3.scale.linear for the color ramp, rendering in SVG with animated transitions.

Aalexmacy
58% match
Loading thumbnail…

Implementing bubble sort in node

This visualization demonstrates a bubble sort algorithm in action, using an array of 13 numbers as the data source. The code implements the sort with nested JavaScript loops, comparing adjacent values and swapping them when the left value exceeds the right one, with a temporary variable storing values during each swap. The inner loop iterates progressively fewer times through the array on each pass, accounting for elements already sorted at the end. A console.log statement outputs the fully sorted array, while commented-out logging shows the sort state at each iteration for debugging.

VVinodLouis
57% match
Loading thumbnail…

Quicksort V

A visualization of quicksort on 100 elements, where each horizontal row represents the array state after a single swap and colored lines trace each element’s positional movement through the sorting process. The code uses d3.v3 with custom SVG path interpolators to render the straight and diagonal segments, and a cubehelix color scale to differentiate elements. Randomly shuffled data is generated with `d3.shuffle` and `d3.range`, and the quicksort algorithm is implemented manually to record swap operations.

Mmbostock
56% match
Loading thumbnail…

Gist 810577150f4b252e8faa69e7060bf3af

This example presents a Clojure visualization of a custom sorting algorithm called `sorting-sort`. The code defines two functions: `remove-one`, which removes a specified item from a list using `split-with` and `rest`, and `sorting-sort`, which iteratively finds the minimum value in an unsorted collection via `apply min`, removes it, and appends it to a sorted vector within a `loop`/`recur` construct. The visualization likely animates this selection-sort-like process, though no graphical library is shown; the gist contains only the algorithmic logic without any rendering or charting API.

66ewis
56% match
Loading thumbnail…

array javascript

This example shows a minimal HTML page that sorts a JavaScript array of numbers in ascending order and logs the result to the browser console. The page relies on native JavaScript’s `Array.prototype.sort()` method with a comparator function, and outputs the sorted array using `console.dir()`. Styling is applied via a CSS rule for a large centered message, though no visual chart or WebGL rendering is present. The code demonstrates basic data manipulation with a plain array literal, but no external libraries or visualization APIs are used.

FFrancisco Ibelles
56% match