1. Tipo de bolha
A classificação de bolhas é um algoritmo básico de classificação.A idéia principal é: se você deseja classificar de pequeno a grande, compare os elementos adjacentes e, quando o elemento esquerdo for maior que o direito, troque de posição.
Por exemplo, uma matriz: 9-18-6-5-12. Classifique esses 5 elementos, de pequeno a grande, a ideia é a seguinte
(1) Compare os números 1 e 2, sem troca; compare os números 2 e 3, troca 9-6-18-5-12; compare os números 3 e 4, troca 9-6-5 -18-12; compare o 4º e o 5º lugar, troque 9-6-5-12-18. No momento, os 18 maiores já estão em último lugar
(2) Compare o primeiro e o segundo lugares, troque 6-9-5-12-18; compare o segundo e o terceiro lugares, troque 6-5-9-12-18; compare o terceiro e o quarto lugares Bits, sem trocar. No momento, o segundo maior 12 está entre os penúltimos
(3) Compare o 1º e o 2º lugares, troque 5-6-9-12-18; compare o 2º e o 3º lugares, não troque; o terceiro maior 9 está agora de volta
(4) Compare o 1º e o 2º lugar sem troca. Classificado
Resumo: Se você classificar n números, precisará de n-1 viagens para classificar o final, porque cada viagem pode colocar um número de volta, cada viagem é o primeiro bit a iniciar a comparação para trás, mas não precisa ser comparada ao final Um.
package com.note;
import java.util.Scanner;
public class 冒泡排序 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();//表示有n个数
int[] arr = new int[n + 1];
//将n个数存储到arr数组中
for (int i=1;i<=n;i++){
arr[i] = sc.nextInt();
}
//冒泡排序
for (int i=1;i<=n-1;i++){//需要进行n-1趟排序
for (int j=1;j<=n-i;j++){//比较到n-i即可，因为每次都会排好一位
if (arr[j] > arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
//输出排序后的数组
for (int i=1; i<=n; i++)
System.out.print(arr[i]+" ");
}
}
O código é como acima, e as notas são muito claras e digite
5
9 18 6 5 12
Após o resultado é o seguinte
5 6 9 12 18
Segundo, classificação rápida
O algoritmo de ordenação rápida é um algoritmo usado com freqüência, mas seu entendimento é muito mais difícil que o da bolha, porque envolve idéias recursivas e de divisão e conquista.Estas idéias são muito difíceis de entender, mesmo se eu for um aluno da turma. Não é fácil, por isso não explicarei essas duas idéias aqui, mas explicarei diretamente como a classificação rápida funciona.
Por exemplo, uma matriz: 9-18-6-5-12-8-3-7. Classifique esses 8 elementos, de pequeno a grande, a ideia é a seguinte
(1) Primeiro defina um número de referência, o que for o primeiro número, por exemplo 9. Então 9 é um número de referência
(2) Defina esquerda = 1 para apontar para o primeiro número 9 e direita = 8 para apontar para o último número 7.
(3) Deixe a direita mover-se primeiro para a esquerda até encontrar um número menor que o número de referência.De fato, quando direita = 8, o elemento 7 é menor que 9, e a esquerda se move para a direita até encontrar um número maior que 9, quando esquerda = 2 Elementos com 18 são maiores que 9. Troque arr [esquerda] e arr [direita]. Então 9-7-6-5-12-8-3-18.
(4) A direita continua à esquerda, o elemento é 3 menor que 9 quando direita = 7; a esquerda continua à direita, o elemento 12 é maior que 9 quando esquerda = 5; trocado por 9-7-6-5-3-8-12-18 .
(5) Direita continua à esquerda, o elemento é 8 menor que 9 quando direita = 6; esquerda continua à direita, quando esquerda = 6, neste momento em que esquerda e direita se encontram, é necessário retornar o número padrão, ou seja, trocar 9 e 8 Obtenha 8-7-6-5-3-9-12-18. Neste momento, você encontrará que o lado esquerdo de 9 é menor que 9 e o lado direito de 9 é maior que 9.
(6) Classifique rapidamente os números à esquerda de 9 da mesma maneira e classifique rapidamente à direita.
package com.note;
import java.util.Scanner;
public class 快速排序 {
private static int[] arr;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();//表示有n个数
arr = new int[n + 1];
//将n个数存储到arr数组中
for (int i=1;i<=n;i++){
arr[i] = sc.nextInt();
}
//调用快速排序函数
f(1,n);
//输出排序后的数组
for (int i=1; i<=n; i++)
System.out.print(arr[i]+" ");
}
private static void f(int left, int right) {
if (left > right)
return;
//设置一个基准数
int temp = arr[left];
//设置左右2大使者
int i = left;
int j = right;
while (i != j){//当i和j没有相遇
//j向左寻找一个小于temp的数
while (arr[j]>=temp && i<j)
j--;
//i向右寻找一个大于temp的数
while (arr[i]<=temp && i<j)
i++;
//找到之后交换
int t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
//i和j相遇，就将基准数归位
arr[left] = arr[i];
arr[i] = temp;
f(left, i-1);//继续递归处理左边的数组
f(i+1, right);//继续递归处理右边的数组
}
}
Entrada
8
9 18 6 5 12 8 3 7
Após saída
3 5 6 7 8 9 12 18
