数据结构-排序算法总结

数据结构中排序算法是各大公司面试的常客，下面则是对各种排序算法的总结：

基本概念

1、排序：排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列

2、内部排序和外部排序：整个排序过程完全在内存中进行，叫做内部排序。数据量较大需要借助外部存储设备才能完成，叫做外部排序。

3、时间复杂度：算法中基本操作重复执行的次数称为算法的时间复杂度，记为T(n)=O(f(n))。

4、空间复杂度：算法所需存储空间的量度称为算法的空间复杂度，记为S(n)=O(f(n))，若排序算法所需的辅助空间并不依赖于问题的规模n，即辅助空间为O(1)。

5、排序的稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，ri=rj，且ri在rj之前，而在排序后的序列中，ri仍在rj之前，则称这种排序算法是稳定的；否则称为不稳定的。

算法分类

排序算法总共可以分4大类，分别是插入类排序、交换类排序、选择类排序、归并类排序。各种排序算法的分类以及时间复杂度和空间复杂度的对比图如下：



下面将对各种排序算法逐一进行叙述：

一、插入类排序

思想：在一个已经排好序的序列中，将未被排进的元素按照原先的规定插入到指定位置。

1、 直接插入排序：

思想：最基本的插入排序，将第i个元素插入到前i−1个元素中的适当位置。

时间复杂度：T(n)=O(n2)

空间复杂度：S(n)=O(1)

稳定性：稳定排序

Java实现：

// 直接插入排序
// 时间复杂度：T(n)=O(n^2)
// 空间复杂度：S(n) = O(1)
// 稳定性：稳定排序
public void directInsertSort(int[] arr){
int temp; //哨兵
int i,j;
for(i = 1;i < arr.length;i++){
if(arr[i] < arr[i-1]){
temp = arr[i];
for( j = i-1;j >= 0 && arr[j] > temp;j--)
arr[j+1] = arr[j];
arr[j+1] = temp;
}
}
}

2、 折半插入排序：

思想：折半插入排序是直接插入排序的改进版，由于前半部分为已排好序的数列，这样我们不用按顺序依次寻找插入点，可以采用折半查找的方法来加快寻找插入点的速度。由于折半查找只是减少了比较次数，但是元素的移动次数不变，因此时间复杂度和直接插入排序一样大。

时间复杂度：T(n)=O(n2)

空间复杂度：S(n)=O(1)

稳定性：稳定排序

Java实现：

