Which Direction to Read Java Printing Out Things

How to print nodes of a binary search tree in sorted order?

Grokking the Coding Interview: Patterns for Coding Questions

Hello guys, recently one of my readers was asked about how do yous print all nodes of a binary search tree in sorted order during a telephonic Java interview. Unfortunately, he didn't know that InOrder traversal can be used to print nodes in sorted order and he asked me after the interview.

In the past, I have shared the best data construction courses and data structure interview questions, and today, I volition teach you about interesting and useful binary tree algorithms called InOrer traversal. We will also encounter an implementation using the Java programming language.

The InOrder traversal is one of the 3 popular ways to traverse a binary tree data structure, the other two beingness the preOrder and postOrder. During the in-society traversal algorithm, the left subtree is explored first, followed by root, and finally nodes on the correct subtree.

Y'all start traversal from the root then go to the left node, then again become to the left node until you reach a leaf node. At that point in fourth dimension, you impress the value of the node or marking it visited and movement to the right subtree. Standing the same algorithm until all nodes of the binary tree are visited.

The InOrder traversal is also known as the left-node-right or left-root-correct traversal or LNR traversal algorithm.

Similar to the preOrder algorithm, it is also a depth-first algorithm because information technology explores the depth of a binary tree earlier exploring siblings. Since it is one of the fundamental binary tree algorithms it's quite popular in programming interviews.

These traversal algorithms are also the basis to learn more advanced binary tree algorithms, hence every programmer should larn, empathize, and know how to implement in-order and other traversal algorithms.

The easiest way to implement the inOrder traversal algorithm in Coffee or any programming language is by using recursion. Since the binary tree is a recursive information structure, recursion is the natural choice for solving a tree-based problem. The inOrder() the method in the BinaryTree course implements the logic to traverse a binary tree using recursion.

From the Interview point of view, InOrder traversal is extremely important because it too prints nodes of a binary search tree in the sorted lodge but merely if a given tree is a binary search tree.

If y'all recall, in BST, the value of nodes in the left subtree is lower than the root, and the values of nodes on the right subtree are higher than the root. The In social club traversal literally means IN social club, I mean, nodes are printed in the social club or sorted order.

Btw, fifty-fifty though these three algorithms (pre-order, in-gild, and post-order) are pop binary tree traversal algorithms but they are not the simply ones. You too have other breadth-first means to traverse a binary tree, similar level order traversal (Run across Data Construction and Algorithms: Deep Dive).

The recursive algorithm to implement InOrder traversal of a Binary tree

The recursive algorithm of inorder traversal is very simple. You just need to telephone call the inOrder() method of BinaryTree grade in the order you desire to visit the tree. What is most of import is to include the base of operations case, which is key to any recursive algorithm.

For case, in this problem, the base case is you reach the leaf node and there is no more node to explore, at that indicate of fourth dimension recursion starts to wind downwardly. Here are the exact steps to traverse the binary tree using InOrder traversal:

1. visit left node
2. print value of the root
3. visit the right node and here is the sample code to implement this algorithm using recursion in Java:

          private void inOrder(TreeNode node) {
            if (node == null) {
            return;
            }                      inOrder(node.left);
            Arrangement.out.printf("%s ", node.data);
            inOrder(node.right);
}        

Similar to the preOrder() method in the last example, at that place is some other inOrder() method which exposes inorder traversal to the public and calls this individual method which actually performs the InOrder traversal.

This is the standard way to write a recursive method which takes input, it makes it easier for a customer to call the method.

          public void inOrder() {
            inOrder(root);
}        

You can run across that we start with root and then recursive call the inOrder() method with node.left, which ways nosotros are going downwards on left subtree until we hitting node == nix, which ways the last node was a leaf node.

At this indicate in time, the inOrder() method will return and execute the next line, which prints the node.information. After that it's again a recursive inOrder() phone call with node.right, which will initiate the aforementioned procedure again.

You lot can also check out Data Structure and Algorithms Part one and 2 courses on Pluralsight to learn more about algorithms and how to design your own algorithms.

Btw, y'all would demand a Pluralsight membership to access this course, which costs effectually $29 monthly or $299 annually (fourteen% saving). I have one and I also suggest all developers have that plan because Pluralsight is like NetFlix for Software developers.

It has more than 5000+ good quality courses on all the latest topics. Since we programmers accept to learn new things every day, an investment of $299 USD is bang-up.

Btw, information technology also offers a 10-day free trial without any obligation which allows you lot to watch 200 hours of content. Y'all tin sentinel these courses for gratuitous by signing upward for that 10-twenty-four hours free trial.

Inorder traversal of a Binary tree in Coffee

