Bubble sort

What is the primary operation of Bubble Sort to sort elements?

• Swapping adjacent elements if they are in the wrong order

• Selecting the minimum element and placing it at the beginning

• Dividing the array into smaller parts

• Using a pivot element to partition the array

What happens to the largest element in the array after the first pass of Bubble Sort?

• It moves to its correct position at the end of the array

• It moves to the beginning of the array

• It is swapped with the smallest element

• It remains in its original position

What does the 'bubbling up' term in Bubble Sort refer to?

• The movement of smaller elements to the beginning

• The movement of the next largest item to its correct position after each pass

• The process of dividing the array

• The swapping of elements in the wrong order

What is the correct order of elements after the second pass of Bubble Sort?

• All elements are in their correct positions except the smallest

• The array is fully sorted

• The second largest element is in its correct position

• The smallest element is at the beginning

What is the time complexity of Bubble Sort in the best-case scenario?

• O(log N)

• O(N log N)

• O(N)

• O(N^2)

How many passes are needed in the best-case scenario for Bubble Sort?

• N

• 1

• 0

• N-1

In the worst-case scenario, how many comparisons does Bubble Sort make for an array of N elements?

• N

• N^2

• N/2

• N-1

Why is Bubble Sort considered inefficient for large datasets?

• Because its time complexity can be quadratic

• Because it makes unnecessary comparisons

• Because it uses extra memory

• Because it cannot sort negative numbers

Which area does Bubble Sort's time complexity fall into on a growth rate chart?

• Green

• Yellow

• Orange

• Red

What is advised to do before looking at the implementation of Bubble Sort in the video?

• Memorize the steps of Bubble Sort

• Understand the concept of swapping elements

• Attempt to implement Bubble Sort independently

• Review the concept of linear time complexity