七大排序是要会写代码的哦

一、冒泡排序：（两两比较，大的放后面，每次得出最大值放在最后）
性能分析

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

二、选择排序：每次选出最小值，需要记录最小值和最小值的位置

public static void SelectSort(int[] array){
    for(int i=0;i<array.length;i++) {
        //无序区间[i,array,lenth)
        int minIndex = i;
        for (int j = i + 1; j < array.length; j++) {
            if (array[j] > array[minIndex]) {
                minIndex = j;
            }
        }
        int temp = array[i];
        array[i] = array[minIndex];
        array[minIndex] = temp;
    }
}

三、插入排序：跟扑克牌差不多，一直取新的元素往有序的队列里面插

public static void insertSort0(int[] array) {
    for (int i = 1; i < array.length; i++) {
        // 有序   [0, i)
        // 无序   [i, array.length)
        int key = array[i];
        int j;
        for (j = i - 1; j >= 0 && array[j] > key; j--) {
            array[j + 1] = array[j];
        }
        array[j + 1] = key;
    }
}

四、希尔排序：将一列数不停的对半分或者除3加1，得到间隔数n，相隔n的两个数比较，不断缩小n,直到等于1，进行插入排序

public static void shellSort(int[] array){
    int gap=array.length;
    while(gap!=0) {
        gap=gap/2;
    }
    for (int i = gap; i < array.length; i++) { 
        int key = array[i];
        int j;
        for (j = i - gap; j >= 0 && array[j] > key; j -= gap) {
            array[j + gap] = array[j];
        }
        array[j + gap] = key;
        if(gap==1){
            break;
        }
    }

五、归并排序：将一列数不断地对半分，直到每个小组相邻个数为1时停止，然后相邻元素间排序在归并到一起

public static void mergeSort3(int[] array) {
    for (int i = 1; i < array.length; i = i * 2) {
        for (int j = 0; j < array.length; j = j + 2 * i) {
            int low = j;
            int mid = j + i;
            if (mid >= array.length) {
                continue;
            }
            int high = mid + i;
            if (high > array.length) {
                high = array.length;
            }
            merge(array, low, mid, high);
        }
    }
}
 private static void merge(int[] a, int low, int mid, int high) {
        int length = high - low;
        int[] extra = new int[length];

        int i = low;
        int j = mid;
        int k = 0;

        while (i < mid && j < high) {
            if (a[i] <= a[j]) {
                extra[k++] = a[i++];
            } else {
                extra[k++] = a[j++];
            }
        }
        while (i < mid) {
            extra[k++] = a[i++];
        }
        while (j < high) {
            extra[k++] = a[j++];
        }
        for (int x = 0; x < length; x++) {
            a[low + x] = extra[x];
        }
    }
}

六、快速排序：找一个基准值，比基准值小的放到左边，大的放到右边，采用分治思想对左右两个小区间按同样的方式处理，直到小区间长度为1（已有序）或为0（没有数据）

public static void quickSort(int[] arr,int low,int high) {
    int i, j, temp, t;
    if (low > high) {
        return;
    }
    i = low;
    j = high;
    temp = arr[low];
    while (i < j) {
        while (temp <= arr[j] && i < j) {
            j--;
        }
        while (temp >= arr[i] && i < j) {
            i++;
        }
        if(i<j) {
            t = arr[j];
            arr[j] = arr[i];
            arr[i] = t;
        }
    }
    arr[low]=arr[i];
    arr[i]=temp;
    quickSort(arr,low,j-1);
    quickSort(arr,j+1,high);
}

七、堆排序：基本原理也是选择排序，只是通过堆来选择无序区间最大的数，排升序建大堆，排降序建小堆

private static void createBigHeap(int[] array) {
        for (int i = (array.length - 2) / 2; i >= 0; i--) {
            shiftDown(array, array.length, i);
        }
    }

    private static void shiftDown(int[] array, int size, int i) {
        while (2 * i + 1 < size) {
            int max = 2 * i + 1;
            if (max + 1 < size) {
                if (array[max + 1] > array[max]) {
                    max = max + 1;
                }
            }

            if (array[i] >= array[max]) {
                return;
            }
            swap(array, i, max);
            i = max;
        }
    }
    private static void swap(int[] array, int i, int j) {
        int t = array[i];
        array[i] = array[j];
        array[j] = t;
    }
}

七大排序的性能分析比较