Traversal is very important in any type of data structure. From the concept of traversal, you will visit every data structure at least once. The traversal function is very crucial in any type of data structure such as searching. It is important to visit all the elements of the data structure at least once so that you can compare each element that is provided in the key.Like the various types of data structure, the data of the tree is also traversed to get access to each element. This process is defined as the node of the tree data structure. let us know more about that the In Order Tree Traversal Without Stack-Know More.

**Definition of Inorder Tree Traversal**

Inorder Tree Traversal is defined as a process in which a tree is traversed and it involves the visit of the left child, then it visits the node, and last but not least it visits the right child.

The process of Inorder Tree Traversal is used in binary search trees. It helps the *node value* to give outputs in *ascending* order.

**How to use Inorder Tree Traversal without stack**?

As a tree does not have a linear data structure, and there are various child nodes, that child node will help you to visit a node that is visited earlier. Nodes are stored in a stack so that you can visit the nodes later in the future.

Nodes can be stored in a stack with the process of recursion. With the help of the method of Morris Traversal, inorder tree traversal can be used without stack.

Morris Traversal is defined as a method of a binary tree that is threaded and it is the process by which you can *traverse* an inorder tree without using a stack. Morris traversal is used for:

- Morris Traversal creates links to inorder successors.
- With the help of created links Morris traversal prints the information.
- When the Morris traversal completes, it restores the original tree and reverts the changes.

**Example of Inorder Traversal using Morris Traversal**

#include <stdio.h>

#include <stdlib.h>

/* Every tree node has some value, it has a pointer to the left child (leftChild)and it has a pointer to the right child (rightChild) */

Struct treeNode

*{*

Int value;

struct treeNode* leftChild;

struct treeNode* rightChild;

*}*

**Example of using Morris Traversal to traverse a tree without using a stack**

Void Morris Traversal (struct treeNode* root)

*{*

Struct treeNode *current, *predecessor Current;

If (root== NULL)

return;

current=root;

//The while loop continues to work until the current root shows NULL

while (current! = NULL)

*{*

*If (current->leftChild == NULL)*

*{*

print(“%d “, current->value);

current= current->rightChild;

*}*

//inorder predecessor of the current node

predecessorofCurrent = current->leftChild

while (predecessorofCurrent->rightChild != NULL)

&& predecessor Current -> rightChild != current)

predecessorofCurrent = predecessorofCurrent->rightChild;

/* Set the right child of a predecessor of current as current, and update current to the value of the leftChild of the current*/

If(predecessorofCurrent->rightChild==NULL)

*{*

predecessor Current->rightChild= current;

current= current-.leftChild;

*}*

/* Reverting the changes which are made due to the if block to restore the tree to its original state by fixing the right child of the predecessor.

Printing the result of traversal */

*else*

*{*

predecessorofCurrent->rightChild= NULL;

printf(“%d “, current->value);

current= current->rightChild;

*}*

*}*

*}*

*}*

/*To allocate a new treeNode with the given value using the function of utility or helper along with NULL leftChild and NULL rightChild pointers.

Struct treeNode* newtreeNode(int value)

*{*

Struct treeNode* node= new treeNode;

Node->value =value;

Node->leftChild =NULL;

Node->rightChild = NULL;

Return (node);

*}*

int main ()

*{*

/* The tree created

*4*

*/ \*

*2 5 *

*/ \*

*3*

**/*

Struct treeNode* root = newtreeNode(4);

Root->leftChild = newtreeNode(2);

Root->rightChild = newtreeNode(5);

Root->leftChild->leftChild = newtreeNode(1);

Root->leftChild->rightChild = newtreeNode(3);

/* Morris Traversal for the created tree */

MorrisTraversal(root);

Return 0;

*}*

**The output is as follows**

**1 2 3 4 5**

**Four advantages of using Inorder Tree Traversal with the process of Morris Traversal**

The advantages of using inorder tree traversal with the help of Morris Traversal are as follows:

*T*he process of Morris Traversal permits inorder traversal to run without using stack.- If a stack is used then the process of Morris Traversal does not allow the addition of additional space.
- The process of Morris Traversal doesn’t cost so much time and memory.
- The process of Morris Traversal allows the node to keep a track of its parents.

**Three disadvantages of using Inorder Tree Traversal with the process of Morris Traversal**

The three disadvantages of using Inorder Tree Traversal with the process of Morris Traversal are as follows:

- The process of Morris Traversal makes the inorder tree more complex.
- The process of Morris Traversal permits one traversal at a time.
- The process of Morris Traversal shows error when the values of nodes point are absent and when both the right and left children are not presented in a binary tree.

### Time complications in Morris Traversal

Some of the following points to be noted** **of time complications in the concept** **of Morris Traversal:

*The*time complication*is 0(n) when the node remains constant when it is traversed.*

*In*Morris Traversal, an edge is visited many times but it remains constant.

*The* first *visit of an edge locates a node and the* second *visit of an edge finds the node’s processor, whereas the* **third ***visit of an edge restores the predecessor of the right child to NULL.*

- In Morris Traversal
*, sometimes for every node a predecessor is found.*

**Conclusion**

This article will help you to cover your doubts about how to use inorder tree traversal without a stack. This article will give you the information to use the inorder tree traversal without stack by using the concept of Morris Traversal.You will be able to use the Inorder Tree Traversal by using the concept of Morris and by seeing some of the examples of Morris Traversal.

**Related questions to the topic**

- Name the tree traversal which does not use a stack.

**Ans: **The** **tree traversal which does not use a stack is the Morris Tree Traversal.

- In depth-first order how can you traverse a tree in different ways?

**Ans: **The different ways to traverse a tree in *depth-first order* are as follows:

*Postorder.**Inorder.**Preorder.*

- Mention the different ways to traverse a tree.

Ans: The various process to traverse a tree is as follows:

*Breadth-first.**Depth-first.*

- How inorder tree traversal is implemented without the use of recursion.

Ans: Inorder Tree Traversal is implemented with the use of Morris Traversal and a stack.