排序算法（一）（时间复杂度均为O(n*n)）

对于一个int数组，请编写一个选择排序算法，对数组元素排序。

给定一个int数组A及数组的大小n，请返回排序后的数组。

测试样例：

[1,2,3,5,2,3],6

[1,2,2,3,3,5]
 
冒泡排序：

 package test;
 
 public class BubbleSort {
     public int[] bubbleSort(int[] A, int n) {
         int temp;
         for (int j = 0; j < n - 1; j++) {
             for (int i = 0; i < n - 1 - j; i++) {
                 if (A[i + 1] < A[i]) {
                     temp = A[i];
                     A[i] = A[i + 1];
                     A[i + 1] = temp;
                 }
             }
         }
         return A;
     }
 
     public static void main(String[] args) {
         BubbleSort bubSort = new BubbleSort();
         int[] A = { 1, 2, 3, 5, 2, 3 };
         int[] ASort = bubSort.bubbleSort(A, A.length);
         for (int i = 0; i < ASort.length; i++) {
             System.out.println(ASort[i]);
         }
 
     }
 
 }

运行结果如下：

1 2 2 3 3 5

时间复杂度为O(n*n);两两相互比较，较小的元素向上冒泡，较大的元素沉到水底。

选择排序：

 package test;
 
 public class SelectionSort {
       public int[] selectionSort(int[] A, int n) {
             // write code here
           int temp;
           for (int j=0;j<n-1;j++)
           {
           for (int i=j+1;i<n;i++)
           {
               if (A[j]>A[i])
               {
                   temp=A[j];
                   A[j]=A[i];
                   A[i]=temp;
               }
           }
           }
           return A;
         }
 
         public static void main(String[] args) {
             SelectionSort selSort = new SelectionSort();
             int[] A = { 1, 2, 3, 5, 2, 3 };
             int[] ASort = selSort.selectionSort(A, A.length);
             for (int i = 0; i < ASort.length; i++) {
                 System.out.println(ASort[i]);
             }
         }
 
 }

运行结果如下：

1 2 2 3 3 5

时间复杂度为O(n*n);第一位存储最小的元素，第二位存储第二小的元素，以此类推。

插入排序：

 package test;
 
 public class InsertionSort {
     public int[] insertionSort(int[] A, int n) {
         int temp;
         for (int j = 1; j < n; j++) {
             for (int i = j; i > 0; i--) {
                 if (A[i] < A[i - 1]) {
                     temp = A[i];
                     A[i] = A[i - 1];
                     A[i - 1] = temp;
                 }
             }
         }
         return A;
     }
 
     public static void main(String[] args) {
         InsertionSort insSort = new InsertionSort();
         int[] A = { 1, 2, 3, 5, 2, 3 };
         int[] ASort = insSort.insertionSort(A, A.length);
         for (int i = 0; i < ASort.length; i++) {
             System.out.println(ASort[i]);
         }
     }
 }

运行结果如下： 1 2 2 3 3 5

时间复杂度为O(n*n)，第二个数同第一个数比，如果比第一个小，就交换位置，然后第三个数同第二个数比，如果小就交换位置，并且继续同第一个数比较大小，如果小就交换位置，以此类推。