八大排序算法

排序的时间复杂度

排序代码

直接插入排序

import java.util.Arrays;

/**
 * Created by ruansh on 2019-6-7
 */

public class selectionSort {

    public static void main(String[] args) {
        int[] a = {9, 7, 5, 3, 1};
        System.out.println(Arrays.toString(a));
        sort(a);
        System.out.println(Arrays.toString(a));
    }

    public static void sort(int[] a){
        for(int i = 0; i < a.length - 1; i++){
            int min = i;
            for(int j = i + 1; j < a.length; j++){
                min = a[j] < a[i]? j: min;
            }
            if(min != i){
                swap(a, i, min);
            }
        }
    }

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

希尔排序

import java.util.Arrays;

/**
 * Created by ruansh on 2019-6-8
 */

public class shellSort {

    public static void main(String[] args) {
        int[] a = {9, 7, 5, 3, 1};
        System.out.println(Arrays.toString(a));
        sort(a);
        System.out.println(Arrays.toString(a));
    }

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

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

直接选择排序

import java.util.Arrays;

/**
 * Created by ruansh on 2019-6-7
 */

public class selectionSort {

    public static void main(String[] args) {
        int[] a = {9, 7, 5, 3, 1};
        System.out.println(Arrays.toString(a));
        sort(a);
        System.out.println(Arrays.toString(a));
    }

    public static void sort(int[] a){
        for(int i = 0; i < a.length - 1; i++){
            int min = i;
            for(int j = i + 1; j < a.length; j++){
                min = a[j] < a[i]? j: min;
            }
            if(min != i){
                swap(a, i, min);
            }
        }
    }

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

堆排序

import java.util.Arrays;

/**
 * Created by ruansh on 2019-6-8
 */

public class heapSort {

    public static void main(String[] args) {
        int[] a = {9, 7, 15, 3, 1};
        System.out.println(Arrays.toString(a));
        heapSort(a, a.length);
        System.out.println(Arrays.toString(a));
    }

    public static void heapify(int[] a, int i, int len){
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        int largest = i;
        if(left < len && a[left] > a[largest]){
            largest = left;
        }
        if(right < len && a[right] > a[largest]){
            largest = right;
        }
        if(largest != i){
            swap(a, i, largest);
            heapify(a, largest, len);
        }
    }

    public static void heapSort(int[] a, int len){
        for(int i = len/2 - 1; i >= 0; i--){
            heapify(a, i, len);
        }
        for(int i = len - 1; i > 0; i--){
            swap(a, 0, i);
            len--;
            heapify(a, 0, len);
        }
    }

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

冒泡排序

import java.util.Arrays;

/**
 * Created by ruansh on 2019-6-8
 */

public class bubbleSort {

    public static void main(String[] args) {
        int[] a = {9, 7, 5, 3, 1};
        System.out.println(Arrays.toString(a));
        sort(a);
        System.out.println(Arrays.toString(a));
    }

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

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

快速排序

import java.util.Arrays;

/**
 * Created by ruansh on 2019-6-7
 */

public class quickSort {

    public static void main(String[] args) {
        int[] a = {9, 7, 5, 3, 1};
        System.out.println(Arrays.toString(a));
        sort(a, 0, a.length - 1);
        System.out.println(Arrays.toString(a));
    }

    public static void sort(int[] a, int low, int high){
        if(a == null || low >= high){
            return;
        }
        int i = low, j = high, key = a[low];
        while(i < j){
            while (i < j && a[j] >= key){
                j--;
            }
            if(i < j){
                a[i++] = a[j];
            }
            while (i < j && a[i] <= key){
                i++;
            }
            if(i < j){
                a[j--] = a[i];
            }
        }
        a[i] = key;
        sort(a, low, i - 1);
        sort(a, i + 1, high);
    }

}

归并排序

import java.util.Arrays;

/**
 * Created by ruansh on 2019-6-7
 */

public class mergeSort {

    public static void main(String[] args) {
        int[] a = {9, 7, 5, 3, 1};
        System.out.println(Arrays.toString(a));
        int[] b =sort(a, 0, a.length - 1);
        System.out.println(Arrays.toString(b));
    }

    public static int[] sort(int[] a, int low, int high){
        if(low == high){
            return new int[]{a[low]};
        }
        int mid = low + (high - low)/2;
        int[] leftArr = sort(a, low, mid);
        int[] rightArr = sort(a, mid + 1, high);
        int[] newArr = new int[leftArr.length + rightArr.length];

        int m = 0, i = 0, j = 0;
        while(i < leftArr.length && j < rightArr.length){
            newArr[m++] = leftArr[i] < rightArr[j]?leftArr[i++]:rightArr[j++];
        }
        while(i < leftArr.length){
            newArr[m++] = leftArr[i++];
        }
        while (j < rightArr.length){
            newArr[m++] = rightArr[j++];
        }
        return newArr;

    }

}

基数排序

import java.util.Arrays;

/**
 * Created by ruansh on 2019-6-23
 */


public class radixSort {
    private static void radixSort(int[] array,int d)
    {
        int n=1;//代表位数对应的数：1,10,100...
        int k=0;//保存每一位排序后的结果用于下一位的排序输入
        int length=array.length;
        int[][] bucket=new int[10][length];//排序桶用于保存每次排序后的结果，这一位上排序结果相同的数字放在同一个桶里
        int[] order=new int[length];//用于保存每个桶里有多少个数字
        while(n<d)
        {
            for(int num:array) //将数组array里的每个数字放在相应的桶里
            {
                int digit=(num/n)%10;
                bucket[digit][order[digit]]=num;
                order[digit]++;
            }
            for(int i=0;i<length;i++)//将前一个循环生成的桶里的数据覆盖到原数组中用于保存这一位的排序结果
            {
                if(order[i]!=0)//这个桶里有数据，从上到下遍历这个桶并将数据保存到原数组中
                {
                    for(int j=0;j<order[i];j++)
                    {
                        array[k]=bucket[i][j];
                        k++;
                    }
                }
                order[i]=0;//将桶里计数器置0，用于下一次位排序
            }
            n*=10;
            k=0;//将k置0，用于下一轮保存位排序结果
        }

    }
    public static void main(String[] args) {
        int[] nums = new int[]{73,22, 93, 43, 55, 14, 28, 65, 39, 81};
        radixSort(nums, 100);
        System.out.println(Arrays.toString(nums));
    }
}