# Bubble Sort for 2D Array in Java

Home /

## Introduction to Bubble Sort for 2D Array in Java

Bubble sort is a simple and commonly used sorting algorithm that works by repeatedly swapping adjacent elements if they are in the wrong order. In Java, bubble sort can be used to sort one-dimensional arrays, but it can also be extended to sort two-dimensional arrays.

A 2D array in Java is an array of arrays, where each subarray is of the same length. In the context of sorting a 2D array, we can think of it as a table with rows and columns, where each row represents a set of values that we want to sort.

Bubble sort for a 2D array in Java works by iterating over each row of the array and applying the bubble sort algorithm to each row separately. This means that we sort the first row, then the second row, and so on until we have sorted all rows in the 2D array.

Bubble sort for a 2D array can be useful in scenarios where we have data that is organized in a tabular format and we need to sort it based on one or more columns. It’s also a good algorithm to use for small to medium-sized data sets, but can become inefficient for larger data sets.

In the following sections, we will explore how bubble sort works for 2D arrays in Java, and how we can implement it step-by-step.

## How Bubble Sort Works for 2D Arrays in Java

Bubble sort for 2D arrays in Java works by iterating over each row of the array and applying the bubble sort algorithm to each row separately. The bubble sort algorithm involves comparing adjacent elements in the row and swapping them if they are in the wrong order. This process is repeated until the entire row is sorted.

Here’s an overview of how bubble sort works for a single row of a 2D array:

1. Start at the beginning of the row (i.e., the leftmost element).
2. Compare the first element with the second element. If the first element is greater than the second element, swap them.
3. Move to the next pair of adjacent elements and repeat step 2.
4. Continue steps 2-3 until the end of the row is reached.
5. At this point, the rightmost element in the row should be the largest element.
6. Repeat steps 1-5, but exclude the rightmost element in the row from the comparison in step 2.
7. Continue steps 1-6 until the entire row is sorted.

To apply this algorithm to a 2D array, we simply iterate over each row of the array and apply the bubble sort algorithm to each row separately. Here’s an overview of how bubble sort works for a 2D array:

1. Iterate over each row of the 2D array.
2. Apply the bubble sort algorithm to the current row.
3. Move to the next row and repeat step 2.
4. Continue steps 2-3 until all rows in the 2D array are sorted.

By applying the bubble sort algorithm to each row separately, we can ensure that each row is sorted based on its own values, rather than being influenced by the values in other rows.

## Implementing Bubble Sort for 2D Arrays in Java

Here’s a step-by-step guide for implementing bubble sort for 2D arrays in Java:

1.Declare a 2D array of integers that needs to be sorted.

Java
``int[][] arr = {{5, 3, 1}, {8, 6, 4}, {2, 9, 7}};``

2. Loop over each row in the 2D array.

Java
``````for (int i = 0; i < arr.length; i++) {
// bubble sort algorithm goes here
}
``````

3.Within the row loop, implement the bubble sort algorithm to sort each row.

Java
``````for (int j = 0; j < arr[i].length - 1; j++) {
for (int k = 0; k < arr[i].length - j - 1; k++) {
if (arr[i][k] > arr[i][k + 1]) {
// swap elements in the row
int temp = arr[i][k];
arr[i][k] = arr[i][k + 1];
arr[i][k + 1] = temp;
}
}
}
``````

4. The completed implementation will look like this:

Java
``````int[][] arr = {{5, 3, 1}, {8, 6, 4}, {2, 9, 7}};

for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length - 1; j++) {
for (int k = 0; k < arr[i].length - j - 1; k++) {
if (arr[i][k] > arr[i][k + 1]) {
// swap elements in the row
int temp = arr[i][k];
arr[i][k] = arr[i][k + 1];
arr[i][k + 1] = temp;
}
}
}
}

// print the sorted 2D array
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
``````

5. The output of the above code will be:

``````1 3 5
4 6 8
2 7 9
``````

This code successfully sorts the 2D array using bubble sort algorithm for each row separately. Note that this implementation only sorts the rows based on their own values, and does not take into account the values in other rows. If you want to sort the entire 2D array based on a specific column, you would need to modify the implementation to compare elements across rows.

## Time and Space Complexity of Bubble Sort for 2D Arrays in Java

The time and space complexity of bubble sort for 2D arrays in Java are as follows:

Time Complexity: The time complexity of bubble sort algorithm for 2D arrays is O(n^2), where n is the number of elements in the array. In bubble sort algorithm, we need to compare each element with every other element to sort the array. Therefore, the total number of comparisons will be n * (n-1) / 2. Hence, the time complexity of bubble sort for 2D arrays is O(n^2).

Space Complexity: The space complexity of bubble sort algorithm for 2D arrays is O(1), which means it is constant. Bubble sort algorithm only requires a constant amount of extra memory to swap the elements in the array.

Therefore, if the size of the 2D array is very large, the bubble sort algorithm may not be the most efficient way to sort the array. There are other sorting algorithms like merge sort and quick sort that have better time complexity for large arrays.