Bubble Up to the Top: A Beginner's Guide to Bubble Sort in JavaScript
As a beginner programmer, you may have heard of the term "sorting algorithms" but have no idea what they are or how they work. Well, fear not! In this article, we'll be diving into one of the most basic sorting algorithms out there: bubble sort.
But before we get into the nitty-gritty of how bubble sort works, let's first define what it is. Simply put, bubble sort is an algorithm that compares adjacent elements in an array and swaps their positions if they are not in the correct order. It continues to do this until the array is fully sorted.
Now that we have a basic understanding of bubble sort, let's take a look at how it works with an example. Let's say we have an array of numbers that we want to sort from least to greatest: [5, 2, 1, 4, 3].
Using bubble sort, we would first compare the first two elements, 5 and 2. Since 5 is greater than 2, we would swap their positions. The array would now look like this: [2, 5, 1, 4, 3].
Next, we would compare the second and third elements, 5 and 1. Since 5 is greater than 1, we would swap their positions. The array would now look like this: [2, 1, 5, 4, 3].
We would continue this process until we reach the end of the array. The final step would be comparing the fourth and fifth elements, 4 and 3. Since 4 is greater than 3, we would swap their positions. The final, sorted array would look like this: [1, 2, 3, 4, 5].
So, now that you have a better understanding of how bubble sort works, let's take a look at some example for this algorithm in JavaScript.
Example
Sorting a list of names alphabetically
const sortNames = names => {
for (let i = 0; i < names.length; i++) {
for (let j = 0; j < names.length - i - 1; j++) {
if (names[j] > names[j + 1]) {
// Swap names[j] and names[j + 1]
let temp = names[j];
names[j] = names[j + 1];
names[j + 1] = temp;
}
}
}
return names;
};
const names = ['John', 'Bob', 'Sue', 'Alice', 'Zack'];
console.log(sortNames(names)); // ['Alice', 'Bob', 'John', 'Sue', 'Zack']
Sorting a list of numbers from least to greatest
const sortNumbers = numbers => {
for (let i = 0; i < numbers.length; i++) {
for (let j = 0; j < numbers.length - i - 1; j++) {
if (numbers[j] > numbers[j + 1]) {
// Swap numbers[j] and numbers[j + 1]
let temp = numbers[j];
numbers[j] = numbers[j + 1];
numbers[j + 1] = temp;
}
}
}
return numbers;
};
Sorting a list of products by price
const sortProducts = products => {
for (let i = 0; i < products.length; i++) {
for (let j = 0; j < products.length - i - 1; j++) {
if (products[j].price > products[j + 1].price) {
// Swap products[j] and products[j + 1]
let temp = products[j];
products[j] = products[j + 1];
products[j + 1] = temp;
}
}
}
return products;
};
const products = [ { name: 'Product A', price: 9.99 }, { name: 'Product B', price: 7.99 }, { name: 'Product C', price: 12.99 }];
console.log(sortProducts(products));
// [{ name: 'Product B', price: 7.99 }, { name: 'Product A', price: 9.99 }, { name: 'Product C', price: 12.99 }]
Sorting a list of employees by their job titles
const sortEmployees = (employees) => {
for (let i = 0; i < employees.length; i++) {
for (let j = 0; j < employees.length - i - 1; j++) {
if (employees[j].jobTitle > employees[j + 1].jobTitle) {
// Swap employees[j] and employees[j + 1]
let temp = employees[j];
employees[j] = employees[j + 1];
employees[j + 1] = temp;
}
}
}
return employees;
};
const employees = [
{ name: "John", jobTitle: "Manager" },
{ name: "Sue", jobTitle: "Developer" },
{ name: "Alice", jobTitle: "Designer" },
{ name: "Bob", jobTitle: "Salesperson" },
];
console.log(sortEmployees(employees));
// [
// { name: 'Alice', jobTitle: 'Designer' },
// { name: 'Sue', jobTitle: 'Developer' },
// { name: 'John', jobTitle: 'Manager' },
// { name: 'Bob', jobTitle: 'Salesperson' }
// ]
Sorting a list of cities by their population
const sortCities = (cities) => {
for (let i = 0; i < cities.length; i++) {
for (let j = 0; j < cities.length - i - 1; j++) {
if (cities[j].population > cities[j + 1].population) {
// Swap cities[j] and cities[j + 1]
let temp = cities[j];
cities[j] = cities[j + 1];
cities[j + 1] = temp;
}
}
}
return cities;
};
const cities = [
{ name: "New York", population: 8175133 },
{ name: "Los Angeles", population: 3792621 },
{ name: "Chicago", population: 2695598 },
{ name: "Houston", population: 2130332 },
];
console.log(sortCities(cities));
// [
// { name: 'Houston', population: 2130332 },
// { name: 'Chicago', population: 2695598 },
// { name: 'Los Angeles', population: 3792621 },
// { name: 'New York', population: 8175133 }
// ]
Performance and Limitations of Bubble Sort
Now that we've seen some practical examples of using bubble sort in JavaScript, let's talk about the performance and limitations of this algorithm.
One of the main limitations of bubble sort is its time complexity. Specifically, bubble sort has a time complexity of O(n^2), meaning that it becomes increasingly slower as the size of the input increases. This makes it a less efficient option for sorting large lists.
However, bubble sort does have some benefits. It is a simple and easy-to-understand algorithm, making it a good choice for beginners. It is also a stable sort, meaning that it preserves the relative order of elements with equal keys.
Conclusion
In conclusion, bubble sort is a simple and easy-to-understand algorithm that can be useful for sorting small lists. While it is not the most efficient algorithm for larger lists, it can still be a useful tool in certain situations. Remember to keep its time complexity in mind when deciding whether or not to use bubble sort for your sorting needs.
Mình hy vọng bạn thích bài viết này và học thêm được điều gì đó mới.
Donate mình một ly cafe hoặc 1 cây bút bi để mình có thêm động lực cho ra nhiều bài viết hay và chất lượng hơn trong tương lai nhé. À mà nếu bạn có bất kỳ câu hỏi nào thì đừng ngại comment hoặc liên hệ mình qua: Zalo - 0374226770 hoặc Facebook. Mình xin cảm ơn.
Momo: NGUYỄN ANH TUẤN - 0374226770
TPBank: NGUYỄN ANH TUẤN - 0374226770 (hoặc 01681423001)
All rights reserved
