Traverse a binary there so that the order returned is ordered from smallest to greatest.

BinaryTreeReturnOrdered.java

public class TreeNode{
 public int data;
 public TreeNode left;
 public TreeNode right;
 public TreeNode(int d){
  this.data = d;
  this.left = null;
  this.right = null;
 }
}

public class BinarySearchTree{
 public root;
 public BinarySearchTree(){
  root = null;
 }
 
 public boolean addNode(int d){
  if (root == null){
   root = new TreeNode(d);
   return true;
  }
  else if (root.data == d){
   return false;
  }
  else{
   return addNodeHelper(root, d);
  }
 }
 
 private boolean addNodeHelper(TreeNode node, int d){
  if (d == node.data){
   return false;
  }
  else if (d < node.data){
   if (node.left == null){
    node.left = new TreeNode(d);
    return true;
   }
   else{
    return addNodeHelper(node.left, d);
   }
   else{
    if (node.right == null){
     node.right = new TreeNode(d);
     return true;
    }
    else{
     return addNodeHelper(node.right, d);
    }
   }
  }
 }
 
 public TreeNode find(int d){
  TreeNode curr = root;
  while (curr != null){
   if (curr.data == d){
    return curr;
   }
   else if (d < curr.data){
    curr = curr.left;
   }
   else{
    curr = curr.right;
   }
  }
  return null;
 }

 public Integer[] getInOrderValues(){
  if (root == null){
      return null;
  }
  ArrayList<Integer> arrayInOrder= new ArrayList<Integer>();
  getInOrderValuesHelper(root, arrayInOrder)
  
  return arrayInOrder.toArray();
 }
 
 private void getInOrderValuesHelper(TreeNode node, ArrayList<Integer> arrayInOrder){
  if (node == null){
   return;
  }
  getInOrderValuesHelper(node.left, arrayList);
  arrayInOrder.add(node.data);
  getInOrderValuesHelper(node.right, arrayList);
 }
 
}
    
public class BinaryTree{
 public TreeNode root;
 public BinaryTree(){
  this.root = null;
 }
 
 
    
 public Integer[] getElementsInOrder(){
   
   Queue<TreeNode> treeQueue = new LinkedList<TreeNode>();
   BinarySearchTree newTree = new BinarySearchTree();
   if (root == null){
    return;
   }
   //Start Breadth first traversal of tree
   treeQueue.clear();
   treeQueue.add(root);
   while (!(treeQueue.size() == 0)){
    TreeNode node = treeQueue.remove();
    newTree.addNode(node.data);
    if (node.left != null){
     treeQueue.add(node.left);
    }
    if (node.right != null){
     treeQueue.add(node.right);
    }
   }
   
   //we now have a BST, return result of getInOrderValues
   return newTree.getInOrderValues();
 }
}