排序汇总

奇偶交换排序

​ 分为奇交换和偶交换，**奇交换，总是比较奇数索引以及其相邻的后续元素。而偶交换总是比较偶数索引和其相邻的后续元素。**并且，奇交换和偶交换会成对出现，这样才能保证比较和交换涉及到数组中的每一个元素。

算法步骤

1. 选取所有奇数列的元素与其右侧相邻的元素进行比较，将较小的元素排序在前面；
2. 选取所有偶数列的元素与其右侧相邻的元素进行比较，将较小的元素排序在前面；
3. 重复前面两步，直到所有序列有序为止。

//串行实现
public void oddEvenSort(int[] arr){
    int exgFlag = 1; //标记是否交换过数字
    int start = 0;
    while (exgFlag == 1 || start == 1){
        exgFlag = 0;
        for (int i = start; i < arr.length - 1 ; i+=2){
            if (arr[i] > arr[i + 1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
                exgFlag = 1;
            }
        }
        if (start == 0){
            start = 1;
        }else{
            start = 0;
        }
    }
}

插入排序

public static void insertSort(int[] arr){
    int length = arr.length;
    for(int i = 1; i < arr.length; i++){
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && key < arr[j]){
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

希尔排序

//希尔排序串行实现
public static void shellSort(int[] arr){
    for (int h = arr.length / 2 ; h > 0 ; h /= 2){
        for (int i = h ; i < arr.length; i ++){
            int key = arr[i];
            int j = i - h;
            while (j >= 0 && key < arr[j]){
                arr[j + h] = arr[j];
                j -= h;
            }
            arr[j + h] = key;
        }
    }
}

冒泡排序

//冒泡排序
public static void bubbleSort(int[] arr){
    for(int i = 0; i < arr.length - 1; i++){//外层循环控制排序趟数
        for(int j = 0; j < arr.length - 1 - i; j++){//内层循环控制每一趟排序多少次
            if(arr[j] > arr[j + 1]){
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    } 
}

选择排序

public static void selectSort(int[] arr){
    for(int i = 0 ; i < arr.length; i++){  //进行n趟操作
        int k = i;
        for(int j = i ; j <= n ; j++){     //选出【i, n】中最小的元素，下标为k
            if(arr[j] < arr[k]){
                k = j;
            }
        }
        int temp = arr[i];
        arr[i] = arr[k];
        arr[k] = temp;
    }
}

归并排序

https://www.cnblogs.com/skywang12345/p/3602369.html

复制代码
/*
 * 将一个数组中的两个相邻有序区间合并成一个
 *
 * 参数说明：
 *     a -- 包含两个有序区间的数组
 *     start -- 第1个有序区间的起始地址。
 *     mid   -- 第1个有序区间的结束地址。也是第2个有序区间的起始地址。
 *     end   -- 第2个有序区间的结束地址。
 */
public void merge(int a[], int start, int mid, int end)
{
    int[] tmp = new int[end - start + 1];    // tmp是汇总2个有序区的临时区域
    int i = start;            // 第1个有序区的索引
    int j = mid + 1;        // 第2个有序区的索引
    int k = 0;                // 临时区域的索引

    while(i <= mid && j <= end)
    {
        if (a[i] <= a[j])
            tmp[k++] = a[i++];
        else
            tmp[k++] = a[j++];
    }

    while(i <= mid)
        tmp[k++] = a[i++];
    while(j <= end)
        tmp[k++] = a[j++];

    // 将排序后的元素，全部都整合到数组a中。
    for (i = 0; i < k; i++)
        a[start + i] = tmp[i];
}

/*
 * 归并排序(从上往下)
 *
 * 参数说明：
 *     a -- 待排序的数组
 *     start -- 数组的起始地址
 *     endi -- 数组的结束地址
 */
public void merge_sort_up2down(int a[], int start, int end)
{
    if(a == null || start >= end)
        return ;

    int mid = (end + start)/2;
    merge_sort_up2down(a, start, mid); // 递归排序a[start...mid]
    merge_sort_up2down(a, mid + 1, end); // 递归排序a[mid+1...end]
    // a[start...mid] 和 a[mid...end]是两个有序空间，
    // 将它们排序成一个有序空间a[start...end]
    merge(a, start, mid, end);
}

快速排序

int Partition(int A[], int left, int right){
    int temp = A[left];
    while(left < right){
        while(left < right && A[right] > temp){
              right--;  
        } 
        A[left] = A[right];
        while(left < right && A[left] <= temp){
              left++;
        }
        A[right] = A[left];
    }
    A[left] = temp;
    return left;
}


void quickSort(int A[], int left, int right){
    if(left < right){
        int pos = Partition(A, left, right);
        quickSort(A, left, pos - 1);
        quickSort(A, pos + 1, right);
    }
}