Lecture6-Trees

Course Information

• Course: CSCI 3230 Data Structures

• Instructor: M Arif Rahman, Ph.D.

• Department: Computer Science, Georgia Southern University

• Email: marahman@georgiasouthern.edu

Table of Contents

1. What is a tree?

2. Traverse a tree

3. Binary tree

4. Inorder Traversal

What is a Tree?

• Definition: In computer science, a tree is an abstract data type (ADT) that models a hierarchical structure consisting of nodes connected by edges. Each tree has a single root node, from which all other nodes branch out, creating a parent-child relationship.

• Structure: A tree consists of nodes, where each node contains a value or data, along with references (or pointers) to its children. This structure allows for efficient searching, insertion, and deletion of data.

• Applications: Trees are utilized in various applications including but not limited to:

  • Organization charts: Visual representation of the hierarchy in a business or organization.

  • File systems: Representing directories and files in operating systems.

  • Programming environments: Managing syntactic structures in compilers and interpreters.

Tree Terminology

• Roots and Relationships:

  • Root: The node at the top of the tree, which has no parent. It is the entry point to the tree data structure.

  • Parent-Child Relationship: A node (parent) that points to other nodes (children), establishing a hierarchical structure.

  • Internal Node: A node that has at least one child, indicating it is not a leaf.

  • External Node (Leaf): A node that has no children, situated at the terminal points of the tree.

  • Ancestors of a Node: Includes the node itself, its parent, grandparent, and all predecessor nodes up to the root.

  • Descendants of a Node: Includes the node itself, its child, grandchild, and all nodes downstream.

  • Depth of a Node: The number of edges from the root to that node, defining its position in the hierarchy.

  • Height of a Tree: The maximum depth of any node in the tree, indicating the longest path from the root to a leaf.

  • Subtree: A tree structure that consists of a certain node and all its descendants.

Tree Interface

• Classes Involved:

  • treeNode Class: Represents an individual node in the tree structure, encapsulating data and links to child nodes.

• Methods:

  • getParent(): Returns the parent of the current node.

  • setParent(): Assigns a parent node to the current node.

  • getChildren(): Retrieves all child nodes of the current node.

  • setChildren(): Sets the child nodes of the current node.

  • numChildren(): Returns the number of children for the current node.

• Tree Class: Represents the entire tree structure, managing nodes and tree operations.

• Attributes and Methods:

  • root: The root node of the tree.

  • size: Total number of nodes in the tree.

  • height: Height of the tree.

  • isEmpty(): Checks if the tree has any nodes.

  • isInternal(node): Evaluates if a specified node is an internal node.

  • isExternal(node): Checks if a specified node is an external node.

  • isRoot(node): Determines if a specified node is the root.

  • traversal(): Method to traverse the tree and access all nodes.

Traverse a Tree

• Traversal Techniques:

  • Preorder Traversal:

    • Algorithm Code:

      preOrder(v)  
      visit(v)  
      For each child w of v: preOrder(w)  

    • Description: In a preorder traversal, the algorithm visits the current node before recursively visiting its descendants, allowing for actions that need to process a node immediately such as printing.

  • Postorder Traversal:

    • Description: In a postorder traversal, the algorithm visits each child node before its parent. This is useful for operations where children need to be processed before their parent, such as deleting a subtree.

    • Algorithm:

      postOrder(v)  
      For each child w of v: postOrder(w)  
      visit(v)  

Binary Tree

• Definition: A binary tree is a special kind of tree where each internal node has at most two children, referred to as the left and right child, which allows for efficient binary search operations.

• Applications:

  • Arithmetic expressions: Encodes operations in a structured way for evaluation.

  • Decision processes: Helps in making decisions based on comparisons and conditional statements.

  • Searching: Assists in organizing data for faster search functionality, particularly with binary search trees.

• Special Trees:

  • Arithmetic Expression Trees: Internal nodes correspond to operators (e.g., +, -, *) and external nodes represent operands (e.g., variables, constants).

  • Decision Trees: Internal nodes are questions with either yes or no answers, guiding paths to decisions at the leaf nodes.

