Skip to main content
100%

Gist f09ab9588a2aa90a6f534845a85d43b8

✓ Published0🌍 Public
Aaarsenault
Last edited Feb 27, 2017
Created on Feb 27, 2017

This example presents a single linked list data structure implemented in Python, demonstrating node traversal, insertion, search, and removal operations. The code defines a `Node` class to store values and references, while the `LinkList` class manages the head node and provides methods such as `push`, `pop`, `search`, and `out_put`. Traversal logic moves through the list iteratively, and the `out_put` method prints each value to the console. The visualization is purely code-based, with no graphical rendering or external libraries.

AI-generated description

Similar vizzes

Loading thumbnail…

LinkedList overview

This visualization demonstrates the structure and operations of linked lists using a text-heavy, illustrated format. It explains node organization, head and tail pointers, and contrasts arrays with linked lists through diagrams and Python code examples. The markdown document includes code snippets defining `ListNode` and `LinkedList` classes, with methods like `setHead` and `insertAtEnd`, and uses embedded images from external sources to show memory layouts. The content also covers algorithmic complexity, comparing O(1) insertions versus O(n) access, and ends with a coding challenge about determining even or odd list length.

TThuyNT13
67% match
Loading thumbnail…

Gist 13007f773bff03dcdb4117a57b9387c1

This example demonstrates a depth-first search algorithm traversing a small graph represented as a Python dictionary, with sets of neighboring nodes as values. It shows how the search visits nodes from a starting point toward a goal, collecting visited nodes into a set and returning the traversal path when the goal is reached. The code uses plain Python data structures and recursion, with no external visualization libraries. The graph’s six nodes (A through F) and their edges are hardcoded, and the algorithm prints the set of visited nodes upon success, while returning `False` if no path exists.

Aaarsenault
65% match
Loading thumbnail…

Gist 598a74e0cb4c65102232

This example demonstrates a C++ program that first simulates traversal and deletion of nodes in a singly linked list, printing the values as it moves and removes each node, and then reads a board from the file `board.txt` into a 2D vector of characters. The rendering shows the board as a grid, printing each cell with its indices and value, and then updates two specific positions to display a modified board. The code relies on standard C++ libraries such as `<iostream>`, `<fstream>`, and `<vector>`, with no external visualization APIs.

NN0taN3rd
61% match
Loading thumbnail…

Recursive depth-first search

This example demonstrates a recursive depth-first search through a tree of Node objects, where each node holds a value and a list of children. The search traverses the tree from the root downward, checking each node’s value and recursively exploring children until a match is found, returning the target node or None. The code builds a sample tree with letters (a through h) and prints the result of searching for 'g', using plain Python classes and methods like `get_value()` and `get_children()`. No external visualization libraries are used; the output is text-based, showing the found node.

Aantonyross
61% match
Loading thumbnail…

Code searches a Tree of nodes, depth-first

This example visualizes a depth-first search of a tree, showing the search path as nodes are visited and discarded. It uses a custom Node class in Python to build the tree structure, with each node holding a value and a list of children. The dfs function traverses the tree using a stack, popping nodes to check their values and printing each visited node to display the search order. The code defines two sample trees and searches for a specific target value, demonstrating how the algorithm explores branches before backtracking.

Aantonyross
60% match
Loading thumbnail…

Gist b9e14cdd96682d931acd2ff1e0c5502e

This notebook demonstrates recursive tree algorithms implemented in Python, defining functions to square tree values, compute height, find maximum values, locate paths, prune branches, and generate hailstone sequences. The code uses a custom `tree` representation as nested lists, with helper functions like `root`, `branches`, and `is_leaf` to navigate the structure. Each algorithm follows a consistent pattern of processing the root, checking for leaf nodes, recursing over branches, and returning the final result. The examples illustrate functional decomposition and recursion for hierarchical data manipulation, with no external visualization libraries involved.

Aakeshavan
59% match
Loading thumbnail…

Gist 5986840

This example demonstrates a minimal Python script that sorts an array of node objects by the `nodename` attribute. It shows how to reorder JSON-structured data before any visualization or further processing occurs. The code defines a small dataset containing two nodes, “foo” and “bar,” and uses the built-in `json` module to print the original and sorted representations. It relies on the standard Python `list.sort` method with a lambda function as the sorting key, directly mutating the `nodes` list and updating the `data` dictionary. The example illustrates a simple preprocessing step common in data-driven visualization workflows.

Aamundo
59% match
Loading thumbnail…

Gist f8b83c150e82b21c7d6fcadc802fb986

This example visualizes a network of interconnected nodes and links, revealing the structure of a graph through spatial clustering and connective pathways. It uses a force-directed layout powered by `d3.forceSimulation` to position nodes, with `d3.drag` enabling interactive repositioning. The rendering relies on SVG elements for both nodes and links, with node fill colors and radii encoding categorical data and degree. The underlying dataset is a static JSON structure of nodes and edges, drawn using standard SVG `circle` and `line` primitives within a responsive viewBox.

PPeleke
58% match