交换排序
本文主要介绍冒泡排序和快速排序。
交换排序——冒泡排序(Bubble sort)
算法描述
》依次从头比较待排序数组相邻的元素,如果前一个比后一个大,就交换它们,直至到数组的结尾。这是,最后的元素应该会是最大的数。然后重复上述过程,除了最后一个元素,直到没有任何一对元素需要比较。
》具体过程如下图:
第一趟排序过程如下
之后排序结果如下
算法分析
平均时间复杂度:O(n^2)
空间复杂度:O(1)
稳定性:稳定
代码实现
public class BubbleSort {
public static int[] bubble(int[] sort){
int size = sort.length;
for(int i = 0; i < (size - 1); i++){
for(int j = 0; j < (size - i - 1); j++){
if(sort[j] > sort[j + 1]){
int temp = sort[j];
sort[j] = sort[j + 1];
sort[j + 1] = temp;
}
}
}
return sort;
}
public static void main(String[] args) {
int[] test= { 3, 1, 5, 7, 2, 4, 9, 6 };
int[] test2 = BubbleSort.bubble(test);
for (int result : test2) {
System.out.print(result + " ");
}
}
}
交换排序——快速排序(Quick sort)
算法描述
》通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
》具体过程如下图:
这是一趟的过程
算法分析
平均时间复杂度:O(n*log2n)
空间复杂度:O(log2n)~O(n)
稳定性:不稳定
代码实现
public class QuickSort {
public static void quick(int[] sort, int low, int high){
if(low >= high){
return;
}
int flagI = low;
int flagJ = high;
int flagValue = sort[low];
while(flagI < flagJ){
while (flagI < flagJ && sort[flagJ] >= flagValue){
flagJ--;
}
if (flagI < flagJ){
sort[flagI] = sort[flagJ];
flagI++;
}
while (flagI < flagJ && sort[flagI] <= flagValue){
flagI++;
}
if (flagI < flagJ){
sort[flagJ] = sort[flagI];
flagJ--;
}
}
sort[flagI] = flagValue;
quick(sort, low, flagI - 1);
quick(sort, flagI + 1, high);
}
public static void main(String[] args) {
int[] test = { 3, 1, 5, 7, 2, 4, 9, 6 };
QuickSort.quick(test, 0, test.length-1);
for (int result : test) {
System.out.print(result + " ");
}
}
}