Metode penyortiran cepat terutama menggunakan arrays.sort () untuk mengimplementasikannya.
Metode gelembung adalah menggunakan array traversal untuk membandingkan, dan melintasi nilai minimum atau maksimum satu per satu melalui perbandingan kontinu.
Metode penyortiran pemilihan adalah menggunakan data pertama dari array sebagai nilai terbesar atau terkecil, dan kemudian mengeluarkan array yang dipesan melalui loop perbandingan.
Masukkan penyortiran adalah memilih data dalam array dan mengurutkannya di ujung dengan terus memasukkan dan membandingkannya.
Salinan kode adalah sebagai berikut:
paket com.firewolf.sort;
MySort kelas publik {
/**
* @param args
*/
public static void main (string [] args) {
int array [] = {45,32,54,12,43,65,11,3,43,6,33,90,44,1,178};
Mysort mysort = mysort baru ();
mysort.insertsort (array);
System.out.print ("Sisipkan Hasil Sortir:");
mysort.printarray (array);
System.out.println ();
mysort.bubblesort (array);
System.out.print ("Hasil Sortir Gelembung:");
mysort.printarray (array);
mysort.qsort (array);
System.out.println ();
System.out.print ("Hasil Sortir Cepat:");
mysort.printarray (array);
mysort.shellsort (array);
System.out.println ();
System.out.print ("Hasil Sortir Bukit:");
mysort.printarray (array);
mysort.selectsort (array);
System.out.println ();
System.out.print ("Pilih Hasil Sortir:");
mysort.printarray (array);
}
/**
* Sort Sisipan Langsung
* Ide Dasar: Dalam set angka yang akan diurutkan, dengan asumsi bahwa angka sebelumnya (n-1) [n> = 2] sudah beres, sekarang Anda perlu memasukkan nomor ke-n ke dalam nomor yang dipesan dalam urutan sebelumnya Ini membuat nomor N ini juga disortir secara berurutan. Ulangi siklus ini sampai semua diatur secara berurutan
*/
public void insertSort (int [] array) {
int temp = 0;
untuk (int i = 1; i <array.length; i ++) {
int j = i-1;
temp = array [i];
untuk (; j> = 0 && temp <array [j]; j-) {
array [j+1] = array [j];
}
array [j+1] = temp;
}
}
/**
* Sortir Gelembung
* Ide Dasar: Dalam set angka yang akan diurutkan, bandingkan dan sesuaikan dua angka yang berdekatan dari atas ke bawah untuk membuat angka yang lebih besar untuk tenggelam, yang lebih kecil naik. Artinya, setiap kali dua angka yang berdekatan dibandingkan dan menemukan bahwa penyortiran mereka berlawanan dengan persyaratan penyortiran, mereka dipertukarkan.
*/
public void bubblesort (int [] array) {
int temp;
untuk (int i = 0; i <array.length; i ++) {// Jumlah perjalanan
untuk (int j = 0; j <array.length-i-1; j ++) {// Jumlah perbandingan
if (array [j]> array [j+1]) {
temp = array [j];
array [j] = array [j+1];
array [j+1] = temp;
}
}
}
}
/**
* Sortir cepat
* Ide Dasar: Pilih elemen tolok ukur, biasanya elemen pertama atau elemen terakhir, dan melalui pemindaian, membagi urutan yang akan diurutkan menjadi dua bagian. Elemen Benchmark.
* @param array
*/
public void qsort (int array []) {
if (array.length> 1) {
_qsort (array, 0, array.length-1);
}
}
/**
* Penyortiran cepat untuk satu perjalanan
* @param array
*/
private void _qsort (int [] array, int low, int high) {
if (rendah <tinggi) {
int middle = getMiddle (array, rendah, tinggi);
_QSort (array, rendah, tengah-1);
_QSort (array, tengah+1, tinggi);
}
}
/**
* Dapatkan nilai menengah
*/
private int getMiddle (int [] array, int low, int high) {
int tmp = array [rendah];
sementara (rendah <tinggi) {
while (Low <High && Array [High]> = TMP)
Tinggi--;
array [rendah] = array [tinggi];
while (Low <high && array [rendah] <= tmp)
rendah ++;
array [tinggi] = array [rendah];
}
array [rendah] = tmp;
kembali rendah;
}
/**
* Jenis pilihan sederhana
* Ide Dasar: Di antara set angka yang akan diurutkan, pilih nomor terkecil dan pertukaran dengan nomor di posisi pertama; Jalan sampai angka kedua dari belakang dibandingkan dengan angka terakhir.
* @param array
*/
public void selectSort (int [] array) {
posisi int = 0;
untuk (int i = 0; i <array.length; i ++) {
int j = i+1;
posisi = i;
int temp = array [i];
untuk (; j <array.length; j ++) {
if (array [j] <temp) {
temp = array [j];
posisi = j;
}
}
array [posisi] = array [i];
array [i] = temp;
}
}
/**
* Sortir Hill (Sorts Inkremental Minimum)
* Ide Dasar: Algoritma pertama kali membagi angka yang akan diurutkan menjadi beberapa kelompok sesuai dengan kenaikan tertentu D (n/2, n adalah jumlah angka yang akan diurutkan), dan subskrip yang dicatat dalam setiap kelompok berbeda dari d. Untuk setiap kelompok, semua elemen diurutkan secara langsung, kemudian dikelompokkan dengan kenaikan yang lebih kecil (D/2), dan kemudian diurutkan langsung di setiap kelompok. Ketika kenaikan dikurangi menjadi 1, penyortiran selesai setelah jenis penyisipan langsung dilakukan.
* @param array
*/
public void shellsort (int [] array) {
d1 d1 = array.length;
int temp = 0;
while (true) {
d1 = math.ceil (d1/2);
int d = (int) d1;
untuk (int x = 0; x <d; x ++) {
untuk (int i = x+d; i <array.length; i+= d) {
int j = id;
temp = array [i];
untuk (; j> = 0 && temp <array [j]; j- = d) {
array [j+d] = array [j];
}
array [j+d] = temp;
}
}
if (d == 1)
merusak;
}
}
/**
* Cetak semua elemen dalam array
*/
public void printarray (int [] array) {
untuk (int i = 0; i <array.length; i ++) {
System.out.print (array [i]+"");
}
}
}
Berikut adalah beberapa contoh metode penyortiran yang digunakan secara terpisah
Penyortiran cepat menggunakan metode penyortiran dengan array
Salinan kode adalah sebagai berikut:
impor java.util.arrays;
test kelas publik2 {
public static void main (string [] args) {
int [] a = {5,4,2,4,9,1};
Arrays.sort (a);
untuk (int i: a) {
System.out.print (i);
}
}
}
Algoritma penyortiran gelembung
Salinan kode adalah sebagai berikut:
Public Static Int [] Bubblesort (int [] args) {// Algoritma penyortiran gelembung
untuk (int i = 0; i <args.length-1; i ++) {
untuk (int j = i+1; j <args.length; j ++) {
if (args [i]> args [j]) {
int temp = args [i];
args [i] = args [j];
args [j] = temp;
}
}
}
return args;
}
Pilih algoritma penyortiran
Salinan kode adalah sebagai berikut:
Public Static Int [] SelectSort (int [] args) {// Pilih algoritma penyortiran
untuk (int i = 0; i <args.length-1; i ++) {
int min = i;
untuk (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;
}
}
return args;
}
Masukkan algoritma penyortiran
Salinan kode adalah sebagai berikut:
Public Static Int [] InsertSort (int [] args) {// Masukkan algoritma penyortiran
untuk (int i = 1; i <args.length; i ++) {
untuk (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;
} lain break;
}
}
return args;
}
Di atas adalah empat metode penyortiran di Java. Metode yang berbeda memiliki efisiensi yang berbeda. Berikut ini adalah perbandingan algoritma yang berbeda dan representasi O yang besar selama pertukaran data.
Sort Bubble: Perbandingan O (N2) Pertukaran Data O (N2)
Pilih Sort: Bandingkan O (N2) Exchange Data O (n)
Masukkan Sort: Bandingkan O (N2) Salin Data O (n)
Dalam aplikasi praktis, kita harus mencoba memilih algoritma yang efisien.