五种排序算法总结（冒泡、选择、插入、快排、希尔排序）

读完本篇文章将会了解以下问题

1.五种排序算法

---------------------------------------------------------------------------------------------------------------------------

排序算法可以分为内部排序和外部排序。

内部排序是数据记录在内存中进行排序。

而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。

常见的内部排序算法有：直接插入排序、希尔排序、简单选择排序、堆排序、冒泡排序、快速排序、归并排序、基数排序。

时间复杂度与空间复杂度

关于时间复杂度：

平方阶 (O(n2)) 排序：冒泡、选择和插入排序。

线性对数阶 (O(nlog2n)) 排序：快排、归并、希尔和堆排序。

线性阶 (O(n*k)) 排序：基数排序。

关于稳定性：

稳定的排序算法：冒泡、插排、归并和基数排序。

不稳定的排序算法：选择排序、快排、希尔排序、堆排序。

1. 冒泡排序

算法分析：双重for，外层for控制整体比较次数(i个元素两两比较，需要比较i-1次)，内层for控制每次比较过程中两两元素的比较与交换。

public int[] sort(int[] arr) throws Exception {
	for (int i = 1; i < arr.length; i++) {
	    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;
}

2. 选择排序

算法分析：首先在未排序序列中找到最小元素，放到已排序序列的起始位置，再从剩余未排序元素中继续寻找最小元素，然后放到已排序序列的末尾。循环所有元素，直到所有元素均排序完毕。

public int[] sort(int[] arr) throws Exception {
	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 (i != min) { //将找到的最小值和i位置所在的值进行交换
			int tmp = arr[i];
			arr[i] = arr[min];
			arr[min] = tmp;
		}
	}
	return arr;
}

3. 插入排序

算法分析：将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。

public int[] sort(int[] array) {
       for (int i = 1; i < array.length; i++) {
            if (array[i] < array[i - 1]) {
                int temp = array[i];
                int f = i;
                for (; f >= 1 && array[f - 1] > temp; f--) {
                    array[f] = array[f-1];

                }
                array[f] = temp;
            }
        }
        return array;
}

4.快速排序

算法分析：从数列中挑出一个元素，称为 “基准”。重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面。然后对小于基准值元素的子数列和大于基准值元素的子数列再进行快速排序，直到所有元素有序。

public int[] sort(int[] arr) throws Exception {
		return quickSort(arr, 0, arr.length - 1);
	}
	
	private int[] quickSort(int[] arr, int left, int right) {
		if (left < right) {
			int partitionIndex = partition(arr, left, right);
			quickSort(arr, left, partitionIndex - 1);
			quickSort(arr, partitionIndex + 1, right);
		}
		return arr;
	}

	private int partition(int[] arr, int left, int right) {
		int pivot = left;// 设定基准值（pivot）
		int index = pivot + 1;
		for (int i = index; i <= right; i++) {
			if (arr[i] < arr[pivot]) {
				swap(arr, i, index);
				index++;
			}
		}
		swap(arr, pivot, index - 1);
		return index - 1;
	}

	private void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
}

5.希尔排序

算法分析：选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；按增量序列个数 k，对序列进行 k 趟排序；每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
 

public int[] sort(int[] arr) throws Exception {
		int gap = 1;
		while (gap < arr.length) {
			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;
}