java 排序 复杂度_java排序算法及复杂度

冒泡排序：

public class Bubble {

/**

* @param args

*/

public static void main(String[] args) {

int[] a = { 77, 1, 65, 13, 81, 93, 10, 5, 23, 17 };

for (int m = a.length - 1; m > 0; m--) {

for (int n = 0; n < m; n++) {

if (a[n] > a[n + 1]) {

int temp = a[n];

a[n] = a[n + 1];

a[n + 1] = temp;

}

}

}

for (int i : a) {

System.out.println(i);

}

}

}

复杂度分析：冒泡排序是不稳定的排序算法，一共要比较((n-1)+(n-2)+...+3+2+1)=n*(n-1)/2次，所以时间复杂度是O(n^2)。

快速排序：

public class QuickSort {

/**

* @param args

*/

public static void main(String[] args) {

int[] initArray = { 1, 545, 23, 334, 876, 222, 111, 8, 9, 7, 6, 57, 89,

0, -23, 670 };

qsort(initArray, 0, initArray.length - 1);

outprint(initArray);

}

public static void outprint(int[] initArray) {

for (int i : initArray) {

System.out.println(i);

}

}

public static void swap(int[] array, int a, int b) {

System.out.println("a=" + a);

System.out.println("b=" + b);

int temp = array[b];

array[b] = array[a];

array[a] = temp;

}

public static int getPivotIndex(int[] array, int begin, int end) {

Random r = new Random();

return begin + r.nextInt(end - begin + 1);

}

public static void qsort(int[] array, int begin, int end) {

if (end > begin) {

int index = getPivotIndex(array, begin, end);

index = portions(array, begin, end, index);

qsort(array, begin, index - 1);

qsort(array, index + 1, end);

}

}

public static int portions(int[] array, int begin, int end, int index) {

int pivot = array[index];

swap(array, index, end);

for (int i = index = begin; i < end; i++) {

if (array[i] < pivot) {

swap(array, index++, i);

}

}

swap(array, index, end);

return index;

}

}

最坏情况是和冒泡一样，时间复杂度是O(n^2)

，最好为n*logn 。

插入排序：

public class InsertSort {

/**

* @param args

*/

public static void main(String[] args) {

int[] array = { 77, 1, 65, 13, 81, 93, 10, 5, 23, 17 };

isort(array, 0, array.length);

outprint(array);

}

public static void outprint(int[] initArray) {

for (int i : initArray) {

System.out.println(i);

}

}

public static void swap(int[] array, int a, int b) {

int temp = array[b];

array[b] = array[a];

array[a] = temp;

}

public static void isort(int[] array, int begin, int end) {

for (int i = begin; i < end; i++) {

int temp = array[i];

for (int m = i - 1; m >= 0; m--) {

if (temp < array[m]) {

array[m + 1] = array[m];

array[m] = temp;

} else {

break;

}

}

}

}

}

最好的情况是：顺序已经排好那么我们只要进行n-1次比较即可。

最坏的情况是：顺序恰好是逆序，比较1+2+...+n-1次。

平均时间复杂度也是O(n^2).

分享到：

2011-04-02 17:03

浏览 1247

评论