常用排序讲解，java实现

冒泡排序

两重for循环，第一重for循环控制比较的轮数，第二重for循环控制比较的元素。每一轮比较后，将未排序序列的最大值放到序列最后

public static void bubbleSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) { //n个数只需要比较n - 1轮
        for (int j = 0; j < n - i - 1; j++) { //n-i-1的缘故是已经排好了i个，-1是因为比较
            if (arr[i] > arr[i + 1]) {    //arr[i]和[arr[i + 1]]
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }     
        }
    }

}

选择排序

选择排序和冒泡排序的不同点在于每次比较过后，将最小值放在未排序的序列部分最前端。另外，每一轮比较，选择排序只交换一轮。

public static void selectSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        int min = i; //用来记录最小值对应的数组索引
        for(int j = j + 1; j < n; j++) {
            if (arr[j] < arr[min]) {
                min = j;
            }
        }
        int temp = arr[i];
        arr[i] = arr[min];
        arr[min] = temp;
    } 

}

插入排序

插入排序将未排序的元素插入到已排序的序列中，得到一个新的数组元素+1的序列。

插入排序for循环索引从1开始，内侧的while循环从右向左遍历，直到第一次出现小于等于要插入元素值的数组元素。

public static void insertSort(int[] arr) {
    int n = arr.length;
    for (int i = 1; i < n; i++) { //数组下标为0的元素前方没有元素，不用插入
        int key = arr[i];      //用key保存需要插入的元素
        int j = i - 1;
        while (arr[j] > key && j >= 0) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

快速排序

快速排序选择一个基准值，将数组分成左右两个子数组，左边数组的值全小于基准值，右边数组的值都大于基准值，然后递归调用自身。通常基准值选取为最后一个元素。

public static void quickSort(int[] arr, int low, int high) {
    if (low < high) {
        int index = partition(arr, low, high);
        quickSort(arr, low, index - 1);
        quickSort(arr, index + 1, high);
    }
}
public static int partition(int[] arr, int low, int high) {
    int pivot = arr[high];
    int j = low;
    for (int i = low; i < high; i++) {
        if (arr[i] < pivot) {
            swap(arr, i, j);
            j++;
        }
    }
    swap(arr, j, high);
    return j;
}
public static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

归并排序

归并排序，利用中间值，将数组拆分为两个子数组，递归调用自身，然后合并子树组。

public static void mergeSort(int[] arr, int left, int right) {
    if (left < right) { // 递归的终止条件，只有一个元素时终止递归
        int mid = left + (right - left) / 2;  //这么写mid的好处可以防止溢出
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);
        merge(arr,left,right, mid);
    }
}
public static void merge(inr[] arr, int left, int right, int mid) {
    int n1 = mid - left + 1;
    int n2 = right - mid;
    int[] L = new int[mid - left + 1];
    int[] R = new int[right - mid];
    for (int i = 0; i < n1; i++) {
        L[i] = arr[left + i];
    }//将两个子数组的值分别赋值给两个临时数组
    for (int j = 0; j < n2; j++) {
        R[j] = arr[mid + 1 + j];
    }
    int i = 0, j = 0, k = 0; //i,j表示从对应数组赋值了多少元素给arr,k表示arr接收的元素个数
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k++] = L[i];
            i++;
        } else {
            arr[k++] = R[j++];
        }
    }
    while (i < n1) {
        arr[k++] = L[i++];
    }
    while (j < n2) {
        arr[k++] = R[j++];
    }
}

堆排序

堆排序的思路：初始化最大堆，然后将根节点和未排序部分的最后一个元素交换，调整堆。

public static void heapSort(int[] arr) {
    int n = arr.length;
    bulidMaxHeap(arr);
    for(int i = n - 1; i > 0; i--) { //最后一个元素不用排
        swap(arr, 0 , i);
        heapify(arr, i , 0); //将根节点与未排序部分的最后一个元素交换，让剩下的部分称为一个最大
//堆
    }
    
}

public static void buildMaxHeap(int[] arr) {
    int n = arr.length;
    for (int i = n / 2 - 1; i >= 0; i--) { //从第一个非叶子结点开始堆化，保证最终能得到一个最
//大堆
        heapify(arr,n,i);    
    }
}

public static void heapify(int[] arr, int n ,int i) {
    int largest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    if (left < n && arr[left] > arr[largest]) { //需要注意：left < n, right < n
        largest = left;
    }
    if (right < n && arr[right] > arr[largest] {
        largest = right;
    }
    if (largest != i) {
        swap(arr, largest, i);
        heapify(arr, n, largest); //保证交换后，剩余的部分也能构成最大堆的形式
    }
}
public static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}