数据结构经典排序算法汇总整理

一、冒泡排序

1、思想以及时间复杂度：

冒泡排序就是每次确定最后一位数，经过n趟排序后序列有序，T(n) = O(n²)

2、算法实现：

package utils;

import java.util.Arrays;

/**
 * @Author m.kong
 * @Date 2020/12/15 上午10:36
 * @Version 1.0
 */
public class BubbleSort {

    public static void bubbleSort(int[] arr){
        for(int i = arr.length - 1; i >=0; i--){
            for(int j = 0; j < i; j++){
                if(arr[j + 1] < arr[j]){
                    swap(arr, j+1, j);
                }
            }
        }
    }

    public static void swap(int[] arr, int m, int n){
        int tmp = arr[m];
        arr[m] = arr[n];
        arr[n] = tmp;
    }

    public static void main(String[] args) {
        int[] arr = {1, 4, 1, 2, 5, 3, 7};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }

}

二、选择排序

1、思想以及时间复杂度：

选择排序就是每次确定第一位数，经过n趟排序后序列有序，T(n) = O(n²)

2、算法实现：

package utils;

import java.util.Arrays;

/**
 * @Author m.kong
 * @Date 2020/12/15 上午10:48
 * @Version 1.0
 */
public class SelectionSort {

    public static void selectSort(int[] arr){
        if (arr == null || arr.length < 2) {
            return;
        }

        int minIndex;
        for(int i = 0; i < arr.length; i++){
            minIndex = i;
            for(int j = i + 1; j < arr.length; j++)
            {
                minIndex = arr[j] < arr[minIndex] ? j : minIndex;
            }
            swap(arr, i, minIndex);
        }
    }

    public static void swap(int[] arr, int m, int n){
        int tmp = arr[m];
        arr[m] = arr[n];
        arr[n] = tmp;
    }

    public static void main(String[] args) {
        int[] arr = {2,3,3,4,1,9,6,3};
        selectSort(arr);
        System.out.println(Arrays.toString(arr));
    }

}

三、插入排序

1、思想以及时间复杂度：

插入排序就是每次从后面依照顺序选择一个数据插入到前面已有到顺序序列中，经过n - 1趟排列有序。时间复杂度为：T(n) = O(n²)

2、算法实现：

package utils;

import java.util.Arrays;

/**
 * @Author m.kong
 * @Date 2020/12/15 上午11:29
 * @Version 1.0
 */
public class InsertionSort {

    public static void insertionSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        for (int i = 1; i < arr.length; i++) {
            for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
                swap(arr, j, j + 1);
            }
        }
    }

    public static void swap(int[] arr, int i, int j) {
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }

    public static void main(String[] args) {
        int[] arr  = {1,2,5,3,8,6,4,23,22,11};
        insertionSort(arr);
        System.out.println(Arrays.toString(arr));
    }

}

四、归并排序

1、思想以及时间复杂度：

插入排序就是每次从后面依照顺序选择一个数据插入到前面已有到顺序序列中，经过n - 1趟排列有序。时间复杂度为：T(n) = O(nlog₂n)

2、算法实现：

package utils;

import java.util.Arrays;

/**
 * @Author m.kong
 * @Date 2020/12/15 下午1:49
 * @Version 1.0
 */
public class MergeSort {

    public static void initMergeSort(int[] arr){
        if(arr == null || arr.length < 2){
            return;
        }
        mergeSort(arr, 0, arr.length - 1);
    }

    public static void mergeSort(int[] arr, int l, int r){
        if(l == r){
            return;
        }
        int mid  = (l + r)/2;
        mergeSort(arr, l, mid);
        mergeSort(arr, mid + 1, r);
        merge(arr, l, mid, r);
    }

    public static void merge(int[] arr, int l, int m, int r){
        int[] help = new int[r - l + 1];
        int i = 0;
        int p1 = l;
        int p2 = m + 1;
        while (p1 <= m && p2 <= r) {
            help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        }
        while (p1 <= m) {
            help[i++] = arr[p1++];
        }
        while (p2 <= r) {
            help[i++] = arr[p2++];
        }
        for (i = 0; i < help.length; i++) {
            arr[l + i] = help[i];
        }
    }

    public static void main(String[] args) {
        int[] arr = {1,7,4,2,45,5,23,46,0,3};
        initMergeSort(arr);
        System.out.println(Arrays.toString(arr));
    }

}