// 折半插入排序
// 时间复杂度：T(n)=O(n^2)
// 空间复杂度：S(n) = O(1)
// 稳定性：稳定排序
public void binaryInsertSort(int[] arr) {
int length = arr.length;
int temp;
for(int i = 1;i < length;i++){
int midIndex = (0 + i-1)/2;
if(arr[i] < arr[midIndex]){
for(int j = 0;j <= midIndex;j++){
if(arr[i] < arr[j]){
temp   = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
else {
for (int j = midIndex; j < i; j++) {
if (arr[i] < arr[j]) {
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
}

3、 希尔排序：

思想：希尔排序是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序把待排序序列分成若干较小的子序列，然后逐个使用直接插入排序法排序，最后再对一个较为有序的序列进行一次排序，主要是为了减少移动的次数，提高效率。

时间复杂度：T(n)=O(n32)

空间复杂度：S(n)=O(1)

稳定性：不稳定排序

Java实现：

// 希尔排序
// 时间复杂度：T(n)=O(n^1.5)
// 空间复杂度：S(n) = O(1)
// 稳定性：不稳定排序
public void shellSort(int[] arr) {
int temp,i,j;
//增量gap，并逐步缩小
// 增量
for(int gap = arr.length/2;gap > 0;gap /= 2){
//从第gap个元素，逐个对其所在组进行直接插入排序操作
for(i = gap;i < arr.length;i++){
for(j = i-gap;j >= 0 && arr[j] > arr[j+gap];j -= gap){
temp = arr[j];
arr[j] = arr[j+gap];
arr[j+gap] = temp;
}
}
}
}

二、交换类排序

思想：两两比较待排序记录的关键字，发现两记录的次序相反时即进行交换，直到没有反序的记录为止。

1、 冒泡排序：

思想：冒泡排序将待排序的元素看作是竖着排列的“气泡”，较小的元素比较轻，从而要往上浮。

时间复杂度：T(n)=O(n2)

空间复杂度：S(n)=O(1)

稳定性：稳定排序

Java实现：

// 冒泡排序
// 时间复杂度：T(n)=O(n^2)
// 空间复杂度：S(n) = O(1)
// 稳定性：稳定排序
public void bubbleSort(int[] arr) {
int length = arr.length;
int temp;
for(int i = 0;i < length;i++){
for(int j = 1;j < length;j++){
if(arr[j] < arr[j-1]){
temp     = arr[j];
arr[j]   = arr[j-1];
arr[j-1] = temp;
}
}
}
}

2、 快速排序：

思想：冒泡排序一次只能消除一个逆序，为了能一次消除多个逆序，采用快速排序，因此快速排序是冒泡排序的一种改进。通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。首先在序列中随机选取一个数字，将大于该数字的放在其右边，小于该数字的放在左边。对于该数字左、右边的序列递归调用该过程。

时间复杂度：T(n)=O(n∗log(n))

空间复杂度：S(n)=O(log(n))

稳定性：不稳定排序

Java实现：

/*
// 快速排序
// 时间复杂度：T(n)=O(nlogn)
// 空间复杂度：S(n) = O(logn)
// 稳定性：不稳定排序
*/
void quickSort(int arr[], int start, int end) {
if(start < end){//判断start是否等于end,如果等于则说明各区间只有一个数
int i = start;
int j = end;
int x = arr[start];//将start作为基准数
while(i < j){//如果i=j,则结束
while(i < j && arr[j] >= x) // 从右向左找第一个小于x的数
j--;
//此时,arr[j] < x,则令arr[i]=arr[j],且i向前移动一格
if(i < j)
arr[i++] = arr[j];

while(i < j && arr[i] < x)// 从左向右找第一个大于等于x的数
i++;
//此时,arr[i] >= x,则令arr[j]=arr[i],且j向后移动一格
if(i < j)
arr[j--] = arr[i];
}
//此时,arr[i]=arr[j]=x,且比x大的数全在它的右边，小于或等于它的数全在其左边。下面则再对其左右区间重复这个步骤
arr[i] = x;
quickSort(arr,start,i-1);//对其左边区间重复上述操作
quickSort(arr,i+1,end);//对其右边区间重复上述操作
}
}

三、选择类排序

思想：选择排序的基本思想是对待排序的记录序列进行n-1遍的处理，第i遍处理是将L[i..n]中最小者与L[i]交换位置。

1、 简单选择排序：

思想：依次遍历序列，每次选出值最小的记录，并和当前所遍历的下标最小的记录进行对换。

时间复杂度：T(n)=O(n2)

空间复杂度：S(n)=O(1)

稳定性：稳定排序

Java实现：

/*
*简单选择排序
* // 时间复杂度：T(n)=O(n^2)
// 空间复杂度：S(n) = O(1)
// 稳定性：稳定排序
*/
void selectSort(int arr[]) {
int length = arr.length;
int temp;
for(int i = 0;i < length;i++){
int min = arr[i];
for(int j = i;j < length;j++){
if(min > arr[j]){
temp = min;
min = arr[j];
arr[j] = temp;
}
}
arr[i] = min;
}
}

2、 堆排序：

思想：堆排序与快速排序，归并排序一样都是时间复杂度为 O(n*logn)的排序方法。想明白什么是堆排序，得先明白什么是二叉堆：

二叉堆是完全二叉树或者是近似完全二叉树。 二叉堆满足二个特性：

1．父结点的键值总是大于或等于（小于或等于）任何一个子节点的键值。

2．每个结点的左子树和右子树都是一个二叉堆（都是最大堆或最小堆）。

当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆。当父结点的 键值总是小于或等于任何一个子节点的键值时为最小堆。

一般都用数组来表示堆，i 结点的父结点下标就为(i – 1) / 2。它的左右子结点下 标分别为 2 * i + 1 和 2 * i + 2。



堆的插入删除



由于堆也是用数组模拟的，由于堆的根节点是最小的，故堆化数组后，第一次将A[0]与A[n - 1]交换，再对A[0…n-2]重新恢复堆。第二次将A[0]与A[n – 2]交换，再对A[0…n - 3]重新恢复堆，重复这样的操作直到A[0]与A[1]交换。由于每次都是将最小的数据并入到后面的有序区间，故操作完成后整个数组就有序了。

时间复杂度：T(n)=O(nlogn)

空间复杂度：S(n)=O(1)

稳定性：不稳定排序

Java实现：

/**
* 堆排序
*/
void heapSort(int[] array) {
if (array == null || array.length <= 1) {
return;
}
buildMaxHeap(array);
for (int i = array.length - 1; i >= 0; i--) {
int temp = array[0];
array[0] = array[i];
array[i] = temp;
maxHeap(array, i, 0);
}
}

/**
* 创建最大堆
*/
void buildMaxHeap(int[] array) {
if (array == null || array.length <= 1) {
return;
}
for (int i = array.length / 2; i >= 0; i--) {
maxHeap(array, array.length, i);
}
}

/**
* 调整最大堆
*/
void maxHeap(int[] array, int heapSize, int index) {
int left = index * 2 + 1;
int right = index * 2 + 2;

int largest = index;
if (left < heapSize && array[left] > array[index]) {
largest = left;
}

if (right < heapSize && array[right] > array[largest]) {
largest = right;
}

if (index != largest) {
int temp = array[index];
array[index] = array[largest];
array[largest] = temp;
maxHeap(array, heapSize, largest);
}
}

四、归并排序：

1、 归并排序：

思想：该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。归并排序，其的基本思路就是将数组分成二组A，B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序。如何让这二组组内数据有序了？可以将A，B组各自再分成二组。依次类推，当分出来的小组只有一个数据时，可以认为这个小组的组内已经达到了有序，然后再合并相邻的二个小组就可以了。这样通过先递归的分解数列，再合并数列就完成了归并排序。

时间复杂度：T(n)=O(nlogn)

空间复杂度：S(n)=O(n)

稳定性：稳定排序

Java实现：

/**
* 归并排序
* 时间复杂度：T(n)=O(nlogn)
* 空间复杂度：S(n) = O(n)
* 稳定性：稳定排序
*/
void mergeSort(int[] nums, int low, int high) {
int mid = (low + high) / 2;
if (low < high) {
// 左边
mergeSort(nums, low, mid);
// 右边
mergeSort(nums, mid + 1, high);
// 左右归并
merge(nums, low, mid, high);
}
}

void merge(int[] nums, int low, int mid, int high) {
int[] temp = new int[high - low + 1];
int i = low;// 左指针
int j = mid + 1;// 右指针
int k = 0;

// 把较小的数先移到新数组中
while (i <= mid && j <= high) {
if (nums[i] < nums[j]) {
temp[k++] = nums[i++];
} else {
temp[k++] = nums[j++];
}
}

// 把左边剩余的数移入数组
while (i <= mid) {
temp[k++] = nums[i++];
}

// 把右边边剩余的数移入数组
while (j <= high) {
temp[k++] = nums[j++];
}

// 把新数组中的数覆盖nums数组
for (int k2 = 0; k2 < temp.length; k2++) {
nums[k2 + low] = temp[k2];
}
}