Recentemente, li muitos livros e postagens de blog relacionadas a algoritmos e queria gravá-los sozinho. Aprendi classificação de bolhas na faculdade e quase esqueci agora. Vamos revisá-lo novamente hoje.
O que é algoritmo Bubble Sort?
Bubble Sort (Bubble Sort) é a classificação de troca mais básica
Ideia de classificação: compare elementos adjacentes para decidir se deve trocar posições
O tipo de bolha original é um tipo estável e a complexidade de tempo é O(N^2)
Implementação Java do tipo de bolha
A implementação original do Java de classificação por bolhas é a seguinte
public class Test {
public static void main(String[] args) {
int[] a = {6, 4, 5, 3, 2, 1};
bubbleSort(a);
System.out.println("sort:" + Arrays.toString(a));
}
/**
* 原始的冒泡升序排序
*
* @param array
*/
public static void bubbleSort(int array[]) {
int temp;//交换元素的临时变量
for (int i = 0; i < array.length - 1; i++) {//外层循环遍历的次数array.length - 1
for (int j = 0; j < array.length - (i + 1); j++) {//内层循环遍历相邻元素进行比较和交换
if (array[j] > array[j + 1]) {//相邻的前一个元素大于后一个元素则交换
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
}
}
Otimização de classificação de bolhas
A implementação original do tipo de bolha é muito simples, relativamente estável e a complexidade do tempo é basicamente inalterada
Se for uma matriz ordenada para classificar, também levará o mesmo tempo
O meio da classificação já está em ordem, então não precisamos percorrê-lo
Se não trocarmos elementos depois de percorrer uma vez, sairemos do loop diretamente e a classificação estará completa
Se no processo de percorrer elementos adjacentes, algumas das matrizes já estiverem em ordem, não precisamos percorrer os seguintes elementos
Durante o processo de passagem, registramos o subscrito da última troca de elemento (esse subscrito é o limite entre a área ordenada e a área não ordenada) e o limite do próximo ciclo é o subscrito do último elemento trocado na última vez
A implementação otimizada do Java de ordenação de bolhas é a seguinte:
public class Test {
public static void main(String[] args) {
int[] a = {2, 11, 10, 3, 9, 2, 6, 4, 5, 3, 2, 1};
bubbleSort(a);
System.out.println("sort:" + Arrays.toString(a));
}
/**
* 优化后的冒泡升序排序
*
* @param array
*/
public static void bubbleSort(int array[]) {
int temp;//交换元素的临时变量
int boundary = array.length - 1;//无序区的边界,每次比较元素到这里
for (int i = 0; i < array.length - 1; i++) {//外层循环遍历的次数array.length - 1
boolean sorted = true;//有序标记,每一轮都设置为true
int lastExchange = 0;//最后一次交换元素的位置
for (int j = 0; j < boundary; j++) {//内层循环遍历相邻元素进行比较和交换
if (array[j] > array[j + 1]) {//相邻的前一个元素大于后一个元素则交换
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
sorted = false;//有元素交换,设置排序完成为false
lastExchange = j;//有元素交换,记录下交换的下标
}
}
boundary = lastExchange;//最后一次交换元素的下标就是下次遍历的边界
if (sorted) {//排序完成
break;
}
}
}
}