java经常使用7种排序算法-选择、归并...

时间 2019-11-13

原文原文链接

/**
 * 一、冒泡排序
 * <p>
 * 原理：<p>循环n-1次，每次循环找到当次循环最大/最小元素</p>
 * 实现：<p>外层控制循环次数(n-1),内层对相邻元素进行比较交换</p>
 * 复杂度：{[@code](https://my.oschina.net/codeo) O(n^2)}
 */
private static void bubbleSort(int[] arr) {
    //外层控制循环次数
    for (int m = 0; m < arr.length - 1; m++) {

        //内层比较交换
        for (int n = 0; n < arr.length - 1 - m; n++) {
            if (arr[n] > arr[n + 1]) {
                int tmp = arr[n];
                arr[n] = arr[n + 1];
                arr[n + 1] = tmp;
            }
        }
    }
}

/**
 * 二、选择排序
 * <p>
 * 原理：<p>循环n次，内部循环每次找到当前循环元素范围内最大/最小下标，如发生改变，则交换数值</p>
 * 实现：<p>外层控制循环次数(n-1),内层对相邻元素进行比较、记录下标、交换数值</p>
 * 优缺点：对比冒泡排序，少了每次对比后的交互，只在每次外层循环后交互，优于冒泡
 * 复杂度：{[@code](https://my.oschina.net/codeo) O(n^2)}
 */
public static void selectSort(int[] arr) {
    //外层控制次数
    for (int i = 0; i < arr.length; i++) {
        int min_index = i;
        //内层控制元素范围并实现对比、记录、交换
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[min_index]) {
                min_index = j;
            }
        }
        //若是最大/小index发生改变，则交换
        if (i != min_index) {
            int temp = arr[i];
            arr[i] = arr[min_index];
            arr[min_index] = temp;
        }
    }
}

/**
 * 三、插入排序
 * <p>
 * 原理：<p>依次将原数组每一个元素与该元素以前的元素对比，根据排序规则插入到合适位置</p>
 * 实现：<p>外层循环控制对哪一个下标的元素进行处理，内部循环将次元素与其以前的元素进行对比，找到正确的位置</p>
 * 优缺点：在数组元素随机排列的状况下，插入排序优于冒泡和选择
 * 复杂度：{[@code](https://my.oschina.net/codeo) O(n^2)}
 */
private static void insertSort(int[] arr) {
    for (int i = 1; i < arr.length; i++) {
        //将当前元素与其以前的元素进行对比、交换
        for (int j = i; j > 0; j--) {
            if (arr[j] < arr[j - 1]) {
                //交换
                int temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;
            } else {
                break;
            }
        }
    }
}

/**
 * 四、希尔排序
 * <p>
 * 原理：
 * <p>
 * 希尔排序也是一种插入排序，它将数组以增量进行增量组，而后分别进行插入排序，不断缩小增量，直至增量为1，数组即排序完成，建议增量为{n/2,(n/2)/2...1}，称为希尔增量
 * </p>
 * 实现：<p>最外层循环控制增量，中层负责对当前增量下的元素进行循环处理，内层使用插入排序进行排序</p>
 * 优缺点：在数组元素随机排列的状况下，插入排序优于冒泡和选择
 * 复杂度：在{n/2,(n/2)/2...1}增量序列下为{[@code](https://my.oschina.net/codeo) O(n^2)|，通过优化后能够达到{[@code](https://my.oschina.net/codeo) O(n^2/3)}
 */
public static void shellSort(int[] arr) {

    //外层控制增量
    for (int add = arr.length / 2; add > 0; add /= 2) {
        //从增量大小处开始对每组进行排序操做，由于在增量处恰好每一组都出现了一个元素
        for (int i = add; i < arr.length; i++) {
            //插入排序操做，与该组该元素以前元素进行对比、交换
            for (int j = i; j > 0; j -= add) {
                //判断的时候注意j-add>=0，而不是>0,这样才能确保第0个元素也能被排序进来
                if (j - add >= 0 && arr[j] < arr[j - add]) {
                    //交换
                    int temp = arr[j];
                    arr[j] = arr[j - add];
                    arr[j - add] = temp;
                } else {
                    break;
                }
            }
        }
    }
}

/**
 * 五、归并排序
 * <p>
 * 原理：<p>将原数组一直二分下去，直到不能再分，对分离的每个部分，从新组合起来，组合的时候对相邻部分按照顺序依次排序(借助临时数组重组后拷贝)</p>
 * 实现：<p>使用递归实现，在对相邻节点进行合并的时候，借助临时数组进行存储和拷贝</p>
 * 优缺点：利用彻底二叉树，最好，最坏，平均时间复杂度均为O(nlogn)
 * 复杂度：{@code O(nlogn)}
 */
public static void mergeSort(int[] arr) {
    //临时数组，避免递归中频繁开辟空间
    int[] temp = new int[arr.length];
    doMergeSort(arr, 0, arr.length - 1, temp);


}

/**
 * @param arr   排序数组
 * @param left  最左边index
 * @param right 最右边index
 * @param temp  临时数组
 */
