java 排序

第一种：冒泡排序

查看 复制到剪切板 打印

1. public static int[] bubbleSort(int[] a) {   
2.   for (int i = 0; i < a.length; i++) {   
3.     for (int j = 0; j < (a.length - i) - 1; j++) {   
4.       if (a[j] > a[j + 1]) {   
5.         int temp = a[j];   
6.         a[j] = a[j + 1];   
7.         a[j + 1] = temp;   
8.       }   
9.     }   
10.   }   
11.   return a;   
12. }  

  public static int[] bubbleSort(int[] a) {
    for (int i = 0; i < a.length; i++) {
      for (int j = 0; j < (a.length - i) - 1; j++) {
        if (a[j] > a[j + 1]) {
          int temp = a[j];
          a[j] = a[j + 1];
          a[j + 1] = temp;
        }
      }
    }
    return a;
  }

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

第二种：选择排序

查看 复制到剪切板 打印

1. public static int[] selecitonSort(int[] a) {   
2.   for (int i = 0; i < a.length; i++) {   
3.     int max = a[0];   
4.     int count = 0;   
5.     int k = a.length - i - 1;   
6.     for (int j = 0; j < a.length - i; j++) {   
7.       if (max < a[j]) {   
8.         max = a[j];   
9.         count = j;   
10.       }   
11.     }   
12.     a[count] = a[k];   
13.     a[k] = max;   
14.   }   
15.   return a;   
16. }  

  public static int[] selecitonSort(int[] a) {
    for (int i = 0; i < a.length; i++) {
      int max = a[0];
      int count = 0;
      int k = a.length - i - 1;
      for (int j = 0; j < a.length - i; j++) {
        if (max < a[j]) {
          max = a[j];
          count = j;
        }
      }
      a[count] = a[k];
      a[k] = max;
    }
    return a;
  }

复杂度分析：选择排序是不稳定算法，最好的情况是最好情况是已经排好顺序，只要比较
n*(n-1)/2次即可，最坏情况是逆序排好的，那么还要移动 O(n)次,由于是低阶故而不考虑
不难得出选择排序的时间复杂度是 O(n^2)

第三种：插入排序

查看 复制到剪切板 打印

1. public static int[] insertionSort(int[] a) {   
2.    int n = a.length;   
3.    for (int i = 1; i < n; i++) {   
4.      int temp = a[i];   
5.      int j;   
6.      for (j = i - 1; j >= 0 && temp < a[j]; j--) {   
7.        a[j + 1] = a[j];   
8.      }   
9.      a[j + 1] = temp;   
10.    }   
11.    return a;   
12.  }  

 public static int[] insertionSort(int[] a) {
    int n = a.length;
    for (int i = 1; i < n; i++) {
      int temp = a[i];
      int j;
      for (j = i - 1; j >= 0 && temp < a[j]; j--) {
        a[j + 1] = a[j];
      }
      a[j + 1] = temp;
    }
    return a;
  }

算法分析：插入排序的思想是这样的，第一层for循环表示要循环n次，且每次循环要操作的主体是a[i]，第二层循环是对a[i]的具体操作，是从原数祖第i个位置起，向前比较，若a[i]比前面的数小，前面的数后移占去a[i]的位置，同时也为a[i]空出了插入地点，然后向前继续比较，直到a[i]比前面的数来的大，插入。下一次循环开始，这样就完成一个完整的升序插入排序。

很明显，这种排序也是不稳定的，
最好的情况是：顺序已经排好那么我们只要进行n-1次比较即可。
最坏的情况是：顺序恰好是逆序，惨了，我们要比较1+2+...+n-1次

平均的复杂度算起来还是比较困难的，也是很有参考价值的：

1。首先，我们来看 对于第i个元素 a[i] 的操作
从等概率角度思考：a[i]只比较 1 次的概率为 1/i;
a[i]只比较 2 次的概率为 1/i;
a[i]只比较 3 次的概率为 1/i;
。
。
。

a[i]只比较 i-1 次的概率为 1/i;
a[i]只比较 i 次的概率为 1/i;
于是又编号为i的元素平均比较次数为：(1/i)*(1+2+3+...+i)=(i+1)/2

2。然后我们来看
平均比较次数为 T=(2+3+4+...+n)/2
所以插入排序的平均时间复杂度也是O(n^2).