The bubble sort algorithm is not the most efficient sorting algorithm when it comes to time complexity. But it is still often used as a starting point for learning and understanding the basic principles of sorting algorithms.

In this article, you will explore the most commonly asked questions about the bubble sort algorithm, including its time and space complexity, best-case and worst-case runtime, implementation in JavaScript, and more.

What is Bubble Sort Algorithm?

Bubble sorting is a way of sorting a list of things, like numbers or words, into a specific order. It works by looking at pairs of adjacent items in the list and swapping them if they are in the wrong order.

For example, if you have a list of [3, 1, 4, 2], bubble sort would compare 3 and 1, seeing that they are in the wrong order, it swaps them to get [1, 3, 4, 2]. It then compares 3 and 4, seeing that they are in the correct order, it moves on to the next pair.

Bubble sort continues to compare adjacent pairs and swap them if necessary until the list is completely sorted. As the algorithm progresses, smaller items "bubble" to the top of the list. This is why it's called bubble sort.

While bubble sort is a simple and easy-to-understand algorithm, it's not the most efficient. In fact, it has a worst-case time complexity of O(n^2), which means that it's not a good choice for sorting very large lists.

But it's still useful for teaching and learning about sorting algorithms and their basic principles.

Implementation of Bubble Sort Algorithm With JavaScript

Here's an example implementation of the bubble sort algorithm in JavaScript:

const bubbleSort = (arr) => {
  let swapped;

  do {
    swapped = false;
    for (let i = 0; i < arr.length - 1; i++) {
      if (arr[i] > arr[i + 1]) {
        [myArray[i], myArray[i + 1]] = [myArray[i + 1], myArray[i]];
        swapped = true;
      }
    }
  } while (swapped);

  return arr;
};

let myArray = [12, 10, 3, 7, 4];
console.log(bubbleSort(myArray)); // returns [3, 4, 7, 10, 12]

In this implementation, you define a function that takes an array as its input. The function uses two nested loops to iterate over the array and compares adjacent elements.

You can read more on how to write the bubble sort algorithm in this detailed article.

Most Asked Questions About Bubble Sort Algorithm

Let’s now explore some of the most common questions you would ask about the bubble sort algorithm to give you clarity.

1. What is the best-case runtime complexity of standard bubble sort?

The best-case runtime complexity of standard bubble sort is O(n) when the input array is already sorted, and no element swap is needed.

let myArray = [3, 4, 7, 10, 12];
console.log(bubbleSort(myArray)); // returns [3, 4, 7, 10, 12]

2. What is the time and space complexity of bubble sort?

The time complexity of bubble sort is O(n^2), where n is the number of elements in the array. The space complexity of bubble sort is O(1) because it uses only a constant amount of extra memory.

3. What type of algorithm is bubble sort?

Bubble sort is a simple sorting algorithm that repeatedly loops through a list, compares adjacent elements, and swaps them if they are in the wrong order.

4. What is the best-case time complexity of bubble sort?

The best-case time complexity of bubble sort is O(n), where n is the number of elements in the array. This occurs when the input array is already sorted, and no element swap is needed.

5. What is the average case complexity of bubble sort?

The average case complexity of bubble sort is O(n^2), where n is the number of elements in the array. This occurs when the input array is unsorted, and multiple elements have to be swapped.

6. What is the worst time complexity of bubble sort?

The worst time complexity of bubble sort is O(n^2), where n is the number of elements in the array. This occurs when the input array is reverse sorted, and every element has to be swapped.

Wrapping Up

In this article, we've covered several frequently asked questions about bubble sort, including its time and space complexity, best and worst-case runtime, and how to implement it in JavaScript.

Hopefully, this article has given you a better understanding of bubble sort and its limitations. Remember that while bubble sort is a good starting point for learning about sorting algorithms, more efficient algorithms are available for sorting larger datasets.

Have fun coding!

