各种常用排序的时间复杂度和稳定性以及代码实现

转载地址：http://blog.csdn.net/hr10707020217/article/details/10581371
怎么记忆稳定性：总过四大类排序：插入、选择、交换、归并（基数排序暂且不算）比较高级一点的（时间复杂度低一点得）shell排序，堆排序，快速排序（除了归并排序）都是不稳定的，在加上低一级的选择排序是不稳定的。比较低级一点的（时间复杂度高一点的）插入排序，               冒泡排序，归并排序，基数排序都是稳定的。（4种不稳定，4种稳定）。一、对于直接插入排序:

public void insertSort(int[] unsorted) {
for (int i = 1; i < unsorted.length; i++) {
if (unsorted[i - 1] > unsorted[i]) {
int temp = unsorted[i];
int j = i;
while (j > 0 && unsorted[j - 1] > temp) {
unsorted[j] = unsorted[j - 1];
j--;
}
unsorted[j] = temp;
}
}
}

当最好的情况，如果原来本身就是有序的，比较次数为n-1次（分析（while (j >= 0 && temp < R[j])）这条语句）,时间复杂度为O(n)。当最坏的情况，原来为逆序，比较次数为2+3+...+n=(n+2)(n-1)/2次，而记录的移动次数为i+1(i=1,2...n)=(n+4)(n-1)/2次。如果序列是随机的，根据概率相同的原则，平均比较和移动的次数为n^2/4.二、
选择排序不关心表的初始次序，它的最坏情况的排序时间与其最佳情况没多少区别，其比较次数都为
n(n-1)/2，交换次数最好的时候为0，最差的时候为n-1，尽管和冒泡排序同为O(n)，但简单选择排序性能上要优于冒泡排序。但选择排序可以   非常有效的移动元素。因此对次序近乎正确的表，选择排序可能比插入排序慢很多。

public void selectSort(int[] R,int n){
int i, j, temp, index;
for ( i = 0; i < n; ++i ) {
index = i;
for ( j = i + 1; j < n; ++j ) {
if ( R[index] > R[j] ) {
index = j;//index中存放关键码最小记录的下标
}
}
if (index != i) {
temp = R[i];
R[i] = R[index];
R[index] = temp;
}
}
}

三、冒泡排序：最好的情况，n-1次比较，移动次数为0，时间复杂度为O(n)。最坏的情况，n(n-1)/2次比较，等数量级的移动，时间复杂度为O(O^2)

public void bubbleSort(int[] num){
int nlen = num.length;
for(int i=0;i<nlen-1;i++){
for(int j=1;j<nlen-i;j++){
if(num[j-1]>num[j]){
int tmp = num[j-1];
num[j-1] = num[j];
num[j] = tmp;
}
}
}
}

四、快速排序：最好情况O(nlogn)
最坏情况O(n^2)

public void quickS(int[] num, int s, int end) {
if (s < end) {
int mid = qs(num, s, end);
quickS(num, s, mid - 1);
quickS(num, mid + 1, end);
}
}
public int qs(int[] num, int s, int end) {
int i = s;
int j = end;
int tmp = num[i];
while (i < j) {
while (i < j && num[j] > tmp)
j--;
if (i < j) {
num[i] = num[j];
i++;
}
while (i < j && num[i] < tmp)
i++;
if (i < j) {
num[j] = num[i];
j--;
}
}
num[i] = tmp;
return i;
}