一、排序算法概览
1.1 思维导图
1.2 时、空复杂度比较
图片来自网络，侵删
二、算法实现
2.1 插入排序
2.1.1 直接插入排序
- 基本思想：每次将一个待排序的记录，按其关键字大小与前面已排序子序列进行比较，找到插入位置，然后插入位置后元素向后顺移，然后将该关键字插入到前面留出的空位中。
- 代码实现
public void DirectInsertSort(int []array) {
for(int i=1; i<array.length; i++) {
if(array[i] < array[i-1]) { //当检测到逆序元素
int tmp = array[i];
int j = i-1;
while(j>=0 && array[j]>tmp) { //边比较边插入
array[j+1] = array[j];
j--;
}
array[j+1] = tmp;
}
}
}
- 稳定性：稳定。每次插入元素总是从后方向前比较再移动，所以不会出现相同元素发生变化的情况。
2.1.2 折半插入排序
- 基本思想：直接插入排序的升级版。直接排序总是变比较边移动元素，折半插入排序将比较和移动操作分离出来，即先折半查找出元素的待插入位置然后再统一地移动插入位置后的所有元素。
- 代码实现
public void HalfInsertSort(int []array) {
int i,j,low,mid,high;
for(i=1; i<array.length; i++) {
int tmp = array[i];
low = 0;
high = i-1;
//折半查找当前元素在已排序序列中的插入位置
while(low <= high) {
mid = (low + high)/2;
if(array[mid] > tmp)
high = mid-1;
else
low = mid+1;
}
for(j=i-1; j>=high+1; j--) //找出待插入的位置 "high+1"
array[j+1] = array[j];
array[j+1] = tmp;
}
}
- 稳定性：稳定。
- 折半插入排序仅仅是为了减少比较元素的次数，该比较次数与待排序表的初始状态无关，仅取决于表中元素个数 n。元素的移动次数没有改变，它依赖于待排序表的初始状态
2.1.3 Shell 排序
- 直接插入排序算法适用于基本有序的排序表和数据量不大的排序表。基于这两点，D.L.Shell 提出了希尔排序，又称为缩小增量排序。
- 基本思想：先将待排序表分割成若干个形如L[i，i+d,i+2d,...,i+kd]的“特殊字表”，分别进行直接插入排序，当整个表中元素已呈“基本有序”时，再对全体记录进行一次直接插入排序。
- 代码实现
public void ShellSort(int []array) {
int dk = array.length/2; //设置初始步长
//当步长为1时，即对基本有序的待排序表进行最后一次直接插入排序
while(dk >= 1) {
for(int i=dk+1; i<array.length; i++) {
if(array[i] < array[i-dk]) {
int tmp = array[i];
int j = i-dk;
while(j>=0 && array[j]>tmp) {
array[j+dk] = array[j];
j -= dk;
}
array[j+dk] = tmp;
}
}
dk /= 2;
}
}
- 稳定性：不稳定。当相同关键字的记录被划分到不同的子表时，可能会改变它们之间的相对次序。
2.1.4 插入排序总结
- 插入类排序最重要的思想是：依次将待排序表中元素，与已排序子序列进行比较，若为逆序，则将已排序子序列元素向后顺移，直到找到插入位置，将该待排序序列元素插入到已排序中。
2.2 交换排序
2.2.1 冒泡排序
- 基本思想：假设待排序表长为n,从后往前（或从前往后）两两比较元素的值，若为逆序（即A[i-1]>A[i]）则交换它们，直到序列比较完。我们称它为一趟冒泡，结果将最小的元素交换到待排序的第一个（关键字最小的元素如气泡一样逐渐向上“漂浮”直至“水面”，这就是冒泡排序名字由来）。下一趟冒泡时，前一趟确定的最小元素不再参与比较，待排序列减少一个元素，每趟冒泡的结果把序列中的最小元素放到了序列的最终位置。
- 代码实现
public void BubbleSort(int []array) {
//表示本趟冒泡是否发生交换的标志，
//若当前待排序表已经有序，可跳出循环，减少比较次数
boolean flag = false;
for(int i=0; i<array.length-1; i++) {
for(int j=array.length-1; j>i; j--) {
if(array[j] < array[j-1]) { //若为逆序
swap(array,j,j-1);
flag = true;
}
}
if(flag == false)
return ; //本趟遍历后没有发生交换，说明表已经有序
}
}
- 稳定性：稳定。当 i>j 且A[i]=A[j]时，不会交换两个元素，从而冒泡排序是一个稳定的排序算法。
2.2.2 快速排序
- 基本思想：快速排序是冒泡排序的一种改进。基本思想是基于分治法的：在待排序表L[1...n]中任取一个元素pivot作为基准通过一趟排序将待排序表划分为独立的两部分L[1...k-1]和L[k+1...n]。使得L[1...k-1]中所有元素小于pivot，L[k+1...n]中所有元素大于或等于 pivot，则 pivot 放在了其最终位置L(k)上，这个过程称为一趟快速排序。而后重复上诉过程，直至每部分内只有一个元素或为空为止，即所有元素放在了其最终位置上。
- 代码实现
public void QuickSort(int []array,int low,int high) {
if(low < high) {
int pivot = Partion(array,low,high);
mySort(array,low,pivot-1);
mySort(array,pivot+1,high);
}
}
//重点理解掌握划分算法
public int Partion(int []array,int low,int high) {
int pivot = array[low];
while(low < high) {
//从待排序表的末端与基准进行比较。若大，则 high 前移
while(low < high && array[high] >= pivot)
high --;
//若小，则将当前 high 所指元素移动到 low 处
array[low] = array[high];
//从待排序的首端与基准进行比较。若小，则 low 后移
while(low < high && array[low] <= pivot)
low ++;
//若小，则将当前 low 所指元素移动到 high 处
array[high] = array[low];
}
//划分结束，将基准元素填入到 low 处
array[low] = pivot;
return low;
}
- 空间复杂度：由于快速排序是递归的，需要借助一个递归工作栈来保存每一层递归调用的必要信息，其容量应与递归调用的最大深度一致。因而最坏情况为O(n)，平均情况为O(logn)。
- 时间复杂度：快排的运行时间与划分是否对称有关，而后者又与具体使用的划分算法有关。若初始排序表基本有序或基本逆序时就得到最坏情况下的时间复杂度O(n^2)。
- 稳定性：不稳定。在划分算法中，若右端区间存在两个关键字相同，且均小于基准值的记录，则在交换到左端区间后，它们的相对位置就会发生变化。
2.2.3 交换类排序总结
- 所谓交换，就是根据序列中两个元素关键字的比较结果来对换这两个记录在序列中的位置。
- 冒泡排序是最简单的交换排序，它不断进行交换操作，直至排序完毕。
- 快速排序，运用分治法的思想，每次将待排序表按设定的基准值划分成两个待排序子表。每一次划分操作后，基准值的位置（在排序表中的最终位置）被确定。运用递归技术，重复进行这一操作，直到所有元素都被划分完毕，所有基准值的位置就被唯一确定。而划分过程中，也就是元素不断交换位置的过程，所以把快速排序归到交换排序中。
2.3 选择排序
2.3.1 简单选择排序
- 基本思想：假设排序表为L[1...n]，第 i 趟排序即从L[i...n]中选择关键字最小的元素与L(i)交换。每一趟排序可以确定一个元素的最终位置。
- 代码实现
public void SelectSort(int []array) {
for(int i=0; i<array.length-1; i++) {
int min = i;
for(int j=i+1; j<array.length; j++) {
if(array[min] > array[j])
min = j;
}
if(min != i)
Swap(array,i,min);
}
}
- 时间复杂度：元素移动次数（交换）很少，最好情况是移动0次，此时对应的表已经有序。但元素的间的比较次数与序列的初始状态无关，始终是n(n-1)/2次，故时间复杂度始终为O(n^2)
- 稳定性：不稳定。假设待排序表为[2,2,1]，经过选择排序后为[1,2,2]。
.........................................未完待续.........................................
2.3.2 堆排序
- 基本思想
- 代码实现
2.4 其它
2.4.1 归并排序
- 基本思想
- 代码实现
2.4.2 基数排序
- 基本思想
- 代码实现
