In the

###

let's understand it with an example

let's say we have a binary tree as you see in the image given below.

First, we need to divide the whole tree into subtrees as you see in the given image above. and then we start traversing the tree.

as you see first we visit the left subtree of the root node in inorder. so the root node is

In the subtree, there is no left subtree so we first visit the left node and then the root node, and then the right node.

so the inorder traversal of subtree

now find the inorder of subtree

now go to the root node P so the inorder is

now find the inorder of subtree

so first we need to find the inorder of the

so the inorder of subtree

now we find the inorder of subtree

so the inorder of subtree

now we substitute the inorder of right subtree C into the so the inorder of the binary tree is

####

**inorder traversal**of the binary tree, we first visit the left subtree of the root node, and then we visit the root node and after that, we visit the right subtree of the root node.###
__Properties of Inorder traversal__

- Traverse the left subtree of the root in inorder
- Visit the root node
- Traverse the right subtree of the root in inorder

let's understand it with an example

let's say we have a binary tree as you see in the image given below.

First, we need to divide the whole tree into subtrees as you see in the given image above. and then we start traversing the tree.

as you see first we visit the left subtree of the root node in inorder. so the root node is

**P**and its left subtree is B but in the subtree**B**, there is also a left subtree**D**so we first start traversing with subtree**D**.In the subtree, there is no left subtree so we first visit the left node and then the root node, and then the right node.

so the inorder traversal of subtree

**D**is**T S Q**and inorder of subtree**B**is**D A E**and substitute the value of subtree**D**so the inorder is**T S Q A E P F C**now find the inorder of subtree

**E**and the inorder of**E**is**E D**so the inorder is**T S Q A E D P F C**now go to the root node P so the inorder is

**T S Q A E D P F C**now find the inorder of subtree

**C**but in the subtree**C**, there is also left subtree**F**and right subtree**G.**so first we need to find the inorder of the

**F**subtree because it's a left subtree and in inorder, the left subtree comes first, and then the root node and right node.so the inorder of subtree

**F**is**M**so the inorder of subtree**C**is**M X G**now we find the inorder of subtree

**G**so the inorder of subtree is**C R**so the inorder of subtree

**C**is**M X C R**now we substitute the inorder of right subtree C into the so the inorder of the binary tree is

**T S Q A E D P M X C R**####
__Program to find the inorder of binary trees using the python programming language.__

from collections import deque class Node: def __init__(self, value): self.info = value self.lchild = None self.rchild = None class BinaryTree: def __init__(self): self.root = None def is_empty(self): return self.root is None def display(self): self._display(self.root, 0) print() def _display(self,p,level): if p is None: return self._display(p.rchild, level+1) print() for i in range(level): print(" ", end='') print(p.info) self._display(p.lchild, level+1) def preorder(self): self._preorder(self.root) print() def _preorder(self,p): if p is None: return print(p.info, " ", end='') self._preorder(p.lchild) self._preorder(p.rchild) def inorder(self): self._inorder(self.root) print() def _inorder(self,p): if p is None: return self._inorder(p.lchild) print(p.info," ", end='') self._inorder(p.rchild) def postorder(self): self._postorder(self.root) print() def _postorder(self,p): if p is None: return self._postorder(p.lchild) self._postorder(p.rchild) print(p.info," ",end='') def level_order(self): if self.root is None: print("Tree is empty") return qu = deque() qu.append(self.root) while len(qu) != 0: p = qu.popleft() print(p.info + " ", end='') if p.lchild is not None: qu.append(p.lchild) if p.rchild is not None: qu.append(p.rchild) def height(self): return self._height(self.root) def _height(self,p): if p is None: return 0 hL = self._height(p.lchild) hR = self._height(p.rchild) if hL > hR: return 1 + hL else: return 1 + hR def create_tree(self): self.root = Node('p') self.root.lchild = Node('Q') self.root.rchild = Node('R') self.root.lchild.lchild = Node('A') self.root.lchild.rchild = Node('B') self.root.rchild.lchild = Node('X') ########################## bt = BinaryTree() bt.create_tree() bt.display() print() print("Preorder : ") bt.preorder() print("") print("Inorder : ") bt.inorder() print() print("Postorder : ") bt.postorder() print() print("Level order : ") bt.level_order() print() print("Height of tree is ", bt.height())

#### Also, read these posts

- What are Data Structures and algorithms
- Algorithm design and analysis
- Classification of algorithms
- How to calculate the running time of an algorithm.
- Worst Average and Best-case analysis of the algorithm.
- Big o notation
- Big o notation examples
- Linked List in Data Structures
- Traversing in Linked list
- Operations on the linked list
- Insertion in the linked list
- Deletion in a linked list
- Reversing a linked list
- Sorting a linked list
- Find and remove the loop in the linked list
- Doubly linked list
- Insertion in the doubly linked list
- Deletion in the doubly linked list
- Reversing a doubly linked list
- Circular linked list
- Insertion in the circular linked list
- Deletion in the circular linked list
- Merge two linked list
- Header linked list
- Sorted linked list
- Stack in data structures
- Queue in data structures
- Circular queue
- Dequeue in the data structure
- Priority queue
- Polish notation
- Tree in the data structure
- Binary tree
- Array representation of the binary tree
- linked representation of a binary tree
- Traversing in the binary tree
- Preorder traversal in the binary tree
- Postorder traversal in the binary tree
- Level order traversal in the binary tree
- Binary search tree
- Insertion in the binary search tree
- Deletion in the binary search tree
- Heap in data structures

- What are Data Structures and algorithms
- Algorithm design and analysis
- Classification of algorithms
- How to calculate the running time of an algorithm.
- Worst Average and Best-case analysis of the algorithm.
- Big o notation
- Big o notation examples
- Linked List in Data Structures
- Traversing in Linked list
- Operations on the linked list
- Insertion in the linked list
- Deletion in a linked list
- Reversing a linked list
- Sorting a linked list
- Find and remove the loop in the linked list
- Doubly linked list
- Insertion in the doubly linked list
- Deletion in the doubly linked list
- Reversing a doubly linked list
- Circular linked list
- Insertion in the circular linked list
- Deletion in the circular linked list
- Merge two linked list
- Header linked list
- Sorted linked list
- Stack in data structures
- Queue in data structures
- Circular queue
- Dequeue in the data structure
- Priority queue
- Polish notation
- Tree in the data structure
- Binary tree
- Array representation of the binary tree
- linked representation of a binary tree
- Traversing in the binary tree
- Preorder traversal in the binary tree
- Postorder traversal in the binary tree
- Level order traversal in the binary tree
- Binary search tree
- Insertion in the binary search tree
- Deletion in the binary search tree
- Heap in data structures

## 0 Comments