排序算法 java版

算法概述

算法分类

常见排序算法可以分为两大类：

• 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。
• 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。
  

相关概念

• 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
• 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。
• 时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。
• 空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数
  

比较类排序

交换排序

冒泡排序

• 冒泡排序是一种比较简单的排序算法，它循环走过需要排序的元素，依次比较相邻的两个元素，如果顺序错误就交换，直至没有元素交换，完成排序。

• 算法原理步骤：
  1. 比较相邻的元素，前一个比后一个大（或者前一个比后一个小）调换位置
  2. 每一对相邻的元素进行重复的工作，从开始对一直到结尾对，这步完成后，结尾为做大或最小的数（每一次遍历，删选出一个正确的排序位置）.
  3. 针对剩余的元素重复进行上面的步骤。
  4. 重复1-3步骤直到完成排序

• 时间复杂度：需要n-1次比较(外循环)，第k次比较需要进行n-k次比较，比较次数为：(n-1) + (n-2) + … + 1 = n*(n-1) / 2，故时间复杂度为O(n^2)。

• 空间复杂度：最优情况无需排序，为0；最差情况全部逆序进行排序，为O(n)；平均的空间复杂度为：O(1)；

• 动画演示：
  

• 代码实现：

public void bubbleSort(int[] arr) {
	int temp = 0;
	boolean swap;
	//外层循环表示趟数
	for (int i = arr.length - 1; i > 0; i--) { // 每次需要排序的长度
	// 增加一个 swap 的标志， 当前一轮没有进行交换时， 说明数组已经有序
		swap = false;
		for (int j = 0; j < i; j++) { // 从第一个元素到第 i 个元素
			if (arr[j] > arr[j + 1]) {
				temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
				swap = true;
			}
		} 
		if (!swap){
		break;
		}
	}
}
/*
for(int i=0;i<n-1;i++){
	for( int j=0;j<n-i-1;j++){
	
	}
}
*/

快速排序

• 快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
• 算法原理步骤：
  快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：
  1. 从数列中挑出一个元素，称为 “基准”（pivot）；
  2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
  3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
• 动画演示：
  
• 代码实现：

function quickSort(arr, left, right) {
    var len = arr.length,
    partitionIndex,
    left = typeofleft != 'number'? 0 : left,
    right = typeofright != 'number'? len - 1 : right;
 
    if(left < right) {
        partitionIndex = partition(arr, left, right);
        quickSort(arr, left, partitionIndex-1);
        quickSort(arr, partitionIndex+1, right);
    }
    return arr;
}
 
function partition(arr, left ,right) {     // 分区操作
    var pivot = left,                      // 设定基准值（pivot）
    index = pivot + 1;
    for(var i = index; i <= right; i++) {
        if(arr[i] < arr[pivot]) {
            swap(arr, i, index);
            index++;
        }       
    }
    swap(arr, pivot, index - 1);
    returnindex-1;
}
 
function swap(arr, i, j) {
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

选择排序

直接选择排序

• 选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
• 算法原理步骤：
  n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

1. 初始状态：无序区为R[1…n]，有序区为空；
2. 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
3. n-1趟结束，数组有序化了。
4. 比较次数为：(n-1) + (n-2) + … + 1 = n*(n-1) / 2，时间复杂度为O(n^2)。

• 动画演示:
  
• 代码实现：

function selectionSort(arr) {
    var len = arr.length; //var局部变量定义
    var minIndex, temp;
    for(var i = 0; i < len - 1; i++) {
        minIndex = i;    //记录当前区间起点索引
        for(var j = i + 1; j < len; j++) {
            if(arr[j] < arr[minIndex]) {     // 寻找最小的数
                minIndex = j;                 // 将最小数的索引保存
            }
        }
        temp = arr[i];		//替换
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
    return arr;
} 

堆排序

插入排序

直接插入排序

希尔排序

非比较排序