Skip to main content
100%

Code searches a Tree of nodes, depth-first

✓ Published0🌍 Public
Aantonyross
Last edited Mar 18, 2016
Created on Mar 18, 2016

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.

AI-generated description

Similar vizzes

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

Binary search tree implemented in js

This example demonstrates an in-order traversal of a binary search tree, printing each node’s value to the console in ascending order. The tree is built iteratively from hardcoded values (100, 5, 10, 25, 14, 140, 314, 500) using plain JavaScript functions `createNode` and `addNode`, with no external libraries. The `traverse` function recursively visits the left subtree, logs the current value, then visits the right subtree, showing the classic depth-first search pattern. The output appears as sequential `console.log` messages, not as a graphical visualization.

Aallyraza
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
60% 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
58% match
Loading thumbnail…

search and read

This example demonstrates a file-searching utility that locates every `target.txt` file within a directory tree and prints its contents to the console. The code uses the `os.walk` API to traverse directories recursively, collecting paths where the target file exists, then opens and reads each matching file with Python’s built-in `open` function. The rendering approach is purely text-based, with output delivered as sequential lines from each located file. No external visualization libraries are employed; instead, the focus is on demonstrating filesystem traversal and conditional file matching through standard library functions.

CCameron-Grams
58% match
Loading thumbnail…

Gist 79ed32828a2db39ec232

This example demonstrates a divide-and-conquer binary search tree constructed over a set of disjoint line segments that span a horizontal strip, with endpoints on two parallel lines. It visualizes how the segments partition the strip into regions and how a query point can be located by traversing the tree. The code uses D3.js with SVG to draw the segments, circles, and tree edges, and employs custom helper functions like `dataAppend` and `translate` from d3-jetpack. The tree is built by recursively splitting the sorted list of bottom endpoints, and the visualization highlights the connection between the geometric arrangement and the hierarchical search structure.

11wheel
54% match