四大排序算法

一.冒泡排序

1.冒泡排序的基本思想

冒泡排序是一种交换排序，通过反复移位交换，每次将最大的数，像冒泡一样放到最后

2.冒泡算法的具体实现

3.时间复杂度分析

一共四个数字，共需要跑三趟，第一趟需要比较3次，第二趟需要比较2次，第三趟需要比较1次
得出结论：当有n个数字时，需要跑n-1趟，而第一趟要比较n-1次，最后一趟要比较一次，所以总次数为：（n-1）+（n-2）+…+1也就是1/2n*n-1/2n次，那复杂度就是 O(n^2)

4.冒泡代码模板

 for (int i = 0; i < arr.length - 1; i++) {
         for (int j = 0; j < arr.length-1-i; j++) {
             if (arr[j + 1] < arr[j]) 
                 int t = arr[j];
                 arr[j] = arr[j+1];
                 arr[j+1] = t;
             }
}

二.选择排序

1.选择排序的基本思想

A.在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
B.从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾
C.以此类推，直到所有元素均排序完毕

2.选择排序的具体实现

3.选择排序的代码实现

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;
				}
			}
			if(min!=i){
				swap(arr, i, min);
			}
		}
	}
	//完成数组两元素间交换
	public static void swap(int[] arr,int a,int b){
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}

三.插入排序

1.插入排序的思想

每一步将一个待排序的数据插入到前面已经排好序的有序序列中，直到插完所有元素为止。

2.插入排序的算法实现

3.插入排序代码实现

void StraightSort(int *arr,int len)
{
	int tmp;
	int i;
	int j;
	for (i = 1;i < len;i++)
	{
		tmp = arr[i];
		for (j = i - 1;j >= 0 && arr[j] > tmp;j--)
		{
			arr[j + 1] = arr[j];
		}
		arr[j + 1] = tmp;
	}
}

四.希尔排序

1.希尔排序的简介

希尔排序(Shell’s Sort)是插入排序的一种又称 “缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。该方法因D.L.Shell于1959年提出而得名。
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至 1 时，整个文件恰被分成一组，算法便终止。
希尔排序是基于插入排序的以下两点性质而提出改进方法的：
插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率。

2.希尔排序的思路

先取一个小于 n 的整数 d_1 作为第一个增量，把文件的全部记录分组。所有距离为 d_1 的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量 d_{2}<d_{1} 重复上述的分组和排序，直至所取的增量d_{t}=1(d_{t}<d_{t-1}<\cdots <d_{2}<d_{1})，即所有记录放在同一组中进行直接插入排序为止。
该方法实质上是一种分组插入方法。

3.希尔排序的图解演示

假设，我们有一个数列，初始状态为，一共 8 个元素。

第一轮
我们按下标相隔距离为 4 进行分组 ，这样a[0]与a[4]是一组、a[1]与a[5]是一组、…。如下图所示。

每个分组进行插入排序后，各个分组就变成了有序的，注意整体不一定有序。如下图所示。

第二轮
小增量为上个增量的一半 2，继续划分分组。此时，每个分组元素个数多了，但是，数组变的部分有序了，插入排序效率同样比高。此时的分组情况如下图所示。

对每个分组进行插入排序，使其每个分组各自有序。如下图所示。

第三轮
最后设置增量为上一个增量的一半 1，则整个数组被分为一组，此时，整个数组已经接近有序了，插入排序效率高。如下图所示。

再对分组进行插入排序，使其每个分组各自有序。这样排序完成。

动画展示

4.希尔排序的时间复杂度

平均时间复杂度为O(nlongn)

5.希尔排序的代码实现

public class ShellSort implements IArraySort {
 
    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
 
        int gap = 1;
        while (gap < arr.length/3) {
            gap = gap * 3 + 1;
        }
 
        while (gap > 0) {
            for (int i = gap; i < arr.length; i++) {
                int tmp = arr[i];
                int j = i - gap;
                while (j >= 0 && arr[j] > tmp) {
                    arr[j + gap] = arr[j];
                    j -= gap;
                }
                arr[j + gap] = tmp;
            }
            gap = (int) Math.floor(gap / 3);
        }
 
        return arr;
    }
}