Instructor: To write the bubble sort algorithm, let's create a function that accepts an array, mutates that array for sorting and then returns that array. Bubble sort works by looping over the array as many times as necessary to get it sorted.

Each time we iterate over the array, we check if the current item is greater than the next item. If it is, we swap it in place, and we indicate that we've made a swap during this iteration.

Then if we've made a swap, we loop through the array again. We continue looping until we make a pass where no items have been swapped.

Since the way we know that an array is sorted is that no swaps occurred during it, we need to at least iterate over the array once in order to determine that it's sorted. This is a perfect situation for a do/while loop in our algorithm.

Since the condition we're going to test is whether or not a swap occurred in each iteration, we need to store a variable that holds that swap state for us. We can pass it as the condition into our while portion of our do/while loop.

The first thing we need to do in our do/block is reset the swap value. This prevents any bugs from occurring from setting swap to true in the previous iteration and forgetting to reset it.

Now we want to iterate over each item in our array, so we'll use array.foreach for that. Foreach receives a callback function. The arguments given to that callback function that we need are the item and the index of that item.

The condition that we're checking is if this item is greater than the next item, so we can use array-index-plus-one. If this condition is met, what we want to do is temporarily store our current item in a variable. We'll then set the current array index to the next item and set the next array index to our temporarily stored item.

This has swapped our two items, and thus, we can now set swap to true. That's our bubble sort algorithm in total.

I want to add something that helps us visualize what the algorithm does through each iteration, so I'm going to use the Print Array utility that I've imported into this file to display the state of the array before each comparison. Now I'm going to create an array of unsorted numbers.

We can pass that numbers array into our bubble sort function. If I log this into our terminal, we'll get to see the array as it transforms through each comparison and swap.

If we scroll all the way out, we can see how our array was sorted. Now this was happening before each comparison. The 10 quickly moved all the way to the right because it's greater than every current item.

We begin to see less drastic movements of items as the array becomes more and more sorted, all the way until we get to the end and we see what appears to be about 19 redundant passes through the array.

This happens because of the two swaps with the one in the very last iteration here, and then we go through all the rest of the iterations, the nine iterations of our array with swapped being true.

Then we need to make one more pass through the array even though we know it's sorted because we need to guarantee that nothing gets swapped.