Scribd
Upload
13 views3 pages

Binary Tree Code Summary

The document outlines the implementation of a binary tree in Python, including the definition of a Node class and functions for initializing the tree, adding nodes, traversing the tree, and searching for values. Key functionalities include managing a free list for node allocation and determining insertion points for new data. The traversal method follows an in-order approach, while the search function checks for the presence of a specific value within the tree structure.

Uploaded by

Nouman Shamim
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
13 views3 pages

Binary Tree Code Summary

The document outlines the implementation of a binary tree in Python, including the definition of a Node class and functions for initializing the tree, adding nodes, traversing the tree, and searching for values. Key functionalities include managing a free list for node allocation and determining insertion points for new data. The traversal method follows an in-order approach, while the search function checks for the presence of a specific value within the tree structure.

Uploaded by

Nouman Shamim
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 3

Line-by-Line Summary of Binary Tree Code

class Node: → Defines a class representing a single node in the binary tree.

def __init__(self): → Constructor initializes a node with data and two child pointers.

self.Data = "" → Stores the data value for the node (initially empty).

self.Left = None → Pointer (index) to the left child node (initially None).

self.Right = None → Pointer (index) to the right child node (initially None).

def initialiseTree(): → Initializes the tree with empty nodes and sets up free list.

global Tree, FreePointer, RootPointer, size → Declares global variables used to


manage the tree.

size = 20 → Sets the maximum number of nodes in the tree.

Tree = [Node() for _ in range(size)] → Creates a list of empty Node objects.

for i in range(size - 1): → Loop to link each node to the next as a free list.

Tree[i].Left = i + 1 → Set Left pointer to next free node's index.

Tree[size - 1].Left = None → Last node in the free list points to None.

FreePointer = 0 → Free list starts at index 0.

RootPointer = None → No root yet — tree is currently empty.

def FindInsertionPoint(NewData): → Finds where to insert new data in the binary tree.

Pointer = RootPointer → Start searching from the root node.

Parent = None → Tracks parent node while traversing tree.

while Pointer is not None: → Keep looping until a null pointer is found.

Parent = Pointer → Save current node as parent.

Current = Tree[Pointer].Data → Get data at current node.

if NewData < Current: → Go left if new data is smaller.

Pointer = Tree[Pointer].Left → Move to left child.


Direction = "Left" → Save direction as left.

else: → Otherwise, go right.

Pointer = Tree[Pointer].Right → Move to right child.

Direction = "Right" → Save direction as right.

return Parent, Direction → Return insertion point and which direction to insert.

def addToTree(NewData): → Adds a new node with given data to the binary tree.

global FreePointer, RootPointer → Access global control variables.

if FreePointer is None: → Check if the tree has space.

print("Tree is full") → If no space, print message.

return → Exit function.

NewPointer = FreePointer → Take the next free node index.

Tree[NewPointer].Data = NewData → Store new data in that node.

FreePointer = Tree[NewPointer].Left → Advance FreePointer to the next free node.

Tree[NewPointer].Left = None → Reset left pointer.

Tree[NewPointer].Right = None → Reset right pointer.

if RootPointer is None: → If tree is empty, this is the root.

RootPointer = NewPointer → Set new node as root.

else: → Otherwise, find place to insert.

Parent, Direction = FindInsertionPoint(NewData) → Find where to attach this


node.

if Direction == "Left": → Attach to left child if applicable.

Tree[Parent].Left = NewPointer → Link parent to new node (left).

else: → Otherwise, attach right.

Tree[Parent].Right = NewPointer → Link parent to new node (right).

def TraverseTree(Pointer=None): → In-order traversal (left, root, right).


global Tree, RootPointer → Access global tree structure.

if Pointer is None: → Start from root if no pointer given.

Pointer = RootPointer → Set pointer to root.

if Pointer is not None: → If pointer is valid, traverse recursively.

TraverseTree(Tree[Pointer].Left) → Visit left subtree.

print(Tree[Pointer].Data) → Print current node data.

TraverseTree(Tree[Pointer].Right) → Visit right subtree.

def SearchTree(Data): → Search for a value in the binary tree.

global Tree, RootPointer → Use global tree structure.

Pointer = RootPointer → Start from root.

while Pointer is not None: → Loop until we find or exhaust the tree.

Current = Tree[Pointer].Data → Get data at current node.

if Current == Data: → Check if found.

print(f"{Data} was found at position {Pointer}") → Print found message.

return → Exit if found.

elif Data < Current: → Go left if data is smaller.

Pointer = Tree[Pointer].Left → Update pointer to left child.

else: → Otherwise go right.

Pointer = Tree[Pointer].Right → Update pointer to right child.

print(f"{Data} was not found") → Print not found message.

You might also like