Detailed graphic explanation of Java implementation of bubble sort

This article brings you relevant knowledge about java, which mainly introduces the related issues of how to implement bubble sorting. Bubble sorting is to compare two adjacent elements, from From the beginning to the end of the list, each pair of adjacent elements is compared in turn. Let's take a look at it. I hope it will be helpful to everyone.

## Recommended study: "

java tutorial"

Bubble sorting principle

1. Compares two adjacent elements. If the first is larger than the second, swap their positions (in ascending order, vice versa in descending order).

2. Compare each pair of adjacent elements in sequence from the beginning to the end of the list. In this way, the element with the largest value "bubbles" to the end of the list through exchange, completing the first round of "bubbling".

3. Repeat the previous step and continue to compare adjacent elements in sequence from the beginning of the list. Elements that have "bubbled" out do not need to be compared (you can compare them all the way to the end. Elements that have "bubbled" to the back do not need to be exchanged even if they are compared. Not comparing can reduce steps).

4. Continue to compare starting from the list, and one element will "bubble" successfully in each round of comparison. The number of elements that need to be compared in each round will decrease until there is only one element left that does not "bubble" (no pair of elements needs to be compared), then the list sorting is completed.

Bubble sorting process

Take this one-dimensional array as an example:

int[] array = new int[]{55,33,22,66,11};

First round of bubbles

Figure ① is a column chart of the starting order of the data in the first round of "bubbles". As long as the condition is met: "The previous element is larger than the following element, then the position order is exchanged, otherwise there is no exchange."
1. array[0]=55 > array[1]=33, if the conditions are met, exchange the position order of the elements, as shown in Figure ②;
2. array[1]=55 > array[2]=22, if the condition is met, the position order of the elements is exchanged, as shown in Figure ③;
3. array[2]=55 array[3]=66 > array[4]=11, if the condition is met, the position order of the elements is exchanged, as shown in Figure ④;

The first round of "bubble" demonstration is shown in the figure:

The second round of bubbling

Figure ④ shows the second round The starting order column chart of the data in "bubble";
1. array[0]33 > array[1]=22, if the conditions are met, the position order of the elements is exchanged, as shown in Figure ⑤;
2. array[1]33 array[2]55 > array [3]=11, if the condition is met, exchange the position order of the elements, as shown in Figure ⑥;

The second round of "bubble" demonstration is as shown in the figure:

The third round of bubbling

Figure ⑥ shows the starting sequence column chart of the data in the third round of "bubble";
1. array[0]= 22 array[1]=33 > array[2]=11, the condition is met , exchange the position order of elements, as shown in Figure ⑦;

The third round of "bubble" demonstration is shown in the figure:

The fourth round Bubble

Figure ⑦ is a column chart of the starting sequence of data in the fourth round of "bubble";
1. array[0]=22 > array[1]= 11. If the conditions are met, exchange the position order of "22" and "11", as shown in Figure 8;

The fourth round of "bubble" demonstration is as shown in the figure:

At this point, the process of bubble sorting the array is complete!

Specific code implementation

BubbleSort class:

public class BubbleSort {
    public static void sort(int array[]) {
        //i表示第几轮“冒泡”，j 表示“走访”到的元素索引。
        // 每一轮“冒泡”中，j 需要从列表开头“走访”到 array.length - 1 的位置。
        for (int i = 0; i  array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }}

TestMain class

import java.util.Arrays;public class TestMain {
    public static void main(String[] args) {
        int[] array = new int[]{55, 33, 22, 66, 11};
        //输出排序前的array数组
        System.out.print("排序前：");
        System.out.println(Arrays.toString(array));
        //调用BubbleSort类中的sort方法对array数组进行排序
        BubbleSort.sort(array);
        //输出冒泡排序后的array数组
        System.out.print("排序后：");
        System.out.println(Arrays.toString(array));
    }}

The running results are as follows:

排序前：[55, 33, 22, 66, 11]排序后：[11, 22, 33, 55, 66]

Recommended learning : "

java learning tutorial"

The above is the detailed content of Detailed graphic explanation of Java implementation of bubble sort. For more information, please follow other related articles on the PHP Chinese website!