Morris traversal for Preorder

Using Morris Traversal, we can traverse the tree without using stack and recursion. The algorithm for Preorder is almost similar to Morris traversal for Inorder.

1...If left child is null, print the current node data. Move to right child.
….Else, Make the right child of the inorder predecessor point to the current node. Two cases arise:
………a) The right child of the inorder predecessor already points to the current node. Set right child to NULL. Move to right child of current node.
………b) The right child is NULL. Set it to current node. Print current node’s data and move to left child of current node.
2...Iterate until current node is not NULL.

Following is the implementation of the above algorithm.

C++

 // C++ program for Morris Preorder traversal  #include using namespace std;     class node  {      public:     int data;      node *left, *right;  };     /* Helper function that allocates a new node with the  given data and NULL left and right pointers. */ node* newNode(int data)  {      node* temp = new node();     temp->data = data;      temp->left = temp->right = NULL;      return temp;  }     // Preorder traversal without recursion and without stack  void morrisTraversalPreorder(node* root)  {      while (root)      {          // If left child is null, print the current node data. Move to          // right child.          if (root->left == NULL)          {              cout<data<<" ";              root = root->right;          }          else         {              // Find inorder predecessor              node* current = root->left;              while (current->right && current->right != root)                  current = current->right;                 // If the right child of inorder predecessor already points to              // this node              if (current->right == root)              {                  current->right = NULL;                  root = root->right;              }                 // If right child doesn't point to this node, then print this              // node and make right child point to this node              else             {                  cout<data<<" ";                  current->right = root;                  root = root->left;              }          }      }  }     // Function for sStandard preorder traversal  void preorder(node* root)  {      if (root)      {          cout<data<<" ";          preorder(root->left);          preorder(root->right);      }  }     /* Driver program to test above functions*/ int main()  {      node* root = NULL;         root = newNode(1);      root->left = newNode(2);      root->right = newNode(3);         root->left->left = newNode(4);      root->left->right = newNode(5);         root->right->left = newNode(6);      root->right->right = newNode(7);         root->left->left->left = newNode(8);      root->left->left->right = newNode(9);         root->left->right->left = newNode(10);      root->left->right->right = newNode(11);         morrisTraversalPreorder(root);         cout<

C

 // C program for Morris Preorder traversal #include #include    struct node {     int data;     struct node *left, *right; };    /* Helper function that allocates a new node with the    given data and NULL left and right pointers. */ struct node* newNode(int data) {     struct node* temp = (struct node*) malloc(sizeof(struct node));     temp->data = data;     temp->left = temp->right = NULL;     return temp; }    // Preorder traversal without recursion and without stack void morrisTraversalPreorder(struct node* root) {     while (root)     {         // If left child is null, print the current node data. Move to         // right child.         if (root->left == NULL)         {             printf( "%d ", root->data );             root = root->right;         }         else         {             // Find inorder predecessor             struct node* current = root->left;             while (current->right && current->right != root)                 current = current->right;                // If the right child of inorder predecessor already points to             // this node             if (current->right == root)             {                 current->right = NULL;                 root = root->right;             }                // If right child doesn't point to this node, then print this             // node and make right child point to this node             else             {                 printf("%d ", root->data);                 current->right = root;                 root = root->left;             }         }     } }    // Function for sStandard preorder traversal void preorder(struct node* root) {     if (root)     {         printf( "%d ", root->data);         preorder(root->left);         preorder(root->right);     } }    /* Driver program to test above functions*/ int main() {     struct node* root = NULL;        root = newNode(1);     root->left = newNode(2);     root->right = newNode(3);        root->left->left = newNode(4);     root->left->right = newNode(5);        root->right->left = newNode(6);     root->right->right = newNode(7);        root->left->left->left = newNode(8);     root->left->left->right = newNode(9);        root->left->right->left = newNode(10);     root->left->right->right = newNode(11);        morrisTraversalPreorder(root);        printf("\n");     preorder(root);        return 0; }