Properties of Proper Binary Trees

• Definition: A proper binary tree (or full binary tree) is one where each internal node has exactly two children, making it complete in structure.

• Properties:

  • The number of external nodes (e) and internal nodes (i) is related by the equation: e = i + 1

  • The total number of nodes (n) can be derived with: n = 2e - 1

  • The height (h) of the tree adheres to the constraints: h ≤ i, h ≤ (n - 1) / 2

  • External node count must satisfy: e ≤ 2h

  • Height is bounded by: h ≥ log2(e), h ≥ log2(n + 1) - 1

Binary Tree Interface Design

• binaryTreeNode Class: Represents a node within a binary tree, encapsulating data specific to binary operations.

• Methods: Include getters and setters specific to left and right child positions, along with utility functions for various binary tree operations.

• Tree Class: Similar structure to the treeNode, but manages attributes like root, size, height and implements methods tailored for binary tree operations.

Inorder Traversal

• Algorithm:

  • Algorithm Code:

    inOrder(v)  
    If left(v) ≠ null, execute inOrder(left(v))  
    visit(v)  
    If right(v) ≠ null, execute inOrder(right(v))  

  • Description: In an inorder traversal, a node is visited after its left child and before its right child, providing a sorted order for binary search trees, hence commonly used in various algorithm designs.

Print and Evaluate Arithmetic Expressions

• Description: An arithmetic expression represented in a binary tree structure can be evaluated and printed recursively with a traversal technique, often utilizing postorder for evaluation and preorder for printing.

• Example Structure:

  • For a node that contains an operator, its evaluation involves recursively obtaining the values of its left and right children, indicating an operation between those values.

Array-Based Representation of Binary Trees

• Storage Method: Nodes in the binary tree are stored in an array format leveraging rank calculations that imply the placement of children based on their linking to their parent node.

• Ranking Logic:

  • Rank(root) = 0

  • For left child: rank(node) = 2 * rank(parent(node)) + 1

  • For right child: rank(node) = 2 * rank(parent(node)) + 2

Comparison of Structures

• Linked Structure: Each node needs explicit representation of three pointers per position (to parent and two children), enhancing flexibility but requiring more overhead in memory.

• Array Representation: Takes advantage of implicit representation, which can lead to improved memory efficiency when the tree is dense, though it may become inefficient with sparse trees as gaps exist in the array representation.

Conclusion

• The course provides a comprehensive overview of fundamental concepts of data structures with a particular emphasis on tree structures. This understanding is crucial not only for theoretical insights but also for practical applications within the field of computer science.

What is a Tree?

• Definition: In computer science, a tree is an abstract data type (ADT) that illustrates a hierarchical structure made up of nodes linked by edges. At the apex of this hierarchy lies a unique root node, which serves as the starting point for all other nodes, thus forming parent-child connections.

• Structure:

  • A tree consists of nodes, each containing a value or data, along with references to any children it may have.

  • This design facilitates efficient operations for searching, inserting, and deleting data.

• Applications:

  • Organization Charts: These charts visually depict hierarchical relationships within organizations.

  • File Systems: Trees represent files and directories in an operating system.

  • Compilers and Interpreters: In programming contexts, trees manage the syntax of code structures efficiently.

Pseudo Code Example

class Node:
    def __init__(self, value):
        self.value = value
        self.children = []

class Tree:
    def __init__(self, root_value):
        self.root = Node(root_value)

    def add_child(self, parent_value, child_value):
        parent_node = self.find_node(self.root, parent_value)
        if parent_node:
            parent_node.children.append(Node(child_value))
    
    def find_node(self, current_node, value):
        if current_node.value == value:
            return current_node
        for child in current_node.children:
            result = self.find_node(child, value)
            if result:
                return result
        return None

Questions to Ask the Professor

• How are tree data structures typically implemented across different programming languages?

• What advantages do trees present compared to other data structures designed for hierarchical data management?

