O método de classificação rápido usa principalmente o Arrays.sort () para implementá -lo.
O método da bolha é usar matrizes de travessia para comparar e atravessar os valores mínimo ou máximo um por um através de comparação contínua.
O método de classificação de seleção é usar os primeiros dados da matriz como o maior ou menor valor e, em seguida, produzir uma matriz ordenada por meio de um loop de comparação.
A classificação Inserir é selecionar os dados em uma matriz e classificá -los no final, inserindo e comparando constantemente.
A cópia do código é a seguinte:
pacote com.firewolf.sort;
classe pública mysort {
/**
* @param args
*/
public static void main (string [] args) {
int dray [] = {45,32,54,12,43,65,11,3,43,6,33,90,44,1,178};
Mysort mysort = new mysort ();
mysort.insertsort (matriz);
System.out.print ("Inserir resultado de classificação:");
mysort.printary (matriz);
System.out.println ();
mysort.bubblesort (matriz);
System.out.print ("resultado da classificação da bolha:");
mysort.printary (matriz);
mysort.qsort (matriz);
System.out.println ();
System.out.print ("Resultado rápido de classificação:");
mysort.printary (matriz);
mysort.shellsort (Array);
System.out.println ();
System.out.print ("Resultado da classificação da colina:");
mysort.printary (matriz);
mysort.SelectSort (Array);
System.out.println ();
System.out.print ("Selecione o resultado de classificação:");
mysort.printary (matriz);
}
/**
* Classificação de inserção direta
* Ideia básica: no conjunto de números a serem classificados, assumindo que os números anteriores (n-1) [n> = 2] já estão em ordem, agora você precisa inserir o enésimo número no número ordenado na ordem anterior . Repita este ciclo até que todos estejam organizados para
*/
public void insertSort (int [] Array) {
int temp = 0;
for (int i = 1; i <Array.length; i ++) {
int j = i-1;
temp = matriz [i];
para (; j> = 0 && temp <array [j]; j-) {
matriz [j+1] = matriz [j];
}
matriz [j+1] = temp;
}
}
/**
* Classificação da bolha
* Ideia básica: no conjunto de números a serem classificados, compare e ajuste os dois números adjacentes de cima para baixo para fazer com que números maiores afundem, os menores aumentam. Ou seja, sempre que dois números adjacentes são comparados e descobriram que sua classificação é oposta aos requisitos de classificação, eles são trocados.
*/
public void bubblesort (int [] matriz) {
int temp;
for (int i = 0; i <array.length; i ++) {// número de viagens
for (int j = 0; j <Array.Length-i-1; J ++) {// Número de comparações
if (Array [j]> Array [j+1]) {
temp = matriz [j];
array [j] = array [j+1];
matriz [j+1] = temp;
}
}
}
}
/**
* Classificação rápida
* Idéia básica: Selecione um elemento de referência, geralmente o primeiro elemento ou o último elemento e, através de uma varredura, divida a sequência a ser classificada em duas partes. Elemento de referência.
* Array @param
*/
public void qsort (int array []) {
if (Array.Length> 1) {
_qsort (matriz, 0, array.length-1);
}
}
/**
* Classificação rápida para uma viagem
* Array @param
*/
private vazio _qsort (int [] array, int baixo, int alto) {
if (baixo <alto) {
int middle = getMiddle (matriz, baixo, alto);
_qsort (Array, Low, Middle-1);
_qsort (matriz, meio+1, alto);
}
}
/**
* Obtenha o valor intermediário
*/
private int getMiddle (int [] matriz, int baixo, int alto) {
int tmp = matriz [baixo];
while (baixo <alto) {
while (Low <High && Array [High]> = TMP)
Alto--;
Array [Low] = Array [High];
while (Low <High && Array [Low] <= tmp)
baixo ++;
Array [High] = Array [Low];
}
Array [baixo] = tmp;
retornar baixo;
}
/**
* Tipo de seleção simples
* Idéia básica: Entre o conjunto de números a serem classificados, selecione o menor número e troque -o com o número na primeira posição; Até que o penúltimo número seja comparado com o último número.
* Array @param
*/
public void selectSort (int [] Array) {
int position = 0;
for (int i = 0; i <Array.length; i ++) {
int j = i+1;
posição = i;
int temp = matriz [i];
para (; j <array.length; j ++) {
if (Array [j] <temp) {
temp = matriz [j];
posição = j;
}
}
Array [posição] = Array [i];
Array [i] = temp;
}
}
/**
* Corrente da colina (classificação incremental mínima)
* Idéia básica: o algoritmo primeiro divide o número a ser classificado em vários grupos de acordo com um certo incremento d (N/2, n é o número de números a serem classificados), e os subscritos registrados em cada grupo são diferentes de d. Para cada grupo, todos os elementos são classificados diretamente e agrupados com um incremento menor (d/2) e depois classificados diretamente em cada grupo. Quando o incremento é reduzido para 1, a classificação é concluída após a execução da classificação de inserção direta.
* Array @param
*/
public void Shellsort (Int [] Array) {
duplo d1 = array.length;
int temp = 0;
while (true) {
d1 = math.ceil (d1/2);
int d = (int) d1;
for (int x = 0; x <d; x ++) {
for (int i = x+d; i <array.length; i+= d) {
int j = id;
temp = matriz [i];
para (; j> = 0 && temp <array [j]; j- = d) {
matriz [j+d] = matriz [j];
}
matriz [j+d] = temp;
}
}
if (d == 1)
quebrar;
}
}
/**
* Imprima todos os elementos na matriz
*/
public void PrintArray (int [] Array) {
for (int i = 0; i <Array.length; i ++) {
System.out.print (Array [i]+"");
}
}
}
Aqui estão alguns exemplos de métodos de classificação usados separadamente
Classificação rápida usando o método de classificação com matrizes
A cópia do código é a seguinte:
importar java.util.arrays;
classe pública test2 {
public static void main (string [] args) {
int [] a = {5,4,2,4,9,1};
Arrays.sort (a);
para (int i: a) {
System.out.print (i);
}
}
}
Algoritmo de classificação de bolhas
A cópia do código é a seguinte:
public static int [] bubblesort (int [] args) {// algoritmo de classificação de bolhas
for (int i = 0; i <args.length-1; i ++) {
for (int j = i+1; j <args.length; j ++) {
if (args [i]> args [j]) {
int temp = args [i];
args [i] = args [j];
args [j] = temp;
}
}
}
retornar args;
}
Selecione o algoritmo de classificação
A cópia do código é a seguinte:
public static int [] selectSort (int [] args) {// Selecione o algoritmo de classificação
for (int i = 0; i <args.length-1; i ++) {
int min = i;
for (int j = i+1; j <args.length; j ++) {
if (args [min]> args [j]) {
min = j;
}
}
if (min! = i) {
int temp = args [i];
args [i] = args [min];
args [min] = temp;
}
}
retornar args;
}
Insira o algoritmo de classificação
A cópia do código é a seguinte:
public static int [] insertSort (int [] args) {// inserir algoritmo de classificação
for (int i = 1; i <args.length; i ++) {
for (int j = i; j> 0; j-) {
if (args [j] <args [j-1]) {
int temp = args [j-1];
args [j-1] = args [j];
args [j] = temp;
} mais quebrar;
}
}
retornar args;
}
Os acima são quatro métodos de classificação em Java. Métodos diferentes têm eficiências diferentes.
Bolhas de bolha: comparação o (n2) troca de dados o (n2)
Selecione Classificação: Compare O (n2) Exchange O (n)
Inserir classificação: compare o (n2) cópia dados o (n)
Em aplicações práticas, devemos tentar escolher algoritmos eficientes.