Skip to main content
100%

Gist 13007f773bff03dcdb4117a57b9387c1

✓ Published0🌍 Public
Aaarsenault
Last edited Mar 10, 2017
Created on Mar 10, 2017

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.

AI-generated description

Similar vizzes

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
69% 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
67% match
Loading thumbnail…

Python implementation of Dijkstra's Algorithm

This example shows a Python implementation of Dijkstra's shortest-path algorithm operating on a graph with weighted edges. It defines a `Graph` class that stores nodes, edges, and distances, then uses the `dijsktra` function to compute the minimum distance from a starting node to all others, returning both the visited distances and the path map. The code relies on Python’s `defaultdict` for edge adjacency and a set-based node collection to iteratively select the unvisited node with the smallest known distance. The visualization itself is not rendered—only the algorithm’s logic and data structures are presented in plain code.

Aabehmiel
65% match
Loading thumbnail…

Gist f09ab9588a2aa90a6f534845a85d43b8

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.

Aaarsenault
65% 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
60% match
Loading thumbnail…

Gist babc8f75061b530146ff

This example demonstrates how a small graph can be converted into a linear system of equations and solved to compute node positions, here yielding values scaled to 50, 100, and 50 for nodes a, b, and c. It shows the process from defining nodes and weighted edges through constructing a matrix equation, solving it with NumPy’s `np.linalg.solve`, and rescaling the result. The visualization relies on Python code and array operations rather than a plotting library, with the final output presented as a list of node–value pairs.

JJonasHeylen
57% match
Loading thumbnail…

Tree Traversals

This interactive visualization demonstrates depth-first and breadth-first tree traversal algorithms on a small dummy dataset. Two buttons trigger the respective traversals, animating each visited node by coloring it red in sequence, while a reset button restores the original white and steel-blue styling. The tree is rendered as a static D3 dendrogram using `d3.layout.tree`, with nodes and links drawn as SVG circles and lines. The animations are driven by chained `transition().style()` calls with incremental delays, and the traversal logic itself relies on basic JavaScript array operations—a stack for depth-first and a queue for breadth-first.

PPooky2011
56% match
Loading thumbnail…

Gist 956273

A graph visualization maps ecological occurrence sets and multipolygon indexes through their shared terms, using a force-directed layout to reveal clusters of related species and regions. The code builds the network from App Engine datastore models, connecting occurrences to their parent sets via reference properties. It renders nodes and edges using d3.forceSimulation, with spatial positioning driven by simulated physics rather than geographic projection, while styling reflects term rank and type metadata from the stored entities.

Aandrewxhill
55% match