八大基本排序代码（数组）

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);
        }

    }
}

西部开源视频教程