Recursive depth-first search

100%

Recursive depth-first search

✓ Published0🌍 Public

Last edited Mar 21, 2016

Created on Mar 21, 2016

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.

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

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

67% 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

64% 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

61% 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

59% 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

55% match

Loading thumbnail…

Fork of Tree_hd

This example shows a hierarchical tree of programming paradigms—object-oriented, functional, and procedural—with nested subcategories leading to specific languages. Node shapes encode depth: a star marks the root, diamonds level 1, triangles level 2, and squares level 3 leaves. The code uses `d3.hierarchy` and `d3.tree` to compute the layout, `d3.linkVertical` for curved links, and SVG paths for custom node shapes. A legend clarifies the shape-to-level mapping, while an ordinal color scale differentiates depths.

HHarshithaDontha@my.unt.edu

51% match

Loading thumbnail…

Fork of HTML Starter

This example demonstrates how to traverse and render a hierarchical tree structure using D3.js’s `d3.hierarchy` API. It visualizes nested data objects as a series of stacked, blue-bordered `div` elements, where each level of nesting corresponds to a deeper layer of the tree. The code builds the hierarchy from a static raw JavaScript object, then uses `d3.select` and `.append()` to create the DOM nodes, with each element’s text set to the node’s name. The console logs the depth and name of each visited node, illustrating the traversal order.

FFarhaan Qazi

51% match