编写学习的java几种常用数组的排序方法，给大家分享一下

冒泡排序
冒泡排序算法的运作如下：（从后往前）
1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 从第一个元素一直比较到最后一个元素。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

/**
 * @Description: 冒泡排序
 * @Author: songyl
 * @Date: Created by 2016/3/5
 */
public class TestArray1 {
    public static void main(String[] args) {
        int arr[] = new int[]{3, 43, 25, 16, 31, 57, 8};
        System.out.println("数组a的原始顺序为：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    int k = arr[i];
                    arr[i] = arr[j];
                    arr[j] = k;
                }
            }
        }
        System.out.println("\n数组arr排序后的顺序为：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }
}

选择排序
在一个长度为N的无序数组中，在第一趟遍历N个数据，
 对比数组中前一个元素跟后一个元素的大小，如果后面的元素比前面的元素小则用一个变量k来记住他的位置，即为索引，
 接着第二次比较，前面“后一个元素”现变成了“前一个元素”，
 继续跟他的“后一个元素”进行比较如果后面的元素比他要小则用变量k记住它在数组中的位置(下标)，
 等到循环结束的时候，我们应该找到了最小的那个数的下标了，然后进行判断，
 如果这个元素的下标不是第一个元素的下标，就让第一个元素跟他交换一下值，
 这样就找到整个数组中最小的数了。
 找出其中最小的数值与第一个元素交换，第二趟遍历剩下的N-1个数据，
 找出其中最小的数值与第二个元素交换......第N-1趟遍历剩下的2个数据，
 找出其中最小的数值与第N-1个元素交换，至此选择排序完成
 

/**
 * @Description: 选择排序
 * @Author: songyl
 * @Date: Created by 2016/3/5
 */
public class TestArray2 {
    public static void main(String[] args) {
        int[] a = new int[]{11, 43, 25, 16, 31, 57, 8};
        System.out.println("数组的原始顺序为：");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + "\t");
        }
        for (int i = 0; i < a.length - 1; i++) {
            int min = i;// 第一个数为最小关键数
            //遍历比较确定最小关键数的索引
            for (int j = i + 1; j < a.length; j++) {
                //如果比最小关键数小，则索引改变，小的那个数为新的最小关键数
                if (a[min] > a[j]) {
                    min = j;
                }
            }
            if (min != i) {
                //遍历结束后只和起始值比较索引是否一致，不是就交换，只进行一次交换
                int temp = a[i];
                a[i] = a[min];
                a[min] = temp;
            }
        }
        System.out.println("\n数组a排序后的顺序为：");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + "\t");
        }
    }
}

 

 

 

插入排序
 /* 插入排序：插入即表示将一个新的数据插入到一个有序数组中，并继续保持有序。
  例如有一个长度为N的无序数组，进行N-1次的插入即能完成排序；
  第一次，数组第1个数认为是有序的数组，将数组第二个元素插入仅有1个有序的数组中,与有序第一个比较；
  第二次，数组前两个元素组成有序的数组，将数组第三个元素插入由两个元素构成的有序数组中，与有序第二个第一个分别比较
 第N-1次，数组前N-1个元素组成有序的数组，将数组的第N个元素插入由N-1个元素构成的有序数组中，与有序的两两比较
  则完成了整个插入排序。*/

/**
 * @Description: 插入排序
 * @Author: songyl
 * @Date: Created by 2016/3/5
 */
public class TestArray3 {
    public static void main(String[] args) {
        int[] a = new int[]{3, 43, 25, 16, 31, 57, 8};
        System.out.println("数组a的原始顺序为：");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + "\t");
        }
        for (int i = 0; i < a.length; i++) {
            for (int j = i; j > 0; j--) {
                //遍历比较有序数组插入(j>0)
                if (a[j] < a[j - 1]) {
                    int temp = a[j - 1];
                    a[j - 1] = a[j];
                    a[j] = temp;
                } else {
                    break;
                }
            }
        }
        System.out.println("\n数组a排序后的顺序为：");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + "\t");
        }
    }
}