手撕十大排序算法①——思路讲解

代码中有关键点注解。

冒泡排序

class Bub {
	public static int[] bub(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        for (int i = 1; i < arr.length; i ++) {
            // 设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成
            boolean flag = true;
            for (int j = 0; j < arr.length - i; j ++) {
                if (arr[j] > arr[j + 1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                    flag = false;
                }
            }
            if (flag)   break;
        }
        return arr;
    }
}

冒泡排序的思想用上图来表达最合适不过。
关键点如下（设数组长度为n）：

• 总共比较n - 1次
• 每次比较的次数都比上次少一次
  • 为什么呢？
  • 因为每次比较都能找到一个最大值放到最后面，这个数是没有必要参与接下来的比较的
• 优化：设置一个flag
  • 如果那次比较位置没有发生改变说明已经有序，可以提前结束排序

选择排序

class Select {
	public static int[] select(int[] sourceArray) throws Exception {
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
        // 总共要经过 N-1 轮比较
        for (int i = 0; i < arr.length - 1; i ++) {
            int min = i;
            // 每轮需要比较的次数为 N-i
            for (int j = i + 1; j < arr.length; j ++) {
                if (arr[j] < arr[min]) {
                    // 记录目前能找到的最小值元素的下标
                    min = j;
                }
            }
            // 将找到的最小值和i位置所在的值进行交换
            if (i != min) {
                int tmp = arr[i];
                arr[i] = arr[min];
                arr[min] = tmp;
            }
        }
        return arr;
    }
}

• 选择排序思想就如上图
• 它并不同于冒泡排序的两两的比较
• 而是做记录
  • 第一次，遍历全部，用最后一个位置与最小值位置交换
  • 如此，则最大值确定在数组最后一个位置
  • 接下来同理
  • 每次都可以比上次少遍历一个值，少遍历的值是已经确定位置的值

插入排序

class Insert {
	public  int[] insert(int[] sourceArray) throws Exception {
        // 对arr进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
        // 从下标为1的元素开始选择合适的位置插入，因为下标为0的只有一个元素，默认是有序的
        for (int i = 1; i < arr.length; i ++) {
            // 记录要插入的数据
            int tmp = arr[i];
            // 从已经排序的序列的最右边的开始比较，找到比其小的数
            int j = i;
            while (j > 0 && tmp < arr[j - 1]) {
                arr[j] = arr[j - 1];
                j --;
            }
            // 存在比其小的数,插入
            if (j != i)
                arr[j] = tmp;
        }
        return arr;
    }
}

这种解法的关键在于

• 从无序的数组中拿值放到有序数组的对应位置
• 怎么个意思呢？
  • 首先默认第一个有序（毋庸置疑，就一个值，咋说都是有序的）
  • 从第二个开始
  • 如果大于第一个，则保持原位，否则跟下标为一的值交换位置
  • 这个时候，原数组的前两个就有序的
    • 所以有序数组长度加一，无序数组长度减一（ps：有序，无序数组是逻辑概念）
  • 往下同理

希尔排序

希尔排序的优化点在于步长的确定
我这里就简单的按照 /2 来做

class Shell {
	// 希尔排序，针对有序序列在插入时采用交换法
    public int[] func1(int[] sourceArray) throws Exception {
        int length = sourceArray.length;
        int[] arr = Arrays.copyOf(sourceArray, length);
        for (int gap = length/2; gap > 0; gap /= 2) {
            for (int i = gap; i < length; i ++) {
                int j = i;
                while (j - gap >= 0 && arr[j] < arr[j - gap]) {
                    swap(arr, j, j - gap);
                    // 这一步意味深长，就是通过这一步进行同组内比较的
                    j -= gap;
                }
            }
        }
        return arr;
    }

    // 希尔排序，针对有序序列在插入时采用移动法
    public int[] func2(int[] sourceArray) throws Exception {
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
        int length = sourceArray.length;
        for (int gap = length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < length; i ++) {
                int j = i;
                int tmp = arr[j];
                if (arr[j] < arr[j - gap]) {
                    // 移动fa
                    arr[j] = arr[j - gap];
                    j -= gap;
                }
                arr[j] = tmp;
            }
        }
        return arr;
    }

