数组中的几种排序法（冒泡，选择，插入，希尔）

package 数组的几种排序方法;

public class SortArray {
 //程序入口：测试冒泡，选择，插入，希尔排序方式；
    public static void main(String args[]) {
     //取得要排序的数组
     int[] srcA = createSrcArray(5);
     System.out.println("冒泡排序前数组中的顺序的值如下：");
     printArray(srcA);
     System.out.println();
     System.out.println("冒泡排序的结果：");
     int[] tem=maopao(srcA);
     printArray(tem);
     System.out.println();
     
        srcA = createSrcArray(6);
     System.out.println("选择排序前数组中的顺序的值如下：");
     printArray(srcA);
     System.out.println();
     System.out.println("选择排序的结果：");
        tem=xuanZe(srcA);
     printArray(tem);
     System.out.println();
     
     srcA = createSrcArray(7);
     System.out.println("插入排序前数组中的顺序的值如下：");
     printArray(srcA);
     System.out.println();
     System.out.println("插入排序的结果：");
        tem=caRu(srcA);
     printArray(tem);
     System.out.println();
     
     srcA = createSrcArray(8);
     System.out.println("希尔排序前数组中的顺序的值如下：");
     printArray(srcA);
     System.out.println();
     System.out.println("希尔排序的结果：");
        tem=shell(srcA);
     printArray(tem);
     
     
    }
   
    //生产一个乱序的，指定长度的原始数组
    public static int[] createSrcArray(int len) {
     //初始化要排序的数组中的值
     int[] base = new int[len];
     for(int i=0;i<base.length;i++) {
      //创建一个随机对象
      java.util.Random random = new java.util.Random();
      //调用随机对象，每次循环时生成一个0-100的随机数
      int value = random.nextInt(100);
      //给数组中指定位置上添上随机数：
      base[i] = value;
     }
     return base; 
    }
   
    //打印数组中的元素
    public static void printArray(int[] ia) {
     //如果要打印的数组为null,则不打印：
     if(ia==null) {
      return;
     }
     for(int i=0;i<ia.length;i++) {
      System.out.print("  "+ia[i]);
     }
     System.out.print("");
    }
   
    //冒泡排序
    public static int[] maopao(int[] x) {
     for(int i=0;i<x.length;i++) {
      for(int j=i+1;j<x.length;j++) {
       if(x[i]>x[j]) {
        int temp = x[i];
        x[i] = x[j];
        x[j] = temp;
       }
      }
     }
     return x;
    }
   
   
    //选择排序
    public static int[] xuanZe(int[] x) {
     for(int i=0;i<x.length;i++) {
      int lowerIndex = i;
      //找出最小的一个索引
      for(int j=i+1;j<x.length;j++) {
       if(x[j]<x[lowerIndex]) {
        lowerIndex = j;
       }
      }
      //交换
      int temp = x[i];
      x[i] = x[lowerIndex];
      x[lowerIndex] = temp;
     }
     return x;
    }
    //插入排序
    public static int[] caRu(int[] x) {
     for(int i=1;i<x.length;i++) {
      for(int j=i;j>0;j--) {
       if(x[j]<x[j-1]) {
        int temp = x[j];
        x[j] = x[j-1];
        x[j-1] = temp;
       }
      }
     }
     return x;
    }
   
    //希尔排序
    public static int[] shell(int[] x) {
     //分组
     for(int increment=x.length/2;increment>0;increment/=2) {
      for(int i=increment;i<x.length;i++) {
       int temp = x[i];
       int j=0;
       for(j=i;j>=increment;j-=increment) {
        if(temp<x[j-increment]) {
         x[j] = x[j-increment];
        }else {
         break;
        }
       }
       x[j] = temp;
      } 
     }
     return x;
    }
}

输出结果：

冒泡排序前数组中的顺序的值如下：
  28  93  12  99  6
冒泡排序的结果：
  6  12  28  93  99
选择排序前数组中的顺序的值如下：
  50  49  30  72  10  4
选择排序的结果：
  4  10  30  49  50  72
插入排序前数组中的顺序的值如下：
  43  3  8  96  20  27  56
插入排序的结果：
  3  8  20  27  43  56  96
希尔排序前数组中的顺序的值如下：
  79  10  13  53  7  27  0  18
希尔排序的结果：
  0  7  10  13  18  27  53  79