冒泡排序

     冒泡排序算法应该说是排序算法中最简单的。但能一次性的写对冒泡排序也是不容易的。冒泡排序最核心的策略就是每次找出最大值(或者最小值)并把其放入到数 组的最末端(或者最前端)，要排序的元素每次减少1个，以此不断执行，最后就会得到想要的结果。下面是其具体的代码实现：

 

  1. /** 
  2.  * 冒泡排序策略：搜索整个数组，比较相邻元素，如果两者的相对大小次序不对，则交换它们，其结果是最大值 
  3.  * “像水泡一样”移动到数组的最后一个位置上，这也是它在完成排序的数组中合适的位置；然后再次搜索数组， 
  4.  * 将第二大的值移动到倒数第二个位置上，重复该过程，直至将所有元素移动到正确的位置上 
  5.  */ 
  6. static void sortBubb(int [] arr){ 
  7.     //数组中有length个数，只需要排length-1次 
  8.     for(int i=0;i<arr.length-1;i++){ 
  9.         //每经过一次排序，就将本次排序中最大的元素放到排序数组的最后一位 
  10.         //每经过一次排序，要排序的数组元素的个数就减1 
  11.         for(int j=0;j<arr.length-i-1;j++){ 
  12.             //比较相邻元素的大小，如果后一个元素小于前一个元素，就交换这两个元素，否则什么事也不做 
  13.             if(arr[j] > arr[j+1]){ 
  14.                 int temp = arr[j]; 
  15.                 arr[j] = arr[j+1]; 
  16.                 arr[j+1] = temp; 
  17.             } 
  18.         } 
  19.     } 
  20. } 

   插入排序

    插入排序的核心思想就是将要插入的元素和已排好序的元素进行比较，并将新元素插入到数组的适当位置。可以分为两步：先比较，再插入。下面是代码实现。

 

  1. /** 
  2.  * 插入排序策略：首先按大小秩序排序数组中的前两个值，然后在相对于前两个值的适当位置插入数组的第三个值 
  3.  * 再在相对于数组前三个值得适当位置插入数组的第四个值，以此类推。每进行以此插入操作，有序子集中的数值个 
  4.  * 数将递增1.重复此过程，直到数组中的所有值都按照秩序排列为止 
  5.  */ 
  6. static void sortInsert(int arr[]){ 
  7.     //先将arr[0]和arr[1]比较，每次比较的元素个数加1 
  8.     for(int i=1;i<arr.length;i++){ 
  9.         for(int j=i;j>0;j--){ 
  10.             if(arr[j] < arr[j-1]){ 
  11.                 int temp = arr[j]; 
  12.                 arr[j] = arr[j-1]; 
  13.                 arr[j-1] = temp; 
  14.             } 
  15.         } 
  16.     } 
  17. } 

  选择排序

    选择排序的核心思想就是先找值，再替换。也就是说,先在数组中找出最大值(或者最小值)，然后再将它与数组的最大下标(或最小下标)处的值替换。具体代码如下：

 

  1. /** 
  2.  * 选择排序策略：搜索整个数组，找到最小值。将该值与数组中的第一个位置上的值进行交换 
  3.  * 搜索剩下的数组元素(第一个除外)，找到其中的最小值，然后将其与数组中第二个位置上的 
  4.  * 值进行交换。对数组中的每个位置重复该过程。在该算法结束时，就完成了对数组的排序。 
  5.  */ 
  6. static void sortSelect(int[] arr){ 
  7.  for(int i=0;i<arr.length;i++){ 
  8.      int lowerIndex = i; 
  9.      for(int j=i+1;j<arr.length;j++){ 
  10.          if(arr[j]<arr[lowerIndex]){ 
  11.              lowerIndex = j; 
  12.          } 
  13.      } 
  14.      int temp = arr[i]; 
  15.      arr[i] = arr[lowerIndex]; 
  16.      arr[lowerIndex] = temp; 
  17.  } 
  18. } 

   希尔排序

   希尔排序的效率是比较高的，它的核心思想就是将数组不断分为更小的几个序列，在序列内先进行排序，排好之后再进行一次插入排序。它的实现具体如下：

 

  1. /** 
  2.  * 希尔排序策略：希尔排序又称为”缩小增量排序“，先将整个待排序的元素序列分割成若干个子序列（由相隔某 
  3.  * 个”增量“的元素组成）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（ 
  4.  * 增量足够小）时，再对全部元素进行依次直接插入排序 
  5.  */ 
  6. static void sortShell(int[] arr){ 
  7.     //不断缩小增量 
  8.     for(int increment = arr.length/2;increment>0;increment/=2){ 
  9.         //从一半的位置开始比较 
  10.         for(int i=increment;i<arr.length;i++){ 
  11.             int temp = arr[i]; 
  12.             int j = 0; 
  13.             for(j=i;j>=increment;j-=increment){ 
  14.                 if(temp < arr[j-increment]){ 
  15.                     arr[j] = arr[j-increment]; 
  16.                 }else{ 
  17.                     break;  
  18.                 } 
  19.             } 
  20.             arr[j] = temp; 
  21.         } 
  22.     } 
  23. }