# Java implementation of binary tree's pre order, middle order, post order, sequence traversal (non recursive method)

## in this implementation of Java, non recursive implementation of binary tree traversal of the front order, middle order, back order, sequence, in non recursive implementation, with the help of stack to help achieve traversal. The former sequence is similar to the middle sequence, but the latter sequence traversal needs two stacks for assistance, which is a little more complex. The sequence traversal is realized by using a queue.

It's the same binary tree

• Preorder traversal: 12 1 3 6 5 7 8 10

• Middle order traversal: 1 2 3 4 5 6 7 8 10

• Subsequent traversal: 1 3 2 5 10 8 7 6 4

• Sequence traversal: 4 2 6 1 3 5 7 8 10

```import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class Tree<AnyType extends Comparable<? super AnyType>>
{
private static class BinaryNode<AnyType>
{
BinaryNode(AnyType theElement)
{
this(theElement, null, null);
}

BinaryNode(AnyType theElement, BinaryNode<AnyType> lt, BinaryNode<AnyType> rt)
{
element = theElement;
left = lt;
right = rt;
}

AnyType element;
BinaryNode<AnyType> left;
BinaryNode<AnyType> right;
}

private BinaryNode<AnyType> root;

public void insert(AnyType x)
{
root = insert(x, root);
}

public boolean isEmpty()
{
return root == null;
}

private BinaryNode<AnyType> insert(AnyType x, BinaryNode<AnyType> t)
{
if(t == null)
{
return new BinaryNode<>(x, null, null);
}

int compareResult = x.compareTo(t.element);

if(compareResult < 0)
{
t.left = insert(x, t.left);
}
else if(compareResult > 0)
{
t.right = insert(x, t.right);
}
else
{
;
}

return t;
}

/**
* Preorder traversal
* recursion
*/
public void preOrder(BinaryNode<AnyType> Node)
{
if (Node != null)
{
System.out.print(Node.element + " ");
preOrder(Node.left);
preOrder(Node.right);
}
}

/**
* Sequential traversal
* recursion
*/
public void midOrder(BinaryNode<AnyType> Node)
{
if (Node != null)
{
midOrder(Node.left);
System.out.print(Node.element + " ");
midOrder(Node.right);
}
}

/**
* Post order traversal
* recursion
*/
public void posOrder(BinaryNode<AnyType> Node)
{
if (Node != null)
{
posOrder(Node.left);
posOrder(Node.right);
System.out.print(Node.element + " ");
}
}

/*
* level traversal
* recursion
*/
public void levelOrder(BinaryNode<AnyType> Node) {
if (Node == null) {
return;
}

int depth = depth(Node);

for (int i = 1; i <= depth; i++) {
levelOrder(Node, i);
}
}

private void levelOrder(BinaryNode<AnyType> Node, int level) {
if (Node == null || level < 1) {
return;
}

if (level == 1) {
System.out.print(Node.element + "  ");
return;
}

// Left tree
levelOrder(Node.left, level - 1);

// Right subtree
levelOrder(Node.right, level - 1);
}

public int depth(BinaryNode<AnyType> Node) {
if (Node == null) {
return 0;
}

int l = depth(Node.left);
int r = depth(Node.right);
if (l > r) {
return l + 1;
} else {
return r + 1;
}
}

/**
* Preorder traversal
* non-recursive
*/
public void preOrder1(BinaryNode<AnyType> Node)
{
Stack<BinaryNode> stack = new Stack<>();
while(Node != null || !stack.empty())
{
while(Node != null)
{
System.out.print(Node.element + "   ");
stack.push(Node);
Node = Node.left;
}
if(!stack.empty())
{
Node = stack.pop();
Node = Node.right;
}
}
}

/**
* Sequential traversal
* non-recursive
*/
public void midOrder1(BinaryNode<AnyType> Node)
{
Stack<BinaryNode> stack = new Stack<>();
while(Node != null || !stack.empty())
{
while (Node != null)
{
stack.push(Node);
Node = Node.left;
}
if(!stack.empty())
{
Node = stack.pop();
System.out.print(Node.element + "   ");
Node = Node.right;
}
}
}

/**
* Post order traversal
* non-recursive
*/
public void posOrder1(BinaryNode<AnyType> Node)
{
Stack<BinaryNode> stack1 = new Stack<>();
Stack<Integer> stack2 = new Stack<>();
int i = 1;
while(Node != null || !stack1.empty())
{
while (Node != null)
{
stack1.push(Node);
stack2.push(0);
Node = Node.left;
}

while(!stack1.empty() && stack2.peek() == i)
{
stack2.pop();
System.out.print(stack1.pop().element + "   ");
}

if(!stack1.empty())
{
stack2.pop();
stack2.push(1);
Node = stack1.peek();
Node = Node.right;
}
}
}

/*
* level traversal
* non-recursive
*/
public void levelOrder1(BinaryNode<AnyType> Node) {
if (Node == null) {
return;
}

BinaryNode<AnyType> binaryNode;

while (queue.size() != 0) {
binaryNode = queue.poll();

System.out.print(binaryNode.element + "  ");

if (binaryNode.left != null) {
queue.offer(binaryNode.left);
}
if (binaryNode.right != null) {
queue.offer(binaryNode.right);
}
}
}

public static void main( String[] args )
{
int[] input = {4, 2, 6, 1, 3, 5, 7, 8, 10};
Tree<Integer> tree = new Tree<>();
for(int i = 0; i < input.length; i++)
{
tree.insert(input[i]);
}
System.out.print("Recursive preamble traversal:");
tree.preOrder(tree.root);
System.out.print("\nNon recursive preamble traversal:");
tree.preOrder1(tree.root);
System.out.print("\nRecursive middle order traversal:");
tree.midOrder(tree.root);
System.out.print("\nNon recursive middle order traversal:");
tree.midOrder1(tree.root);
System.out.print("\nRecursive postorder traversal:");
tree.posOrder(tree.root);
System.out.print("\nNon recursive postorder traversal:");
tree.posOrder1(tree.root);
System.out.print("\nRecursive sequence traversal:");
tree.levelOrder(tree.root);
System.out.print("\nNon recursive sequence traversal:");
tree.levelOrder1(tree.root);
}
}```
``````In the above code, preOrder1,midOrder1,posOrder1,levelOrder1 The four functions represent the traversal of binary tree's pre order, middle order, post order and sequence.
``````
``` ```
` `
``` ```
``` Tags: Java Posted on Wed, 18 Mar 2020 12:38:56 -0400 by dzm ```
``` ```
``` ©2020 Programmer Help var html = '<a href="' + '/contact-us/' + '">'; html += 'Contact Us' + '</a>'; document.write(html) var _hmt = _hmt || []; (function() { var hm = document.createElement("script"); hm.src = "https://hm.baidu.com/hm.js?9a0ffc6fe7a6b5d3ef8b1ad8c659f59a"; var s = document.getElementsByTagName("script")[0]; s.parentNode.insertBefore(hm, s); })(); window.dataLayer = window.dataLayer || []; function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-136936861-1'); ```