We've been solving depth-first search problems using recursion, and we know we can also solve them using a stack. However, this is not the case for breadth-first search.

Here, since we need nodes in level-by-level order, we have to use a queue. We'll use an array as a queue in our solution.

Let's look at the algorithm:

1. We'll begin by adding the root node to the queue and initializing the result array.

2. Next, in each iteration, we are going to:

   • Dequeue a node from the queue and process it (add its value to the result array)
   • If the node has a left child, we are going to enqueue it.
   • If the node has a right child, we are going to enqueue it.

3. We'll repeat the steps above until no elements are left in the queue.

4. In the end, we'll return the result array.

Let's do a walkthrough using the example tree from the previous assignments:

Step 1: We begin with the root node in the queue.

Step 2: In the first iteration, we dequeue node 1, add its value to the result array, and then enqueue its children, first the left child 2 and then the right child 3.

Step 3: In the next iteration we dequeue node 2 and add its value to the result array. This node doesn't have any children, so we will continue.

Step 4: In the next iteration, we repeat the process. First, we dequeue the node from the queue, node 3, and add its value to the result array. Then, we enqueue its left child, node 4 to the result array. This node doesn't have a right child, so we continue.

Step 5: In this iteration, we dequeue node 4 from the queue and add its value to the result array. Then we enqueue its right child, node 5 to the queue as it doesn't have a left child.

Step 6: In the final iteration, we dequeue node 5 from the queue. Since this node has no children and the queue is empty, we are done with the iterations and can return the result.