###### Linux

#### Top 60 Linux Interview Questions & Answers

Download PDF 1) What is Linux? Linux is an operating system based on UNIX and was first introduced by...

- Details

Bubble sort is a sorting algorithm that is used to sort items in a list in ascending order. This is done by comparing two adjacent values. If the first value is higher than the second value, then the first value takes the position of the second value while the second value takes the position that was previously occupied by the first value. If the first value is lower than the second value, then no swapping is done.

This process is repeated until all the values in a list have been compared and swapped if necessary. Each iteration is usually called a pass. The number of passes in a bubble sort is equal to the number of elements in a list minus one.

In this algorithm tutorial you will learn:

- What is a Bubble Sort?
- Implementing the Bubble Sort Algorithm
- Optimized Bubble Sort Algorithm
- Visual Representation
- Python Examples
- Code Explanation
- Bubble sort advantages
- Bubble sort Disadvantages
- Complexity Analysis of Bubble Sort

We will breakdown the implementation into three (3) steps, namely the problem, the solution, and the algorithm that we can use to write code for any language.

A list of items is given in random order, and we would like to arrange the items in an orderly manner

Consider the following list:

[21,6,9,33,3]

Iterate through the list comparing two adjacent elements and swapping them if the first value is higher than the second value.

The result should be as follows:

[3,6,9,21,33]

The bubble sort algorithm works as follows

**Step 1)** Get the total number of elements. Get the total number of items in the given list

**Step 2)** Determine the number of outer passes (n - 1) to be done. Its length is list minus one

**Step 3) ** Perform inner passes (n - 1) times for outer pass 1. Get the first element value and compare it with the second value. If the second value is less than the first value, then swap the positions

**Step 4) ** Repeat step 3 passes until you reach the outer pass (n - 1). Get the next element in the list then repeat the process that was performed in step 3 until all the values have been placed in their correct ascending order.

**Step 5) **Return the result when all passes have been done. Return the results of the sorted list

**Step 6)** Optimize Algorithm

Avoid unnecessary inner passes if the list or adjacent values are already sorted. For example, if the provided list already contains elements that have been sorted in ascending order, then we can break the loop early.

By default, the bubble sort algorithm compares all items in the list regardless of whether the list is already sorted or not. If the given list is already sorted, comparing all values is a waste of time and resources.

Optimizing the bubble sort helps us to avoid unnecessary iterations and save time and resources.

For example, if the first and second items are already sorted, then there is no need to iterate through the rest of the values. The iteration is terminated, and the next one is initiated until the process is completed.

Optimization is done using the following steps

**Step 1)** Create a flag variable that monitors if any swapping has occurred in the inner loop

**Step 2)** If the values have swapped positions, continue to the next iteration

**Step 3)** If the benefits have not swapped positions, terminate the inner loop, and continue with the outer loop.

An optimized bubble sort is more efficient as it only executes the necessary steps and skips those that are not required.

Given a list of five elements, the following images illustrate how the bubble sort iterates through the values when sorting them

The following image shows the unsorted list

**First Iteration**

**Step 1)**

The values 21 and 6 are compared to check which one is greater than the other.

21 is greater than 6, so 21 takes the position occupied by 6 while 6 takes the position that was occupied by 21

Our modified list now looks like the one above.

**Step 2)**

The values 21 and 9 are compared.

21 is greater than 9, so we swap the positions of 21 and 9

The new list is now as above

**Step 3)**

The values 21 and 33 are compared to find the greater one.

The value 33 is greater than 21, so no swapping takes place.

**Step 4)**

The values 33 and 3 are compared to find the greater one.

The value 33 is greater than 3, so we swap their positions.

The sorted list at the end of the first iteration is like the one above

**Second Iteration**

The new list after the second iteration is as follows

**Third Iteration**

The new list after the third iteration is as follows

**Fourth Iteration**

The new list after the fourth iteration is as follows

The following code shows how to implement the bubble sort using Python.

def bubbleSort( theSeq ): n = len( theSeq ) for i in range( n - 1 ) : flag = 0 for j in range(n - 1) : if theSeq[j] > theSeq[j + 1] : tmp = theSeq[j] theSeq[j] = theSeq[j + 1] theSeq[j + 1] = tmp flag = 1 if flag == 0: break return theSeq el = [21,6,9,33,3] result = bubbleSort(el) print (result)