You can access over 200 of my articles by visiting my website. You can also use the search field to see if I've written a specific article.

Twaikura, haikus but funnier

As easy as ABC: some stranger on the Internet starts a 120 characters story, some stranger on the Internet finishes it. And that makes a Twaiku (tweet + haiku). Twaikus can be funny, serious, artistic, it’s up to you.

So, as a developer, implementing something like that shouldn't be hard, right? Yes, but no. Here is the story of how it took me multiple years to create Twaikura and how you could do the same in a matter of hours.

Back to TwentyParts and why it never came to existence

TwentyParts was my first “entrepreneurial concept” back in 2015. As you may guess, the idea is to write a story in 20 parts, with each part written by a different author.

I was a CS student at the time and it took me 2 months to release a first draft. The result was disastrous. I didn’t even know about the concept of a “framework”, picture the code. The concept was too complex, the interface unusable.

I did not give up. A few months later, in 2016, I came up with a simplified version of TwentyParts, HiKoo. I limited the length of a story to 3 tweets. And instead of rushing to development, I created mocks using a marvelous tool named MarvelApp.

Now I had a great UI and all, but no working code. One more app that never came to existence.

Looks good, doesn't work

Fast forward to now. I’ve graduated. I’ve built my consulting company, LBKE. I’ve developed complex SaaS platforms for multiple clients. And I've kept this question running in my head:

What prevents me from recreating TwentyParts, now I am fast and skilled and over-confident?

After all, it would only take a full work week nowadays. Yet there’s a problem: I am not a student anymore. With one spare hour here and there, a “full work week“ can span over a few months. Too slow.

How to code fast: don’t.

I’ve explored thoroughly the realms of fast web development. You may have read my previous articles on freeCodeCamp about Vulcan, a framework based on Meteor that makes me very productive.

Those researches all lead me to the same conclusion: the best code is the code you don’t write.

There are a lot of ways NOT to write code, even for a developer. Scaffolding, declarative programming, using snippets, or using an ORM are all methods to circumvent writing code. Using open source is another great example. Some may even think that developers are a bit lazy – but aren't they?

Yet minimal skills in web development are still necessary. That means careful thinking, lots of doc reading, debugging and so on. In the end, the time needed to create a fully functional app can only be reduced this much.

You know what? Using a massive framework to speed up developments feels like cheating sometimes. What if I did not have those skills? What if I was not a developer? I would have no other choice than embracing the “no-code way”. And that’s what I’ve done.

Relax, Code will be on vacation for the remainder of this article

Sparkling innovations for web non-developers

No-code solutions have been pretty bad in the past. Limited, difficult to extend, proprietary, expensive, the list is long. But some recent tools are starting to be worthy enough.

I will focus specifically on Bubble. Its plugin system coupled with its data management features makes it the most complete solution on the market currently. Here are a few key features and how I used them to build Twaikura.

The UI editor

Bubble proposes a WYSIWYG editor (What You See Is What You Get) to create the app user interface. You put your blocks of content wherever you want, and configure their content.

It’s grid-based so you can have pixel perfect alignment. It handles responsiveness. So you should be able to create designs as complex as you wish.

Building Twaikura's interface using the WYSIWYG editor.

But I’ll be honest, I am not the hugest fan. More precisely, I am not very good with it. It’s very different both from writing HTML/CSS and from using web-based design tools like Figma, so there is a learning curve.

I ended up sticking myself to an old school Windows 98-ish style. With a little bit of imagination you could even believe it has some “V a p o r w a v e” aesthetic.

Thinking in workflows

The most impressive feature of Bubble to me is its “Workflows”. It lets you describe complex process in a visual language. It can mix data management (validating and storing a Twaiku, sending an email) and user experience (resetting a form, refreshing the page) transparently. You don’t need to mentally split the workflow between frontend and backend as you would do in a traditional web app.

Twaiku creation workflow