Here is our complete solution to the inorder traversal algorithm in Java. This plan uses a recursive algorithm to impress the value of all nodes of a binary tree using InOrder traversal.

As I have told you before, during the in-guild traversal value of the left subtree is printed starting time, followed by the root and right subtree. If you lot are interested in the iterative algorithm, you can farther bank check this tutorial of implementing in order traversal without recursion.

          import java.util.Stack;          /*
            * Java Program to traverse a binary search tree
            * using inorder traversal without recursion            
            * and impress all nodes in sorted social club
            * In InOrder traversal first left node is visited, followed by root
            * and right node.
            *
            * input:
            *      40
            *     /\
            *    xx   50
            *   / \    \
            *  10  30   threescore
            * /   /  \
            * 5  67  78
            *
            * output: 5 x 20 xxx 40 50 sixty 67 78
            */          public class Main {                      public static void main(Cord[] args) throws Exception {                      // construct the binary tree given in question
            BinaryTree bt = BinaryTree.create();                      // traversing binary tree using InOrder traversal using recursion
            System.out
            .println("press nodes of binary tree on InOrder using recursion");                      bt.inOrder();
            }          }          form BinaryTree {
            static class TreeNode {
            Cord data;
            TreeNode left, right;                      TreeNode(String value) {
            this.data = value;
            left = right = null;
            }                      }                      // root of binary tree
            TreeNode root;                      /**
            * traverse the binary tree on InOrder traversal algorithm
            */
            public void inOrder() {
            inOrder(root);
            }                      private void inOrder(TreeNode node) {
            if (node == goose egg) {
            render;
            }                      inOrder(node.left);
            System.out.printf("%s ", node.data);
            inOrder(node.right);
            }                      /**
            * Java method to create binary tree with test information
            *
            * @return a sample binary tree for testing
            */
            public static BinaryTree create() {
            BinaryTree tree = new BinaryTree();
            TreeNode root = new TreeNode("40");
            tree.root = root;
            tree.root.left = new TreeNode("twenty");
            tree.root.left.left = new TreeNode("10");
            tree.root.left.left.left = new TreeNode("five");                      tree.root.left.correct = new TreeNode("30");
            tree.root.correct = new TreeNode("fifty");
            tree.root.right.right = new TreeNode("lx");
            tree.root.left.right.left = new TreeNode("67");
            tree.root.left.right.correct = new TreeNode("78");                      return tree;
            }          }        

Output
press nodes of the binary tree on InOrder using recursion
v 10 20 xxx 67 78 40 50 60

That's all most how to implement inOrder traversal of a binary tree in Java using recursion. You lot can see the code is pretty much similar to the preOrder traversal with the only departure in the society we recursive phone call the method. In this case, nosotros phone call inOrder(node.left) first and then print the value of the node.

It's worth remembering that in order traversal is a depth-kickoff algorithm and prints tree node in sorted lodge if the given binary tree is a binary search tree.

In the next part of this article, I'll share inOrder traversal without recursion, meanwhile, y'all can effort practicing following data construction and binary tree bug.

Further Learning
Information Structures and Algorithms: Deep Dive Using Coffee
Algorithms and Data Structures — Part 1 and 2
Data Structures in Java 9 past Heinz Kabutz
Cracking the Coding Interview — 189 Questions and Solutions
100+ Data Structure and Algorithms Questions for Programmers
75+ Programming and Coding Interview Questions
Grokking the Coding Interview: Patterns for Coding Questions
Grokking Dynamic Programming Patterns for Coding Interviews

Other data structure and algorithms tutorials for Java Programmers

• ten Algorithm books Every Programmer Should Read (list)
• How to implement the Quicksort algorithm in Java? (solution)
• 5 Books to learn data structure and algorithms in Java? (books)
• How to implement a binary search algorithm in Java? (solution)
• How to find all pairs on an integer assortment whose sum is equal to given a number? (solution)
• How to opposite an array in identify in Java? (solution)
• How to reverse a linked list in Coffee without recursion? (solution)
• How to implement Insertion sort in Java? (solution)
• How to find the missing number in an array of i to 100? (solution)
• How to observe the length of a singly linked listing in Java? (solution)
• 15 frequently asked information structure and Algorithm Interview Questions (list)

If yous have any suggestions to make this algorithm better, feel free to suggest. The interviewer loves people who come up with their ain algorithms or give some touch to popular algorithms.

P.S. — If you lot don't mind learning from gratuitous resources then y'all tin as well take a look at my list of gratis information structure and algorithm courses for Java developers.

crosswhitepronow1963.blogspot.com

Source: https://medium.com/javarevisited/how-to-print-nodes-of-a-binary-search-tree-in-sorted-order-8a4e52eb8856

Share this post