Executing the above code produces the following results

[6, 9, 21, 3, 33]

The explanation for the code is as follows

**HERE,**

- Defines a function bubbleSort that accepts a parameter theSeq. The code does not output anything.
- Gets the length of the array and assigns the value to a variable n. The code does not output anything
- Starts a for loop that runs the bubble sort algorithm (n – 1) times. This is the outer loop. The code does not output anything
- Defines a flag variable that will be used to determine if a swap has occurred or not. This is for optimization purposes. The code does not output anything
- Starts the inner loop that compares all the values in the list from the first to the last one. The code does not output anything.
- Uses the if statement to check if the value on the left-hand side is greater than the one on the immediate right side. The code does not output anything.
- Assigns the value of theSeq[j] to a temporal variable tmp if the condition evaluates to true. The code does not output anything
- The value of theSeq[j + 1] is assigned to the position of theSeq[j]. The code does not output anything
- The value of the variable tmp is assigned to position theSeq[j + 1]. The code does not output anything
- The flag variable is assigned the value 1 to indicate that a swap has taken place. The code does not output anything
- Uses an if statement to check if the value of the variable flag is 0. The code does not output anything
- If the value is 0, then we call the break statement that steps out of the inner loop.
- Returns the value of theSeq after it has been sorted. The code outputs the sorted list.
- Defines a variable el that contains a list of random numbers. The code does not output anything.
- Assigns the value of the function bubbleSort to a variable result.
- Prints the value of the variable result.

The following are some of the advantages of the bubble sort algorithm

- It is easy to understand
- It performs very well when the list is already or almost sorted
- It does not require extensive memory.
- It is easy to write the code for the algorithm
- The space requirements are minimal compared to other sorting algorithms.

The following are some of the disadvantages of the bubble sort algorithm

- It does not perform well when sorting large lists. It takes too much time and resources.
- It's mostly used for academic purposes and not the real-world application.
- The number of steps required to sort the list is of the order n
^{2}

There are three types of Complexity are:

The sort complexity is used to express the amount of execution times and space that it takes to sort the list. The bubble sort makes (n – 1) iterations to sort the list where n is the total number of elements in the list.

The time complexity of the bubble sort is O(n^{2})

The time complexities can be categorized as:

**Worst case**– this is where the list provided is in descending order. The algorithm performs the maximum number of executions which is expressed as [Big-O] O(n^{2})**Best case**– this occurs when the provided list is already sorted. The algorithm performs the minimum number of executions which is expressed as [Big-Omega] Ω(n)**Average case**– this occurs when the list is in random order. The average Complexity is represented as [Big-theta] ⊝(n^{2})

The space complexity measures the amount of extra space that is needed for sorting the list. The bubble sort only requires one (1) extra space for the temporal variable used for swapping values. Therefore, it has a space complexity of O (1).

- The bubble sort algorithm works by comparing two adjacent values and swapping them if the value on the left is less than the value on the right.
- Implementing a bubble sort algorithm is relatively straight forward with Python. All you need to use are for loops and if statements.
- The problem that the bubble sort algorithm solves is taking a random list of items and turning it into an ordered list.
- The bubble sort algorithm performs best when the list is already sorted as it performs a minimal number of iterations.
- The bubble sort algorithm does not perform well when the list is in reverse order.
- The bubbler sort has a time complexity of O (n
^{2}) and a space complexity of O (1) - The bubbler sort algorithm is best suited for academic purposes and not real-world applications.
- The optimized bubble sort makes the algorithm more efficient by skipping unnecessary iterations when checking values that have already been sorted.

Download PDF 1) What is Linux? Linux is an operating system based on UNIX and was first introduced by...

Generally, in a large organization, there are multiple, separate teams to manage and run jobs in...

There are many front-end development tools that accelerate web development. Here is a curated list of...

Linux is a clone of UNIX, the multi-user operating system which can be accessed by many users...

Jenkins is an open source Continuous Integration platform and is a cruial tool in DevOps...

What is the Knapsack Problem? KNAPSACK PROBLEM is a very helpful problem in combinatorics. In the...