private static void doMergeSort(int[] arr, int left, int right, int[] temp) {
    //当元素不能再分时中止
    if (left < right) {
        int mid = (left + right) / 2;
        doMergeSort(arr, left, mid, temp);
        doMergeSort(arr, mid + 1, right, temp);

        int left_start_index = left;
        int rigth_start_index = mid + 1;
        int temp_index = 0;

        //先对比在两边数组都有数据的时候
        while (left_start_index <= mid && rigth_start_index <= right) {
            if (arr[left_start_index] < arr[rigth_start_index]) {
                temp[temp_index++] = arr[left_start_index++];
            } else {
                temp[temp_index++] = arr[rigth_start_index++];
            }
        }
        //考虑左还遗留元素
        while (left_start_index <= mid) {
            temp[temp_index++] = arr[left_start_index++];
        }

        //考虑右还遗留元素
        while (rigth_start_index <= right) {
            temp[temp_index++] = arr[rigth_start_index++];
        }

        //将临时数组元素拷贝进原数组
        int copy_index = 0;
        int arr_index = left;
        while (copy_index < right - left + 1) {
            arr[arr_index++] = temp[copy_index++];
        }

    }

}

/**
 * 六、快速排序-三数取中法
 * <p>
 * 原理：<p>首先对原数组的首中（枢纽）尾三个元素进行排序交换，而后将中值移动到紧邻尾元素的位置，对中间剩余的非首中尾元素分别从前(记下标为i)找到大于枢纽，尾(记下标为j)找到
 * 小于枢纽的值，若是配对成功则交换，当i>=j时，中止匹配，再将枢纽值与i(只可i不可j)值交换，再将该数组以i（此时为枢纽值）拆分为两个数组，递归进行此操做，直至排序完成
 * </p>
 * 实现：<p>先取得前、中、尾三数，再排序并把中移到紧邻尾的位置，将剩余元素以枢纽值划分配对交换，还原枢纽值，递归</p>
 * 复杂度：{@code O(nlogn)}
 */
private static void quickSort(int[] arr) {
    doQuickSort(arr, 0, arr.length - 1);
}


/**
 * @param arr   排序数组
 * @param left  左元素下标
 * @param right 右元素下标
 */
private static void doQuickSort(int[] arr, int left, int right) {
    if (left < right) {
        //取得首、中、尾并调整顺序
        int mid = (left + right) / 2;
        //左两数
        if (arr[left] > arr[mid]) {
            int temp = arr[left];
            arr[left] = arr[mid];
            arr[mid] = temp;
        }
        //右两数
        if (arr[mid] > arr[right]) {
            int temp = arr[mid];
            arr[mid] = arr[right];
            arr[right] = temp;
        }
        //左两数
        if (arr[left] > arr[mid]) {
            int temp = arr[left];
            arr[left] = arr[mid];
            arr[mid] = temp;
        }

        //将中值放到紧邻尾元素处
        int temp = arr[right - 1];
        arr[right - 1] = arr[mid];
        arr[mid] = temp;


        //真正的排序操做,若是left与right之间元素个数大于2个时才须要作拆分排序，其余状况在上面构建枢纽的时候就已经排序好了
        if (right - left > 2) {
            int flag = arr[right - 1];
            int left_index = left + 1;
            int right_index = right - 2;
            while (left_index <= right_index) {
                //大于枢纽值
                if (arr[left_index] > flag) {
                    if (arr[right_index] < flag) {
                        int temp1 = arr[left_index];
                        arr[left_index] = arr[right_index];
                        arr[right_index] = temp1;
                        left_index++;
                        right_index--;
                    } else {
                        right_index--;
                    }
                } else {
                    left_index++;
                }
            }

            //把枢纽值和left_index处值交换
            int temp2 = arr[left_index];
            arr[left_index] = flag;
            arr[right - 1] = temp2;

            //将两边的数组继递归处理
            doQuickSort(arr, left, left_index - 1);
            doQuickSort(arr, left_index + 1, right);

        }
    }
}

/**
 * 七、堆排序
 * <p>
 * 原理：<p>将数组构建为大顶堆或小顶堆，而后依次将顶元素存于数组，直至排序完成</p>
 * 实现：<p>构建大/小顶堆，交换元素</p>
 * 复杂度：{@code O(nlogn)}
 */
public static void heapSort(int[] arr) {
    //构建大顶堆
    for (int i = arr.length / 2 - 1; i >= 0; i--) {
        build(arr, i, arr.length);
    }
    //交换元素
    for (int j = arr.length - 1; j > 0; j--) {
        //交换
        int temp = arr[0];
        arr[0] = arr[j];
        arr[j] = temp;

        build(arr, 0, j);
    }

}

/**
 * 调整大顶堆（仅是调整过程，创建在大顶堆已构建的基础上）
 *
 * @param arr 数组
 * @param i   第一个非叶子节点下标
 */
public static void build(int[] arr, int i, int length) {
    int temp = arr[i];
    for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
        if (k + 1 < length && arr[k] < arr[k + 1]) {
            k++;
        }
        if (arr[k] > temp) {
            arr[i] = arr[k];
            i = k;
        } else {
            break;
        }
    }
    arr[i] = temp;
}