Populate inorder successor for all nodes
I think this equivalent, but simpler. It removes the need for the TreeNodeHolder class by returning a TreeNode&lt;T&gt;.

public void populateInorderSuccessor() {
  populate(root, null);
}

private TreeNode&lt;T&gt; populate(TreeNode&lt;T&gt; root, TreeNode&lt;T&gt; successor) {
  if (root == null) {
    return successor;
  }

  root.next = populate(root.right, successor);
  return populate(root.left, root);
}




PopulateInorderSuccessor is not a good name for a class. Let's change it to BinaryTree.



Tree construction can be simplified:

public BinaryTree(T[] items) {
  this.root = create(items, 0);
}

private TreeNode&lt;T&gt; create(T[] items, int i) {
  if (i &gt;= items.length || items[i] == null) {
    return null;
  }

  TreeNode&lt;T&gt; root = new TreeNode&lt;T&gt;(items[i]);
  root.left = create(items, 2 * i + 1);
  root.right = create(items, 2 * i + 2);
  return root;
}




I find that helper methods setLeft and setRight on TreeNode can make tree code a bit cleaner, in general. It's not of much advantage here, but just for reference:

public TreeNode&lt;T&gt; setLeft(TreeNode&lt;T&gt; left) {
  this.left = left;
  return this;
}

public TreeNode&lt;T&gt; setRight(TreeNode&lt;T&gt; right) {
  this.right = right;
  return this;
}


This way we can write

private TreeNode&lt;T&gt; create(T[] items, int i) {
  if (i &gt;= items.length || items[i] == null) {
    return null;
  }

  return new TreeNode&lt;T&gt;(items[i])
    .setLeft(create(items, 2 * i + 1))
    .setRight(create(items, 2 * i + 2));
}




Putting it all together, we get something like this

import java.util.ArrayList;
import java.util.List;

public class BinaryTree&lt;T&gt; {
  private TreeNode&lt;T&gt; root;

  public BinaryTree(T[] items) {
    this.root = create(items, 0);
  }

  private TreeNode&lt;T&gt; create(T[] items, int i) {
    if (i &gt;= items.length || items[i] == null) {
      return null;
    }

    return new TreeNode&lt;T&gt;(items[i])
      .setLeft(create(items, 2 * i + 1))
      .setRight(create(items, 2 * i + 2));
  }

  public void populateInorderSuccessor() {
    populate(root, null);
  }

  private TreeNode&lt;T&gt; populate(TreeNode&lt;T&gt; root, TreeNode&lt;T&gt; successor) {
    if (root == null) {
      return successor;
    }

    root.next = populate(root.right, successor);
    return populate(root.left, root);
  }

  public List&lt;T&gt; toInOrderList() {
    TreeNode&lt;T&gt; node = root;
    while (node.left != null) {
      node = node.left;
    }

    final List&lt;T&gt; list = new ArrayList&lt;&gt;();
    while (node != null) {
      list.add(node.item);
      node = node.next;
    }
    return list;
  }

  private static class TreeNode&lt;T&gt; {
    private TreeNode&lt;T&gt; left;
    private T item;
    private TreeNode&lt;T&gt; right;
    private TreeNode&lt;T&gt; next;

    TreeNode(T item) {
      this.item = item;
    }

    public TreeNode&lt;T&gt; setLeft(TreeNode&lt;T&gt; left) {
      this.left = left;
      return this;
    }

    public TreeNode&lt;T&gt; setRight(TreeNode&lt;T&gt; right) {
      this.right = right;
      return this;
    }
  }
}