Tree Traversal Pseudocode (Pre-order)

Duration: 8 min

This video lesson is available to enrolled students.

Return to /learn/COAL-INDIA-MANAGEMENT-TRAINEE/programming-data-structures/tree/traversals-construction/asset-tree-traversal-pseudocode-pre-order after enrolling

Inside: a video lesson and guided study material.

Module outline

  1. About Course: About the Course
  2. Paper-2 | Programming & Data Structures: C Fundamentals, Control Flow, Functions, Arrays & Pointers, Storage Classes, Structures & Enums, DMA, Macros, Scoping & File Handling, Introduction to DS, Array, Stack, Queue, Linked List, Tree, Graphs, Hashing
  3. Paper-2 | Databases / DBMS & SQL: Basics of DBMS, ER Diagram, Relational Model & Functional Dependencies, Keys & Integrity Constraints, Normalization (1NF - BCNF), Decomposition Properties & 4NF, File Organization & Indexing, Relational Algebra, SQL, Relational Calculus, Transaction Management, Concurrency Control
  4. Paper-2 | Algorithms: Algorithm Analysis, Time Complexity Analysis, Sorting Algorithms, Greedy Algorithms, Dynamic Programming, Minimum Spanning Trees, Shortest Path Algos
  5. Paper-2 | Computer Networks & Security: Introduction to CN, Data Communication, DLL: Access Control, DLL: Flow Control, DLL: Error Control, DLL: Framing, Data Link Layer - Ethernet, Net Layer: IPv4 & Proto, Net Layer: IP Addressing, Net Layer:Routing Protocol, Transport Layer Services, TL: Congestion & UDP, Application Layer, Hardware Basics, Network Access Technologies, Network Security
  6. Paper-2 | Digital Logic: Digital Systems & Boolean Basics, Logic Gates & Hardware, Boolean Expression, Boolean Minimization, Combinational Circuit, Sequential Circuits, Number System, Number Representation, Floating Point Rep
  7. Paper-2 | Operating System: Introduction to OS, Process Management, CPU Scheduling, Process Synchronization, Threads & Process Creation, Deadlock, Memory Management, Virtual Memory, Disc Scheduling, File Management
  8. Paper-2 | Theory of Computation: Introduction to TOC, Deterministic FA (DFA), Non-Deterministic FA, Regular Expressions, Grammar, Regular Language Properties, Moore & Mealy Machines, Pushdown Automata & CFG, Turing Machines
  9. Paper-2 | Computer Organization & Architecture: Basics of COA, Cache Memory Organization, Input Output Organisation, Pipelining, Instr Formats & Modes, Control Unit Design, Programming the Basic Computer
  10. Paper-2 | Compiler Design: Intro to Compilers, Lexical Analysis, Grammar & CFG, Syntax Analysis: Top-Down, Syntax Analysis: Bottom-Up, Semantic Analysis & SDT, Intermediate Code Gen, Code Optimization, Run Time Environment
  11. Paper-1 | General Awareness: Polity, Physics, Biology, Chemistry, Static General Knowledge, GK- Current Affairs, History, Geography, Indian Economy, Environment
  12. Paper-1 | Logical Reasoning: Series (Number and Letter Series) (Numerical Relations and Reasoning), Coding Decoding, Non Verbal Reasoning (Spatial Aptitude) (Spatial Reasoning) (Visual Reasoning), Data Interpretation, Blood Relations, Syllogisms, Deductive and Inductive Reasoning (Logical Deduction and Induction) (Prepositional Reasoning), Selection Decision Table (Decision Making), Clock, Calendar, Cubes & Dices, Directions (Direction Test), Analogy, Seating Arrangements, Analytical Reasoning (Counting Figures Reasoning)
  13. Paper-1 | Quantitative Aptitude: Ratio and Proportion (Ratios), Mixture and Alligation, Permutation and Combination, Number System, HCF LCM, Speed Time and Distance, Average, Age Problems, Percentage, Profit and Loss, Time and Work, Pipe and Cistern, Simple Interest and Compound Interest, Powers and Exponents (Surds and Indices), Mensuration and Geometry, Probability, Statistics, Arithmetic, Algebra
  14. Paper-1 | English: Vocabulary, Comprehension / Reading Comprehension / Unseen Passages (Critical Reasoning) (Paragraph Questions), Sentence Re-arrangements (Para Jumbles) (Narrative Sequencing), Sentence Correction (Error Correction), Sentence Completion (Fill in the blanks), Sentence Construction, Cloze Test (Cloze Passage)
  15. Coal India Previous Year Paper:
  16. Engineering Mathematics: Set Theory, Relations, Functions, Graph Theory, Group Theory, Propositional and Predicate Logic, Linear Algebra, Calculus
  17. Coal India Mock Test:
AI summary & chapters

AI Summary

An AI-generated summary of this video lecture.

The video lecture provides a detailed analysis of a C function named `what` designed to traverse a binary tree. The instructor begins by presenting the code snippet, which takes a pointer to a binary tree node (`struct Bnode *t`) as an argument. He explains the logic flow, highlighting the base case check `if (t)` and the three operations performed within the block: printing the node's data, recursively calling the function on the left child (`LC`), and then on the right child (`RC`). To illustrate the function's behavior, the instructor draws a sample binary tree with the root node 10, left child 20, right child 30, and further children 40 and 50 under node 20. He then manually traces the execution of the function on this tree, writing down the sequence of recursive calls. Finally, he deduces the output sequence (10, 20, 40, 50, 30) and identifies the traversal method as Preorder Traversal.

Chapters

  1. 0:00 – 2:00 00:00-02:00

    The video begins with a clear display of the C code snippet `void what(struct Bnode *t)`. The instructor uses a digital pen to underline the function name `what` and the parameter `t`, emphasizing that this is a recursive function operating on a binary tree node structure. He explains the `if (t)` condition, which serves as the termination condition for the recursion, ensuring the function stops when it reaches a null pointer. He then points to the three lines inside the `if` block: `printf("%d', t->data);`, `what(t->LC);`, and `what(t->RC);`. He highlights the specific order of these operations, noting that the data is printed first, followed by the recursive call to the left child, and finally the right child.

  2. 2:00 – 5:00 02:00-05:00

    To visualize the function's behavior, the instructor draws a binary tree on the right side of the screen. The tree has a root node with value 10. The left child of 10 is 20, and the right child is 30. Node 20 further has a left child 40 and a right child 50. He starts the execution trace by writing `what(10)` on the board. He explains that since 10 is not null, the function prints 10. Then, it recursively calls `what` on the left child, which is 20. He writes `what(20)` below `what(10)`. He continues this process, writing `what(40)` as the next recursive call on the left child of 20.

  3. 5:00 – 7:47 05:00-07:47

    The instructor completes the trace by writing `what(50)` for the right child of 20. After finishing the left subtree of the root, he traces the right child of 10, writing `what(30)`. He then compiles the final output sequence based on the order of `printf` statements: 10, 20, 40, 50, 30. He writes "preorder" underneath the sequence to explicitly name the traversal type. He concludes that the function performs a Preorder Traversal because it visits the root node before its children.

The lecture effectively demonstrates how to analyze recursive tree traversal functions. By breaking down the code into its constituent parts (base case, processing, recursion) and applying it to a concrete example, the instructor clarifies the concept of Preorder Traversal. The visual tracing of the call stack and the resulting output sequence provides a clear understanding of the 'Root-Left-Right' order characteristic of this traversal method. This step-by-step approach helps students understand how recursive calls are managed and how the final output is generated based on the order of operations in the code.

Loading lesson…