八大基本排序程式碼（陣列）
阿新 • • 發佈：2022-03-20
0 概述
public class Code00CallAllSort { public static void main(String[] args) { /* 1.氣泡排序 bubble sort 陣列元素兩兩比較，大數往後移，經過一輪，最大元素處於最後。 (0 1,1 2,2 3,3 4,...) */ Code01BubbleSort bubble =new Code01BubbleSort(); bubble.bubbleSort(); /* 2.選擇排序 select sort 陣列元素依次與第一個比較，小的往前移，經過一輪，最小元素處於首位。 (0 1,0 2,0 3,0 4,...) */ Code02SelectSort select = new Code02SelectSort(); select.selectSort(); /* 3.插入排序 insert sort 將一個元素插入到一個現存有序表中，經過一輪，有序表長度加 1 。 */ Code03InsertSort insert = new Code03InsertSort(); insert.insertSort(); /* 4.希爾排序 shell sort / diminishing increment sort 高階插入排序，當初始增量為1時，為插入排序；初始增量一般取 克努特序列 h = 3h+1 ，3h+1 > array.length */ Code04DiminishingIncrementSort shellSort = new Code04DiminishingIncrementSort(); shellSort.diminishingIncrementSort(); /* 5.快速排序 quick sort 取出一個基準數，大的放右邊，小的放左邊，直到各區間只有一個數。 */ Code05QuickSort quick = new Code05QuickSort(); quick.quickSort(); /* 6.歸併排序 merge sort 拆分至子序列有序，兩兩歸併。 */ Code06MergeSort merge = new Code06MergeSort(); merge.mergeSort(); /* 7.基數排序(桶排序) radix sort 依次根據 個位、十位、百位...上的數字進行排序（首先要找出最大值） */ Code07RadixSort radix = new Code07RadixSort(); radix.radixSort(); /* 8.堆排序 heap sort 先把陣列變為一個大頂堆，再把根元素和最後一個元素進行調換 */ Code08HeapSort heap = new Code08HeapSort(); heap.heapSort(); } }
1 氣泡排序
氣泡排序 bubble sort
陣列元素兩兩比較，大數往後移，經過一輪，最大元素處於最後。
(0 1,1 2,2 3,3 4,...)
import java.util.Arrays; // 氣泡排序 public class Code01BubbleSort { // public static void main(String[] args) { public void bubbleSort() { // 排序原理 陣列元素兩兩比較，大數往後移，經過一輪，最大元素處於最後。 int[] array = {24, 69, 80, 57, 13,234, 545, 57, 0, 4}; int temp = 0; for (int i = 0; i < array.length - 1; i++) { for (int j = 0; j < array.length - 1 -i; j++) { if(array[j+1] < array[j]){ temp = array[j]; array[j] = array[j+1]; array[j+1] = temp; } } } System.out.print("Bubble Sort:" + "\t"); System.out.println(Arrays.toString(array)); } }
2 選擇排序
選擇排序 select sort
陣列元素依次與第一個比較，小的往前移，經過一輪，最小元素處於首位。
(0 1,0 2,0 3,0 4,...)
import java.util.Arrays; public class Code02SelectSort { // public static void main(String[] args) { public void selectSort() { int[] array = {24, 69, 80, 57, 13,234, 545, 57, 0, 4}; int temp = 0; for (int i = 0; i < array.length-1; i++) { for (int k = i+1; k < array.length; k++) { if (array[i] > array[k]){ temp = array[i]; array[i] = array[k]; array[k] = temp; } } } System.out.print("Select Sort:" + "\t"); System.out.println(Arrays.toString(array)); } }
3 插入排序
插入排序 insert sort
將一個元素插入到一個現存有序表中，經過一輪，有序表長度加 1
import java.util.Arrays;
public class Code03InsertSort {
// public static void main(String[] args) {
public void insertSort() {
int[] array = {24, 69, 80, 57, 13,234, 545, 57, 0, 4};
int temp = 0;
for (int i = 1; i < array.length; i++) {
for (int k = i; k > 0; k--) {
if (array[k] < array[k-1]){
temp = array[k];
array[k] = array[k-1];
array[k-1] = temp;
}
}
}
System.out.print("Insert Sort:" + "\t");
System.out.println(Arrays.toString(array));
}
}
4 希爾拍戲
希爾排序 shell sort / diminishing increment sort
高階插入排序，當初始增量為1時，為插入排序；初始增量一般取 克努特序列 h = 3h+1 ，3h+1 > array.length
import java.util.Arrays;
public class Code04DiminishingIncrementSort {
// public static void main(String[] args) {
public void diminishingIncrementSort() {
int[] array = {24, 69, 80, 57, 13, 234, 545, 57, 0, 4};
int temp = 0;
// 一、
// for (int h = array.length / 2; h > 0; h /= 2) {/* 第一次增量選擇陣列長度的一半 */
// for (int i = h; i < array.length; i++) {
// for (int k = i; k > h - 1; k -= h) {
//
// if (array[k] < array[k - h]) {
// temp = array[k];
// array[k] = array[k - h];
// array[k - h] = temp;
// }
// }
// }
// }
// 二、
int delta = 1;
while (delta < array.length/3){
delta = delta * 3 + 1;
}/* 克努特序列 h = 3h+1 */
// System.out.println(delta);// 4
for (int h = delta; h > 0; h = ((h-1)/3)) {
for (int i = h; i < array.length; i++) {
for (int k = i; k > h - 1; k -= h) {
if (array[k] < array[k - h]) {
temp = array[k];
array[k] = array[k - h];
array[k - h] = temp;
}
}
}
}
System.out.print("Shell Sort: " + "\t");
System.out.println(Arrays.toString(array));
}
}
5 快速排序
快速排序 quick sort
取出一個基準數，大的放右邊，小的放左邊，直到各區間只有一個數。
import java.util.Arrays;
public class Code05QuickSort {
// public static void main(String[] args) {
public void quickSort() {
int[] array = {24, 69, 80, 57, 13, 234, 545, 57, 0, 4};
int start = 0;
int end = array.length-1;
quickSort(array, start, end);
System.out.print("Quick Sort: " + "\t");
System.out.println(Arrays.toString(array));
}
public static void quickSort(int[] array, int start, int end){
if (start < end){
int index = getIndex(array,start,end);
quickSort(array, start, index - 1);
quickSort(array, index + 1,end);
}
}
private static int getIndex(int[] arr, int start, int end){
int i = start;
int j = end;
int x = arr[i];
while (i < j){
while (i < j && arr[j] >= x){
j--;
}
if (i < j){
arr[i] = arr[j];
i++;
}
while (i < j && arr[i] < x){
i++;
}
if (i < j){
arr[j] = arr[i];
j--;
}
}
arr[i] = x;
return i;
}
}
6 歸併排序
歸併排序 merge sort
拆分至子序列有序，兩兩歸併。
import java.util.Arrays;
public class Code06MergeSort {
// public static void main(String[] args) {
public void mergeSort() {
int[] array = {24, 69, 80, 57, 13, 234, 545, 57, 0, 4};
process(array,0,array.length -1);
System.out.print("Merge Sort: " + "\t");
System.out.println(Arrays.toString(array));
}
public static void process(int[] array, int startIndex, int endIndex){
int centerIndex = (startIndex + endIndex)/2;
if (startIndex < endIndex){
process(array, startIndex, centerIndex);
process(array,centerIndex +1, endIndex);
merge(array, startIndex, centerIndex,endIndex);
}
}
public static void merge(int[] array, int startIndex, int centerIndex, int endIndex){
int [] tempArr = new int[endIndex - startIndex + 1];
int i = startIndex;
int j = centerIndex +1;
int index = 0;
while (i <= centerIndex && j<= endIndex){
if (array[i] <= array[j]){
tempArr[index] = array[i];
i++;
}else{
tempArr[index] = array[j];
j++;
}
index++;
}
while (i <= centerIndex){
tempArr[index] = array[i];
i++;
index++;
}
while (j <= endIndex){
tempArr[index] = array[j];
j++;
index++;
}
for (int i1 = 0; i1 < tempArr.length; i1++) {
array[startIndex + i1] = tempArr[i1];
}
}
}
7 基數排序
基數排序(桶排序) radix sort
依次根據 個位、十位、百位...上的數字進行排序（首先要找出最大值）
import java.util.Arrays;
public class Code07RadixSort {
// public static void main(String[] args) {
public void radixSort() {
int[] array = {24, 69, 80, 57, 13, 234, 545, 57, 0, 4};
sort(array);
System.out.print("Radix Sort: " + "\t");
System.out.println(Arrays.toString(array));
}
private static void sort(int[] array) {
int [][] tempArr = new int[10][array.length];
int[] counts = new int[10];
int max = getMax(array);
int len = String.valueOf(max).length();
for (int i = 0, n = 1; i < len; i++, n *= 10) {
for (int i1 = 0; i1 < array.length; i1++) {
int remainder = array[i1]/n%10;
tempArr[remainder][counts[remainder]++] = array[i1];
}
// 取出桶中的元素
int index = 0;
for (int k = 0; k < counts.length; k++) {
if (counts[k] != 0){
for (int h = 0; h < counts[k]; h++) {
array[index] = tempArr[k][h];
index++;
}
counts[k] = 0; // 清除上一次的統計
}
}
}
}
private static int getMax(int[] array) {
int max = array[0];
for (int i = 0; i < array.length; i++) {
if (array[i] > max){
max = array[i];
}
}
return max;
}
}
8 堆排序
堆排序 heap sort
先把陣列變為一個大頂堆，再把根元素和最後一個元素進行調換
import java.util.Arrays;
public class Code08HeapSort {
// public static void main(String[] args) {
public void heapSort() {
// 升序大頂堆， 降序小頂堆
int[] array = {24, 69, 80, 57, 13, 234, 545, 57, 0, 4};
int startIndex = (array.length-1)/2;
for (int i = startIndex;i >= 0;i--){
toMaxHeap(array, array.length,i);
}
// 經過上面的步驟，已經把陣列變為一個大頂堆，把根元素和最後一個元素進行調換
for (int i = array.length - 1;i > 0; i--) {
int t = array[0];
array[0] = array[i];
array[i] = t;
// 換完之後，再把剩餘元素調成大頂堆
toMaxHeap(array, i, 0);
}
System.out.print("Heap Sort: " + "\t");
System.out.println(Arrays.toString(array));
}
private static void toMaxHeap(int[] array, int size, int index) {
int leftNodeIndex = index * 2 + 1;
int rightNodeIndex = index * 2 + 2;
int maxIndex = index;
if (leftNodeIndex < size && array[leftNodeIndex] > array[maxIndex]){
maxIndex = leftNodeIndex;
}
if (rightNodeIndex < size && array[rightNodeIndex] > array[maxIndex]){
maxIndex = rightNodeIndex;
}
if (maxIndex != index){
int t = array[maxIndex];
array[maxIndex] = array[index];
array[index] = t;
toMaxHeap(array, size, maxIndex);
}
}
}