Traverse a Tree

• Traversal Techniques:

  • Preorder Traversal:

    • Description: During a preorder traversal, the algorithm first visits the current node before moving on to its descendants. This method is particularly useful for tasks that require immediate processing of a node's value, such as printing.

    • Algorithm Pseudo Code:

    def preOrder(node):
        visit(node)
        for each child in node.children:
            preOrder(child)

  • Postorder Traversal:

    • Description: In a postorder traversal, each child node is processed before its parent node. This technique is ideal for operations where information from children must be gathered prior to processing the parent, such as in subtree deletion.

    • Algorithm Pseudo Code:

    def postOrder(node):
        for each child in node.children:
            postOrder(child)
        visit(node)

Questions to Ask the Professor

• What are the advantages and disadvantages of the various tree traversal methods concerning their time complexity?

• Can you provide examples of situations where postorder traversal is more favorable than preorder traversal?

Binary Tree

• Definition: A binary tree represents a specialized form of a tree structure where each internal node is limited to a maximum of two children, typically referred to as the left and right child. This configuration promotes efficient binary search operations.

• Applications:

  • Arithmetic Expressions: They systematically encode operations for rapid evaluation.

  • Decision Processing: Aids in executing binary decisions based on comparisons.

  • Searching: Enhances data organization for quicker search processes, especially in the context of binary search trees.

Questions to Ask the Professor

• How does the binary tree configuration contribute to enhanced search efficiency compared to other data structures?

• What common challenges arise during the implementation of binary trees?

Inorder Traversal

• Algorithm:

  • Description: In an inorder traversal, nodes are visited in a sequence that processes each node after its left child and before its right child. This order produces a sorted output when applied to binary search trees, making it a valuable approach in algorithm design.

  • Algorithm Pseudo Code:

    def inOrder(node):
        if node.left is not null:
            inOrder(node.left)
        visit(node)
        if node.right is not null:
            inOrder(node.right)

Questions to Ask the Professor

• Can you illustrate real-world applications that effectively utilize inorder traversal?

• Are there specific scenarios where inorder traversal might not be the optimal choice?

Print and Evaluate Arithmetic Expressions

• Description: An arithmetic expression can be represented as a binary tree structure, enabling both evaluation and printing of expressions through traversal techniques. Postorder traversal is often used for evaluation, while preorder traversal facilitates printing.

• Pseudo Code Example for Evaluation:

def evaluate(node):
    if node is a leaf:
        return node.value
    left_value = evaluate(node.left)
    right_value = evaluate(node.right)
    return apply_operator(node.value, left_value, right_value)

Questions to Ask the Professor

• What algorithms are best suited for evaluating expressions represented as binary trees?

• How does the structure of the tree impact the evaluation process?

Array-Based Representation of Binary Trees

• Storage Method: Nodes in a binary tree can be stored in an array format, using index calculations to locate parent-child relationships without the necessity for explicit pointers.

• Ranking Logic:

  • For the root node, rank = 0.

  • For a left child: rank(node) = 2 * rank(parent(node)) + 1.

  • For a right child: rank(node) = 2 * rank(parent(node)) + 2.

Questions to Ask the Professor

• What are the advantages and disadvantages of using an array-based approach for binary tree representation compared to linked structures?

• In what scenarios would an array-based representation be more beneficial?

Comparison of Structures

• Linked Structure: Requires explicit representation of up to three pointers for each node (to parent and two children), providing flexibility but increasing memory overhead.

• Array Representation: Utilizes implicit representation, which can yield improved memory efficiency for dense trees, although it may result in wasted space within sparse trees due to gaps in the array.

Questions to Ask the Professor

• How do linked and array-based structures perform in terms of memory usage and access speed?

• What real-world examples illustrate the effectiveness of one structure over the other?

Conclusion

This comprehensive overview of essential concepts in data structures highlights the importance of trees, particularly in relation to their applications and efficiency. Understanding these principles forms a crucial foundation for both theoretical and practical explorations in the field of computer science.