各种sort

冒泡排序 Bubble Sort  O(N^2)  

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

   伪代码
   function bubble_sort (array, length) {
       var i, j;
       for(i from 0 to length-1){
           for(j from 0 to length-1-i){
               if (array[j] > array[j+1])
                   swap(array[j], array[j+1])
           }
       }
   }
   
   JAVA
       public int[] bubble_sort(int[] arr) {
           int i, j, temp, len = arr.length;
           for (i = 0; i < len - 1; i++)
               for (j = 0; j < len - 1 - i; j++)
                   if (arr[j] > arr[j + 1]) {
                       temp = arr[j];
                       arr[j] = arr[j + 1];
                       arr[j + 1] = temp;
                   }
           return arr;
       }

    

       选择排序 select sort

　　　　是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

public static void selection_sort(int[] arr) {
    int i, j, min, temp, len = arr.length;
    for (i = 0; i < len - 1; i++) {
        min = i;
        for (j = i + 1; j < len; j++)
            if (arr[min] > arr[j])
                min = j;
        temp = arr[min];
        arr[min] = arr[i];
        arr[i] = temp;
    }
}

插入排序 insert sort

1. 从第一个元素开始，该元素可以认为已经被排序
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5. 将新元素插入到该位置后
6. 重复步骤2~5

       public static void insertion_sort(int[] arr)
       {
           for (int i = 1; i < arr.length; i++ ) {
               int temp = arr[i];
               int j = i - 1;  // 如果将赋值放到下一行的for循环内, 会导致在第10行出现j未声明的错误
               for (; j >= 0 && arr[j] > temp; j-- ) {
                   arr[j + 1] = arr[j];
               }
               arr[j + 1] = temp;
           }
       }

 快速排序

 * @brief 虽然快速排序称为分治法，但分治法这三个字显然无法很好的概括快速排序的全部步骤。 
  *        因此我的对快速排序作了进一步的说明：挖坑填数+分治法： 
  * @param R为待排数组，low和high为无序区 
  *        时间复杂度：最好O(nlogn),最坏O(n^2)，平均O(nlogn)，空间复杂度O(logn)； 
  */  
void quickSort(int R[], int low, int high)  
{  
    if ( low < high ) {  
        int i = low, j = high, temp = R[low];  
  
        while ( i < j ) {  
            //从右往左扫描，如果数组元素大于temp，则继续，直至找到第一个小于temp的元素  
            while ( i < j && R[j] >= temp ) {  
                --j;  
            }  
            if ( i < j ) {  
                R[i++] = R[j];  
            }  
            while ( i < j && R[i] <= temp ) {  
                ++i;  
            }  
            if ( i < j ) {  
                R[j--] = R[i];  
            }  
        }  
        R[i] = temp;  
        quickSort(R, low, i - 1);  
        quickSort(R, i + 1, high);  
    }  
}