Java

 // Java program to implement Morris preorder traversal    // A binary tree node class Node {            int data;     Node left, right;            Node(int item) {         data = item;         left = right = null;     } }    class BinaryTree {            Node root;            void morrisTraversalPreorder()     {         morrisTraversalPreorder(root);     }        // Preorder traversal without recursion and without stack     void morrisTraversalPreorder(Node node) {         while (node != null) {                // If left child is null, print the current node data. Move to             // right child.             if (node.left == null) {                 System.out.print(node.data + " ");                 node = node.right;             } else {                    // Find inorder predecessor                 Node current = node.left;                 while (current.right != null && current.right != node) {                     current = current.right;                 }                    // If the right child of inorder predecessor                  // already points to this node                 if (current.right == node) {                     current.right = null;                     node = node.right;                 }                     // If right child doesn't point to this node, then print                 // this node and make right child point to this node                 else {                     System.out.print(node.data + " ");                     current.right = node;                     node = node.left;                 }             }         }     }            void preorder()     {         preorder(root);     }        // Function for Standard preorder traversal     void preorder(Node node) {         if (node != null) {             System.out.print(node.data + " ");             preorder(node.left);             preorder(node.right);         }     }            // Driver programs to test above functions     public static void main(String args[]) {         BinaryTree tree = new BinaryTree();         tree.root = new Node(1);         tree.root.left = new Node(2);         tree.root.right = new Node(3);         tree.root.left.left = new Node(4);         tree.root.left.right = new Node(5);         tree.root.right.left = new Node(6);         tree.root.right.right = new Node(7);         tree.root.left.left.left = new Node(8);         tree.root.left.left.right = new Node(9);         tree.root.left.right.left = new Node(10);         tree.root.left.right.right = new Node(11);         tree.morrisTraversalPreorder();         System.out.println("");         tree.preorder();                } }    // this code has been contributed by Mayank Jaiswal

Python3

 # Python program for Morris Preorder traversal    # A binary tree Node class Node:     def __init__(self, data):         self.data = data         self.left = None         self.right = None    # Preorder traversal without  # recursion and without stack def MorrisTraversal(root):     curr = root        while curr:         # If left child is null, print the         # current node data. And, update          # the current pointer to right child.         if curr.left is None:             print(curr.data, end= " ")             curr = curr.right            else:             # Find the inorder predecessor             prev = curr.left                while prev.right is not None and prev.right is not curr:                 prev = prev.right                # If the right child of inorder             # predecessor already points to             # the current node, update the              # current with it's right child             if prev.right is curr:                 prev.right = None                 curr = curr.right                                # else If right child doesn't point             # to the current node, then print this             # node's data and update the right child             # pointer with the current node and update             # the current with it's left child             else:                 print (curr.data, end=" ")                 prev.right = curr                  curr = curr.left    # Function for sStandard preorder traversal def preorfer(root):     if root :         print(root.data, end = " ")         preorfer(root.left)         preorfer(root.right)               # Driver program to test  root = Node(1) root.left = Node(2) root.right = Node(3)    root.left.left = Node(4) root.left.right = Node(5)    root.right.left= Node(6) root.right.right = Node(7)    root.left.left.left = Node(8) root.left.left.right = Node(9)    root.left.right.left = Node(10) root.left.right.right = Node(11)       MorrisTraversal(root) print("\n") preorfer(root)       # This code is contributed by 'Aartee'

C#

 // C# program to implement Morris // preorder traversal  using System;    // A binary tree node  public class Node {     public int data;     public Node left, right;        public Node(int item)     {         data = item;         left = right = null;     } }    class GFG { public Node root;    public virtual void morrisTraversalPreorder() {     morrisTraversalPreorder(root); }    // Preorder traversal without  // recursion and without stack  public virtual void morrisTraversalPreorder(Node node) {     while (node != null)     {            // If left child is null, print the          // current node data. Move to right child.          if (node.left == null)         {             Console.Write(node.data + " ");             node = node.right;         }         else         {                // Find inorder predecessor              Node current = node.left;             while (current.right != null &&                     current.right != node)             {                 current = current.right;             }                // If the right child of inorder predecessor              // already points to this node              if (current.right == node)             {                 current.right = null;                 node = node.right;             }                // If right child doesn't point to              // this node, then print this node              // and make right child point to this node              else             {                 Console.Write(node.data + " ");                 current.right = node;                 node = node.left;             }         }     } }    public virtual void preorder() {     preorder(root); }    // Function for Standard preorder traversal  public virtual void preorder(Node node) {     if (node != null)     {         Console.Write(node.data + " ");         preorder(node.left);         preorder(node.right);     } }    // Driver Code public static void Main(string[] args) {     GFG tree = new GFG();     tree.root = new Node(1);     tree.root.left = new Node(2);     tree.root.right = new Node(3);     tree.root.left.left = new Node(4);     tree.root.left.right = new Node(5);     tree.root.right.left = new Node(6);     tree.root.right.right = new Node(7);     tree.root.left.left.left = new Node(8);     tree.root.left.left.right = new Node(9);     tree.root.left.right.left = new Node(10);     tree.root.left.right.right = new Node(11);     tree.morrisTraversalPreorder();     Console.WriteLine("");     tree.preorder(); } }    // This code is contributed by Shrikant13

Output:

1 2 4 8 9 5 10 11 3 6 7
1 2 4 8 9 5 10 11 3 6 7

Limitations:
Morris traversal modifies the tree during the process. It establishes the right links while moving down the tree and resets the right links while moving up the tree. So the algorithm cannot be applied if write operations are not allowed.

My Personal Notes arrow_drop_up

Improved By : shrikanth13, rathbhupendra

Article Tags :
Practice Tags :

4

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.