Java中常用的排序算法

（1）冒泡排序

时间复杂度： 

最好               最坏               平均                 辅助空间                 稳定性

O(n)             O(n2)              O(n2)                   O(1)                       稳定

 

实现：                                                                                                                                  改进：

 

public  void bubblesort (char[]  a)  {                                   public void bubbleSort2 ( char[]  a)  {
     char temp = '';                                                          int left = 0;
     int size = a.length;                                                     int right = a.length - 1;
     for (int i = 0; i < size-1; i++ ) {                                      while ( left < right ) {       =
          for (int j = i+1; j < size - 1; j++) {                                   for ( int i = left; i < right; i++ ) {
             if ( a[i]  > a[j] )  {                                                    if (A[i] > A[i + 1])   {
                 temp = a[i];                                                              Swap(A[i], A[i+1]);
                 a[i] = a[j];                                                          }
                 a[j] = temp;                                                     }
             }                                                                    right--;
         }                                                                        for ( int i = right ; i > left ; i-- )  {
     }                                                                                 if ( A[i-1] > A[i] )  {
 }                                                                                         Swap(A[i-1], A[i]);
                                                                                       }
                                                                                  }
                                                                                  left++;
                                                                              }
                                                                        }

 

 

 

                                                                                                                              

                                                                                                                                                        

（2）插入排序

 

最好               最坏               平均                 辅助空间                 稳定性

O(n)             O(n2)              O(n2)                   O(1)                      稳定

 

 实现：                                                                                                           改进：

 

public void InsertionSort ( int A[], int n )  {             void InsertionSort ( int A[], int n )  {
    for ( int i = 1 ; i < n ; i++ )  {                           for ( int i = 1 ; i < n ; i++ )  {
        int temp = A[i] ;                                             int get = A[i] ;
        int j ;                                                       int left = 0;
        for ( j = i - 1 ; j >= 0 ; j-- ) {                            int right = i -1;
             if ( a[j] > temp ) {                                     while ( left <= right ) {
                 a[j + 1] = a[j];                                         int mid =  ( left  + right  ) / 2;
             } else {                                                     if ( A[mid]  >  get ) {
                 break;                                                       right = mid - 1;
             }                                                            }  else {
             a[j+1] = temp;                                                   left = mid + 1;
        }                                                                 }
    }                                                                 }
}                                                                     for ( int j = i - 1 ; j >= left ; j-- ) {
                                                                          A[j + 1] = A[j] ; 
                                                                      }
                                                                      A[left] = get;
                                                                 }
                                                            }

 

 

 

 

 

（3）快速排序

 

  最好                     最坏                 平均                 辅助空间                 稳定性

O(nlogn)               O(n2)              O(nlogn)          O(logn) ~ O(n)            稳定

 

实现：

 

void Swap ( int A[], int i, int j )  {
        int temp = A[i];
        A[i] = A[j];
        A[j] = temp;
}

int Paryion( int A[], int left, int right ） {
        int pivot = A[right];
        int tail = left - 1;
        for ( int i = left ; i < right ; i++ ) {
               if (A[i] <= pivot) {
                    Swap(A, ++tail, i);
               }
        }
        Swap(A, tail + 1, right);
        return tail + 1;
}

void QuickSort( int A[], int left, int right )  {
        if (left >= right)
              return;
        int pivot_index = Partion(A, left, right);
        QuickSort(A, left, pivot_index - 1);
        QuickSort(A, pivot_index + 1, right);
}

 

 

 

 

 

（4）选择排序

 

 

  最好                 最坏                 平均               辅助空间                  稳定性

O(n2)                O(n2)               O(n2)            O(logn) ~ O(n)           不稳定

 

实现：

 

public static void selectSort ( int[] a) {
        int size = a.length;
        int temp = 0;
        for ( int i = 0 ; i < size ; i++ ) {
                 int k = i;
                 for ( int j = size - 1 ; j > i ; j-- )  {
                          if ( a[j] < a[k] ） {
                                   k = j;
                          }
                 }
                 temp = a[i];
                 a[i] = a[k];
                 a[k] = temp;
        }
}