Dieser Artikel fasst verschiedene Sortieralgorithmen in Java zusammen. Teilen Sie es für Ihre Referenz wie folgt weiter:
1. Blasenart:
öffentliche Klasse Sortest {public static void main (String [] args) {int [] a = {345,7,32,5,4, -1,3,12,23,110,45645,321,456,78, -1,78 78,32.444.345}; {für (int j = 0; j <A.Length-i-1; j ++) {if (a [j]> a [j+1]) {int tmp = a [j]; [J+1];2. Schnelle Sortierung (keine doppelten Werte):
public class sortest {public static void main (String [] args) {int [] a = {345,7,32,5,4,3,12,23,110}; .Length-1); = starten; ) {i ++; int n, int index) {int tmp = a [n]; .println (Arrays.toString (a));3. Schnelle Sortierung (kann wiederholte Werte enthalten)
öffentliche Klasse Sortest {public static void main (String [] args) {int [] a = {345,7,32,5,4, -1,3,12,23,110,45645,321,456,78, -1,78 78,32,345}; > = Ende) int i = starten; = index && a [j] == a [index]) {index = swap (a,-j, index); a [i]) {i ++; I, Index)}} QuickSort2 (a, start, index-1); a [n]; ;}}4. Heapsortierung
öffentliche Klasse Sortest {public static void main (String [] args) {int [] a = {345,7,32,5,4, -1,3,12,23,110,45645,321,456,78, -1,78 78,32.444,345}; /2-1; i> = 0; i-) {createBigigheap (a, i, size-1); [0]; [] a, int start, int end) {int tmp = a [start]; +1]) {j ++; ] = tmp;5. Sortier einfügen
public class sortest {public void main (String [] args) {int [] a = {345,7,32,5,4, -1,3}; ); j = i; j> = 0; j-) {if (tmp <a [j]) {a [n] = a [j]; a [n] = tmp;6. Halbeinsatz -Sortier
öffentliche Klasse Sortest {public static void main (String [] args) {int [] a = {345,7,7,345,2,2,7,2,7,23,2,345,7,32,5,4,---------- 1,3,7,2,3,3,4,2,1,2,4,5,3,345,3,2,2,2,2,2,3,345,3,2}; statische void InsertSort2 (int [] a) {für (int i = 0; i <A.Length-1; i ++) {int n = i+1; ]) Int LOW = 0; ]) {High = Mid -1; -) {a [j] = a [j-1]; ;}}7. Hill Sort
öffentliche Klasse Sortest {public static void main (String [] args) {int [] a = {345,7,32,5,4, -1,3,2,3,5,7,90,1} ; ) {int i, j, k, temp, gap; 58548857, 157840433,410151271,1131376761,2147483647}; i <n; i ++ {temp = a [i]; - Gap;8. Sortieren auswählen
public class sortest {public static void main (String [] args) {int [] a = {345,7,32,5,4, -1}; } private statische Void SelectSort (int [] a) {für (int i = 0; i <A.Length-1; i ++) {int min = i; J ++) {if (a [j] <a [min]) min = j; = TMP;9. Bestellung
öffentliche Klasse Sortest {public static void main (String [] args) {int [] a = {345,7,32,5,4, -1,3,2,3,5,7,90,1,432, -1,3,2,3,7,8,90,1,432, 1}; Speicherspeicher Der mittlere Index ist mit dem linken Wert int [] links = setValue (a, 0, mid); ; Elementwert ist 1 Mergesort (rechts); {int i = 0, j = 0, k = 0; [i ++];} else {a [k ++] = rechts [j ++]; ; j ++) {a [k ++] = rechts [j]; int i = 0; A)); } }Zusammenfassung:
öffentliche Klasse Sortutil {öffentliche statische Int Desc = -1; (int [] a, int sortieren) {if (sort == asc) bubblesortasc (a); .Length-1; i ++) {für (int j = 0; j <A.Length-i-1; j ++) {if (a [j]> a [j+1]) {int tmp = a [j] ; a [j] = a [j+1]; 1; i ++) {für (int j = 0; j <A.Length-i-1; j ++) {if (a [j] <a [j+1]) {int tmp = a [j]; J] = A [j+1]; -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------- Fähigkeit -Segment-line ------------------------------------------------------ -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- param sortil.asc, sortutil.desc */ public static void QuickNorepeatsort (int [] a, int sort) {if (sort == asc) QuickNorepeatsortasc (a, 0, A.Length-1); 0, A.Length-1); starten; {i ++; int starten, int) {if (start> = Ende) int i = start; {j -; , Index - 1); c statische void Quicksort (int [] a, int sortieren) {if (sort == asc) quicksortasc (a, 0, A.Length-1); statische void QuickSortasc (int [] A, int start, int) {if (start> = Ende) int i = start; [j]> a [index]) {j--; Index = SWAP (a, j, index); (a, ++ i, Index) statische VOI D Quicksortdesc (int [] A, int start, Ende) {if (start> = Ende) Return; a [j] <a [index]) {j--; {Index = SWAP (a, j, index); Swap (a, ++ i, index)} else {index = swap (a, i, index) private statische I nt Swap (int [] a, int n, intindex) {int tmp = a [n]; ---- ---------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------- @param ein Sortierarray * @param sortil.asc, sortil.desc */ public static void Heapsort (int [] a, int sort) {if (sort == asc) heapsortasc (a); i--) {createBigigheap (a, i, size - 1); [Größe - 1 - J]; {int tmp = a [start]; a [j]> tmp) {a start] = a [j]; int [] a) {// minimale Heap int size = A.Length; } // sortieren für (int j = 0; j <Größe - 1; j ++) {int tmp = a [0]; = TMP; 1; ] start = j; J = 2 * J + 1; -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------- ------------------------ /** * Sortier einfügen * * @param ein Sortierarray * @param Sortil. Asc, sortutil.desc */ public static void InsertSort (int [] a, int sort) {if (sort == ASC) {InsertSortasc (a); [] a) {für (int i = 0; i <A.Length - 1; i ++) {int n = i+1; j--) {if (tmp <a [j]) {a [n] = a [j]; public static void InsertSortDesc (int [] a) {für (int i = 0; i <A.Length - 1; i ++) {int n = i+1; ; j> = 0; ] = TMP;}} // ------------------------------------------------ -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------- int sort) {if (sort == asc) {halfInsertsortasc (a); - 1; i ++) {int n = i + 1; / 2; = Mid + 1; TMP; tmp <a [i]) int niedrig = 0; tmp> a [Mid]) {High = Mid - 1; J> Mid; -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------- ---------------------- /** * Hill Sort Sortutil.asc, sortil.desc */ public static void Shellsort (int [] a, int sort) {if (sort == asc) {ShellSortasc (a, A.Length); ); , 4711, 11969, 27901, 84801, 213331, 543749, 1355339, 3501671, 8810089, 21521774, 58548857, 157840433, 410151271, 113761, 2148347 n; -K> = 0) {ga p = gaps [k]; - gap]> temp) {a [j] = a [j - gap]; int i, j, k, temp, gap; , 21521774, 58548857, 157840433, 410151271, 1131376761, 2147483647}; = GAP; i <n; J = J-GAP; -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------- void selectSort (int [] a, int sort) {if (sort == asc) {selectSortasc (a); = 0; i <A.Length - 1; ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ::::::::::::::::::::::::::::::::::::::::::::::::::: für (int j = i+1; ] = a [min]; ; für (int j = i+1; j <A.Length; ] a [i] = a [max]; -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------Function-Segmentation-Line-- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------- Sortil.desc */ Public Static Void mergesort (int [] a, int sortieren) {// den Zwischenwert int Mid = A.Length / 2; , Mid); int [] right = setValue (a, Mid, A.Length); = = Asc) {mergeasc (a, links, rechts); ich : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: :::::::::::::::::::::::::::::::::: = 0, j = 0, k = 0; rechts.länge;) {if (links [i] <rechts [j]) {a [k ++] = links [i ++]; .Length; i ++) {a [k ++] = links [i]; , int [] links, int [] rechts) {int i = 0, j = 0, k = 0; [j]) {a [k ++] = links [i ++];} else {a [k ++] = rechts [j ++]; ]; = Neue int [Länge - für (int i = 0;Ich hoffe, dieser Artikel wird für Java -Programme aller hilfreich sein.