This example workflow is triggered when the user wants to submit the second part of a Twaiku. It will create a "Twaiku End" in the database, link it with a "Twaiku Begin", and reset the form. I could also display a success message, send a mail to a moderator and so on. Visualizing the full workflow in a single timeline is very intuitive.

Complete data management

Bubbles comes with a relational database and complete filtering features. That means you can easily create both forms and list of data. For example, the “Read latest Twaikus” block will load all valid Twaikus.

Plugins can help secure your content. For example, there is a ReCaptcha plugin to add CAPTCHAs to your form in a matter of minutes. This is important as security is usually left behind in the prototyping steps. Malevolent bots and hackers don't care that you are a "lean startup-er", and they won't miss an opportunity to spam or hack your website.

A few hours of work for an app that works

I won’t describe all features of Bubble, because it has a lot more. The conclusion is that it's been powerful enough to write an app like Twaikura. Instead of writing tons of crappy code that will end up in a dumpster, instead of creating a visual prototype as lively as Frankenstein’s Creature, I just created something that works.

Is my website great? Honestly, not yet. Does it do the job? Hell yes. I had fun creating it, it cost me no more than a few hours, and I am able to test the concept in the most direct possible way. The longest part was writing this article.

I especially recommend no-code tools for people who want to learn web development. Taking a lot of time to produce simple features can feel frustrating at first. Using a no-code tool alongside traditional programming is a way to keep having fun. It's instructive too, because, even if you don't write code, you still have to think like a developer: designing conditional workflows, structuring a database, validating forms... That's a win-win.

I won't become a no-code evangelist, but Bubble is a great addition to my tool belt. And it could be great addition to yours too!

Thanks for the read. If you liked this article, come try a Bubble app by creating your first Twaiku on twaikura.com!

With a worst-case complexity of O(n^2), bubble sort is very slow compared to other sorting algorithms like quicksort. The upside is that it is one of the easiest sorting algorithms to understand and code from scratch.

Example:

let arr = [4, 2, 6, 3, 9];
let sorted = false

while(!sorted) {
  sorted = true
  for(var i = 0; i < arr.length; i++) {
    if(arr[i] < arr[i - 1]) {
      let temp = arr[i];
      arr[i] = arr[i - 1];
      arr[i - 1] = temp;
      sorted = false;
    }
  }
}

First pass through the list:

• Starting with [4, 2, 6, 3, 9], the algorithm compares the first two elements in the array, 4 and 2. It swaps them because 2 < 4: [2, 4, 6, 3, 9]
• It compares the next two values, 4 and 6. As 4 < 6, these are already in order, and the algorithm moves on: [2, 4, 6, 3, 9]
• The next two values are also swapped because 3 < 6: [2, 4, 3, 6, 9]
• The last two values, 6 and 9, are already in order, so the algorithm does not swap them.

Second pass through the list:

• 2 < 4, so there is no need to swap positions: [2, 4, 3, 6, 9]
• The algorithm swaps the next two values because 3 < 4: [2, 3, 4, 6, 9]
• No swap as 4 < 6: [2, 3, 4, 6, 9]
• Again, 6 < 9, so no swap occurs: [2, 3, 4, 6, 9]

The list is already sorted, but the bubble sort algorithm doesn't realize this. Rather, it needs to complete an entire pass through the list without swapping any values to know the list is sorted.

Third pass through the list:

• [2, 4, 3, 6, 9] => [2, 4, 3, 6, 9]
• [2, 4, 3, 6, 9] => [2, 4, 3, 6, 9]
• [2, 4, 3, 6, 9] => [2, 4, 3, 6, 9]
• [2, 4, 3, 6, 9] => [2, 4, 3, 6, 9]

Clearly bubble sort is far from the most efficient sorting algorithm. Still, it's simple to wrap your head around and implement yourself.

Now go pour yourself a cold, bubbly beverage – you deserve it.