冒泡排序与快速排序

算法分析：

序列 S= {S0, S1, S2, ...,Sn-1}是n个可排序的序列。

(1). i从n-1递减到1，重复步骤(2)~(3)。

(2). j从0递增到i-1，重复步骤(3)。

(3). 若Sj > Sj+1，交换它们。

原始代码和改进的代码如下：

import java.util.Arrays;

class InsertSort {
public void bubbleSort(int[] array) {
for (int i = array.length-1; i > 0; i--) {
for (int j = 0; j < i; j++) {
if(array[j+1] < array[j]) {
int tmp = array[j+1];
array[j+1] = array[j];
array[j] = tmp;
}
}
}
}
public void bubbleSortBetter(int[] array) {
for (int i = array.length-1; i > 0; i--) {
boolean change = false;
for (int j = 0; j < i; j++) {
if(array[j+1] < array[j]) {
int tmp = array[j+1];
array[j+1] = array[j];
array[j] = tmp;
change = true;
}
}
if(!change) break; // 无改变时，说明从j=0到j=i已经是有序的，故不需要再次排序。
}
}
}
public class TestClass {
public static void main(String[] args) {
int[] test = {5, 3, 4, 1, 7, 6};
new InsertSort().bubbleSort(test);
System.out.println(Arrays.toString(test));
}
}

快速排序的三步分治过程：



关于快速排序的详细通俗解说，点击百科快速排序算法。下面给出Java代码，注意递归条件left < right。

import java.util.Arrays;

class QuickSort {
public void quickSort(int[] array, int left, int right) {
int index = partition(array, left, right);
if(left < index-1) quickSort(array, left, index-1); //排序基准点的左半部分
if(index+1 < right) quickSort(array, index+1, right); //排序基准点的右半部分
}

public int partition(int[] array, int left, int right) {
int pivot = array[left]; //找第1个元素作为基准点
while (left < right) {
while (left < right && array[right] >= pivot) right--;
if(left < right) {
int tmp = array[left];array[left] = array[right]; array[right] = tmp;
left++;
}
while (left < right && array[left] <= pivot) left++;
if(left < right) {
int tmp = array[left];array[left] = array[right]; array[right] = tmp;
right--;
}
}
return left; //返回基准点的下标
}
}
public class TestClass {
public static void main(String[] args) {
int[] test = {6, 2, 7, 3, 8, 9};
new QuickSort().quickSort(test, 0, test.length-1);
System.out.println(Arrays.toString(test));
}
}

冒泡算法最好的时间复杂度为O(N)，最坏的时间复杂度O(N2)，平均时间复杂度O(N2)，是稳定的排序算法。

快速排序算法最好的时间复杂度为O(Nlg(N))，最坏的时间复杂度O(N2)，平均时间复杂度O(Nlg(N))，就其平均性能比较而言，它是基于关键字比较的内部排序算法中速度最快的，快速排序亦因此而得名，它是非稳定的。