算法分析_选择、插入、快速排序算法（对数器实现）

排序算法

问题描述

给定一个随机数组，将它变成一个有序数组

示例1

输入：[5,2,3,1,4]
返回值：[1,2,3,4,5]

示例2

输入：[5,1,6,2,5]
返回值：[1,2,5,5,6]

选择排序算法

解题思路

遍历一次数组，找出一个最大或最小值，并确定它的位置，当数组长度为N时，我们遍历N-1次数组就能得到排好序的该数组，所以该算法的时间复杂度为$O(n^2)$，代码实现如下：

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

插入排序算法

解题思路

每一趟确定一个元素的位置（可以是任意元素），例如数组[5,1,6,2,5]，第一趟后[1,5]，第二趟后[1,5,6]，每一次排序插入一个元素，每一趟之后得到的都是有序的数组，算法时间复杂度为$O(n)$，代码实现如下：

public static void insertSort(int[] arr){
    for (int i = 0; i < arr.length-1; i++) {
        for (int j = i + 1; j > 0 ; j--) {
            if (arr[j] < arr[j-1]){
                CheckNumber.swap(arr, j, j-1);
            }
        }
    }
}

快速排序

解题思路

任取待排序列的一个元素作为中心元素（通常取第一个），称为枢轴元素pivot，将数组中比pivot小的值放到其左边，比其大的放到右边，形成两个子表，然后分别对这两个子表进行上述的操作，直到子表不可再分，此时排序结束。

注：每一趟的排序过程，我们都能确定一个元素的位置（枢轴元素），当子表不可再分的时候，不就是每个元素都做过枢轴元素吗？此时数组有序!

public static void quickSort(int[] arr){
    quickSort(arr, 0, arr.length - 1);
}

public static void quickSort(int[] arr, int left, int right){
    int middle;
    if (left < right){
        middle = partition(arr, left, right);
        quickSort(arr, left, middle - 1);
        quickSort(arr, middle + 1, right);
    }
}
//返回枢轴元素在数组中的位置
private static int partition(int[] arr, int left, int right) {
    int pivot = arr[left];
    while (left < right){
        while (left < right && arr[right] >= pivot)
            right--;
        arr[left] = arr[right];
        while (left < right && arr[left] <= pivot)
            left++;
        arr[right] = arr[left];
    }
    arr[left] = pivot;
    return left;
}

对数器

目的

测试我们的代码在大数据量、小数据量下是否正确。

主要组成部分

• 随机数组生成函数
• 数组复制函数
• 系统排序函数
• 数组比较函数

这样我们只需要指定数组的最大值、最大长度，就可以随机生成对应的数组，将自己编写的排序算法结果与系统排序算法结果进行比较，如果结果正确则说明自己编写的排序算法是正确的。

package algorithm.utils;

import java.util.Arrays;

public class CheckNumber {

    //生成随机数组，最大值为maxValue-1,最小值为-maxValue+1，长度最大值为maxSize;
    public static int[] getArray(int maxValue, int maxSize){
        int[] arr = new int[(int)((maxSize + 1) * Math.random()) + 1];
        for (int i = 0; i < arr.length; i++) {
            //随机产生(-maxValue,maxValue)的数
            arr[i] = (int)(maxValue * Math.random() - maxValue * Math.random());
        }
        return arr;
    }

    //将数组复制一遍
    public static int[] copyArray(int[] arr){
        if (arr == null || arr.length == 0){
            return null;
        }
        int[] arrays = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            arrays[i] = arr[i];
        }
        return arrays;
    }

    //使用系统的排序算法进行排序
    public static void SystemSort(int[] arr){
        Arrays.sort(arr);
    }

    //打印数组
    public static void print(int[] arr){
        for (int num : arr) {
            System.out.print(num + ",");
        }
    }

    //比较两个数组是否相等
    public static boolean compare(int[] arr1, int[] arr2){
        if (arr1.length == 0 || arr2.length == 0 || arr1.length != arr2.length)
            return false;
        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] != arr2[i]){
                return false;
            }
        }
        return true;
    }
    //交换数组间元素位置
    public static void swap(int[] arr, int a, int b){
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}