各种排序算法总结

目录

快速排序

堆排序

归并排序

冒泡排序

插入排序

选择排序

希尔排序

1、快速排序

核心思想：以第一个元素为基准，记录基准元素t，用两个指针left，right分别指向两端，用基准元素 t 先与right比较，right从后往前寻找比 t 小的元素，填入 left 所在位置，然后left + 1，left从前往后寻找比 t 大的元素，填入 right 所在位置，然后rihgt - 1；重复以上过程。直至left == right，将 t 放入left的位置。然后递归 left 左右两边。

public void quickSort(int[] nums, int start, int end){
    if ( start >= end ) return;
    int left = start, right = end;
    int tem = nums[left];
    while ( left < right ) {
        while ( left < right && nums[right] > tem )  right--;
        if ( left < right ) {
            nums[left] = nums[right];
            left++;
        }
        while ( left < right && nums[left] < tem ) left++;
        if ( left < right ) {
            nums[right] = nums[left];
            right--;
        }
    }
    nums[left] = tem;
    quickSort ( nums, start, left - 1);
    quickSort ( nums, left + 1, end );
}

2、堆排序

        堆是一个完全二叉树。当根节点下标为0开始计数时，如果父节点的位置为k，则两个子节点的位置分别为：2k +1，2k + 2；当结点共N个时，则最后一个非叶子结点为N/2 - 1 ; 

堆排序的过程(升序、大根堆)：

1. 将长度为n的序列构造为大根堆
2. 将根结点与最后一个结点n-1进行交换
3. 对交换后的堆重新进行调整，调整为大根堆
4. 重复步骤2，3，此时最后一个结点下标为 n-2，因为最后一个元素已是最大元素。

public void heapSort(int arr[], int n){
    //构建大根堆，从最后一个非叶子结点开始
    for(int i = n/2-1; i >= 0; i--) swim(arr, i, n-1);
    for(int i = n-1; i > 0; i--){
        //将根节点(最大值)进行排序，与最后一个结点交换位置，
        temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
        //将交换完的剩余i个结点调整为大根堆。
        swim(arr,0,i - 1);
    }
}
public void swim(int[] arr, int i, int end){
    int temp = arr[i];
    int j = 2*i + 1; //获得左孩子节点的位置
    while(j <= end){
        //如果右结点大于左节点的话，拿右节点与父节点比较
        if(j < end && arr[j] < arr[j+1]) j++; 
        //如果子节点大于父节点，进行交换
        if(temp < arr[j]){ 
            arr[i] = arr[j];
            //继续与子节点的子节点进行比较，直至找到合适位置。
            i = j;      
            j = 2*i + 1;
        }else break;
        arr[i] = temp;
    }
}

3、归并排序

思想：归并排序是典型的分治策略。先将数组不断的 /2 分成子序列，直至不可再分，然后将子序列合并，在合并的过程中进行排序。

public void mergeSort(int[] nums, int left, int right){
    if(left >= right) return;
    int mid = (left + right) / 2;
    mergeSort(nums, left, mid);
    mergeSort(nums, mid + 1, right);
    merge(arr, left, mid, right);
}
public void merge(int[] nums, int left, int mid, int right){
    int n1 = mid - left + 1;
    int n2 = right - mid;
    int[] arrL = new int[n1];
    int[] arrR = new int[n2];
    for(int i = 0; i < n1; i++) arrL[i] = nums[left + i];
    for(int i = 0; i < n2; i++) arrR[i] = nums[mid + 1 + i];
    
    int i = 0, j = 0, k = low;
    while(i < n1 && j < n2){
        if(arrL[i] <= arrR[j]) nums[k] = arrL[i++];
        else nums[k] = arrR[j++];
        k++;
    }
    while(i < n1) nums[k++] = arrL[i++];
    while(j < n2) nums[k++] = arrR[j++];
}

4、冒泡排序

思想：从左到右不断交换相邻之间逆序的元素，在一轮循环之后，可以让未排序的最大元素交换到右侧。在一轮循环中，如果没有发生交换，那么说明数组是有序的，可以直接退出。

public void sort( int[] nums) {
    int N = nums.length;
    boolean isSorted = true;
    for (int i = N - 1; i > 0 && isSorted; i--) {
        isSorted = flase;
         for (int j = 0; j < i; j++) {
             if ( nums[j] < nums[j+1] ) {
                 isSorted = true;
                 swap(nums, j, j + 1);
                }
         }
    }
}

5、插入排序

思想： 依次选择一个未排序的元素，与前面排好序的元素，从后往前比较，找到合适的位置插入。

    public void sort(int [] nums) {
        int N = nums.length;
        for (int i = 1; i < N; i++) {
            for (int j = i; j > 0 && nums[j] < nums[j - 1]; j--) {
                swap(nums, j, j - 1);
            }
        }

6、选择排序

思想：从数组中选择最小的元素，将它与数组的第一个元素交换位置。再从数组剩下的元素中选择出最小的元素，将它与数组第二个元素交换位置，不断进行这样的操作，直到将整个数组排序。

public void sort(int [] nums) {
        int N = nums.length;
        for (int i = 0; i < N - 1; i++) {
            int min = i;
            for (int j = i + 1; j < N; j++) {
                if (nums[j] < nums[min])) {
                    min = j;
                }
            }
            swap(nums, i, min);
        }
    }

7、希尔排序

思想：设置增量分为子序列进行直接插入排序，直至增量为1；

public void sort(int[] nums) {
  int N = nums.length;
  for (int h = n/2; h > 0; h /= 2) {
    for (int i = h; i < N; i++) {
       for (int j = i; j >= h && nums[j] < nums[j - h]; j -= h) {
                    swap(nums, j, j - h);
            }
        }
    }
}

 总结：