    public void swap(int[] arr, int a, int b){
        arr[a] = arr[a] + arr[b];
        arr[b] = arr[a] - arr[b];
        arr[a] = arr[a] - arr[b];
    }
}

如上就是希尔思想根本

• 所以首先确认步长，这里以 len/2 为例
• 之后每次都是 /2/2的，整个数组变化浮动就会逐渐平缓
• 需要注意的点在于：
  • for (int i = gap; i < length; i ++)这个语句
  • 我们可以看到每次步长发生改变之后，都是先比较一组内前面的两个数，然后是中间的，中间的比完之后会继续跟最前面的作比较。后面的同理
• 在比较上，有两种方法：
  • 一是交换，两两交换
  • 二是移动
    • 记录当前位置，然后与前面数的比较过程中，如果发现前面的数更大，则把前面的复制到后面去，一直往前比较，同理。结束的时候，判断最初记录的位置如果发生了变化，则把最初位置的值放到指定位置。

归并排序

class Merge {
	// 递归版
    public int[] func1(int[] sourceArray) throws Exception {
        int length = sourceArray.length;
        int[] arr = Arrays.copyOf(sourceArray, length);
        if (length < 2)
            return arr;
        int mid = (int) Math.floor(length / 2);
        int[] left = Arrays.copyOfRange(arr, 0, mid);
        int[] right = Arrays.copyOfRange(arr, mid, length);

        return merge(func1(left), func1(right));
    }

    protected int[] merge(int[] left, int[] right) {
        int[] result = new int[left.length + right.length];
        int i = 0;
        while (left.length > 0 && right.length > 0) {
            if (left[0] <= right[0]) {
                result[i++] = left[0];
                left = Arrays.copyOfRange(left, 1 ,left.length);
            } else {
                result[i++] = right[0];
                right = Arrays.copyOfRange(right, 1, right.length);
            }
        }
        while (left.length > 0) {
            result[i++] = left[0];
            left = Arrays.copyOfRange(left, 1, left.length);
        }
        while (right.length > 0) {
            result[i++] = right[0];
            right = Arrays.copyOfRange(right, 1, right.length);
        }
        return result;
    }

	// 进阶版本
    public void fun2(int[] sourceArray) {
        Fun2.sort(sourceArray);
    }

    static class Fun2 {
        public static void sort(int []arr){
            //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
            int []temp = new int[arr.length];
            sort(arr,0,arr.length-1,temp);
        }
        private static void sort(int[] arr,int left,int right,int []temp){
            if(left<right){
                int mid = (left+right)/2;
                sort(arr,left,mid,temp);//左边归并排序，使得左子序列有序
                sort(arr,mid+1,right,temp);//右边归并排序，使得右子序列有序
                merge(arr,left,mid,right,temp);//将两个有序子数组合并操作
            }
        }
        private static void merge(int[] arr,int left,int mid,int right,int[] temp){
            int i = left;//左序列指针
            int j = mid+1;//右序列指针
            int t = 0;//临时数组指针
            while (i<=mid && j<=right){
                if(arr[i]<=arr[j]){
                    temp[t++] = arr[i++];
                }else {
                    temp[t++] = arr[j++];
                }
            }
            while(i<=mid){  //将左边剩余元素填充进temp中
                temp[t++] = arr[i++];
            }
            while(j<=right){    //将右序列剩余元素填充进temp中
                temp[t++] = arr[j++];
            }
            t = 0;
            //将temp中的元素全部拷贝到原数组中
            // 通过条件做到只拷贝部分数据过去
            while(left <= right){
                arr[left++] = temp[t++];
            }
        }
    }
}

上面用到两种方法，其实是一种，但是第二种是第一种的进阶版本，更高级。
高级在哪呢？

• 没有开辟多余空间，而是通过下标的方式进行操作
• 代码更优雅
  
• 重点就是分和治
• 分：
  • sort函数就是用来分的
  • 一直分到只剩一个
  • 这样两个数组进行合
  • 回溯到上一步，同理操作
  • 整个代码都是这个思路
  • 是属于偏难的题
    
    
• 它的治也是极为巧妙
• 通过提前开辟的空间来传递存储
• 代码很优雅，不错不错

---

• 这道题解有着很精彩的思路，很赞，值得时常回顾