排序算法主要包括：冒泡排序、快速排序、希尔排序、插入排序、选择排序、堆排序、归并排序、基数排序、桶排序
（1）.冒泡排序：
- 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
- 针对所有的元素重复以上的步骤，除了最后一个；
- 重复步骤1~3，直到排序完成。
/**
* 冒泡排序
*
* @param array
* @return
*/
public int[] bubbleSort(int[] array){
if(array.length==0) return array;
int temp=0;
for(int i=0;i<array.length;i++){
for(int j=0;j<array.length-i;j++){
if (array[j + 1] < array[j]) {
temp = array[j + 1];
array[j + 1] = array[j];
array[j] = temp;
}
}
}
}
（2）.快速排序
快速排序的原理：选择一个关键值作为基准值，比基准值小的在左边序列，比基准值大的在右边序列（一般左右都是无序的），一般选择序列的第一个元素。
一次循环：从后往前比较，用基准值和最后一个值比较，如果比基准值小的就交换位置，如果没有就继续比较下一个，直到找到第一个比基准值小的数才交换，找到这个值之后，又从前往后开始比较，如果有比基准值大的就交换位置，没有就继续比较下一个，直到找到第一个比基准值大的值才交换，直到从前往后的比较索引>从后往前比较的索引，结束第一次循环，此时，对于基准值 来说，左右两边就是有序的了。
public void sort(int[] a,int low,int high){
int start = low;
int end = high;
int key = a[low];
while(end>start){
//从后往前比较
while(end>start&&a[end]>=key)
//如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
end--;
if(a[end]<=key){
int temp = a[end];
a[end] = a[start];
a[start] = temp;
}
//从前往后比较
while(end>start&&a[start]<=key)
//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
start++;
if(a[start]>=key){
int temp = a[start];
a[start] = a[end];
a[end] = temp;
}
//此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的 值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
}
//递归
if(start>low) sort(a,low,start-1);//左边序列。第一个索引位置到关键值索引-1
if(end<high) sort(a,end+1,high);//右边序列。从关键值索引+1到最后一个
}
}
（3）.插入排序
通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应的位置并插入。 插入排序非常类似于整扑克牌。在开始摸牌时，左手是空的，牌面朝下放在桌上。接着，一次从 桌上摸起一张牌，并将它插入到左手一把牌中的正确位置上。为了找到这张牌的正确位置，要将 它与手中已有的牌从右到左地进行比较。无论什么时候，左手中的牌都是排好序的。
如果输入数组已经是排好序的话，插入排序出现最佳情况，其运行时间是输入规模的一个线性函 数。如果输入数组是逆序排列的，将出现最坏情况。平均情况与最坏情况一样，其时间代价是(n2)。
1 public void sort(int arr[])
2 {
3 for(int i =1; i<arr.length;i++)
4 {
5 //插入的数
6 int insertVal = arr[i];
7 //被插入的位置(准备和前一个数比较)
8 int index = i-1;
9 //如果插入的数比被插入的数小
10 while(index>=0&&insertVal<arr[index])
11 {
12 //将把arr[index] 向后移动
13 arr[index+1]=arr[index];
14 //让index向前移动
15 index--;
16 }
17 //把插入的数放入合适位置
18 arr[index+1]=insertVal;
19 }
20 }
（4）.希尔排序
基本思想：先将若干待排序的记录序列分成若干子序列分别进行直接插入排序，待整个序列中的记录基本有序时，再对全体记录进行依次直接插入排序。
- 选择一个增量序列t1，t2...tk，其中ti>tj，tk=1；
- 按增两个序列个数k，对序列进行k趟排序；
- 每趟排序根据对应的增量ti，将待排序列分割成若干长度为m的子序列，分别对各子表进行直接插入排序
1 private void shellSort(int[] a) {
2 int dk = a.length/2;
3 while( dk >= 1 ){
4 ShellInsertSort(a, dk);
5 dk = dk/2;
6 }
7 }
8 private void ShellInsertSort(int[] a, int dk) {
9 //类似插入排序，只是插入排序增量是1，这里增量是dk,把1换成dk就可以了
10 for(int i=dk;i<a.length;i++){
11 if(a[i]<a[i-dk]){
12 int j;
13 int x=a[i];//x为待插入元素
14 a[i]=a[i-dk];
15 for(j=i-dk; j>=0 && x<a[j];j=j-dk){
16 //通过循环，逐个后移一位找到要插入的位置。
17 a[j+dk]=a[j];
18 }
19 a[j+dk]=x;//插入
20 }
21 }
22 }
（5）.归并排序算法
归并排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列 分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
1 public class MergeSortTest {
2 public static void main(String[] args) {
3 int[] data = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7 };
4 print(data);
5 mergeSort(data);
6 System.out.println("排序后的数组：");
7 print(data);
8 }
9 public static void mergeSort(int[] data) {
10 sort(data, 0, data.length - 1);
11 }
12 public static void sort(int[] data, int left, int right) {
13 if (left >= right)
14 return;
15 // 找出中间索引
16 int center = (left + right) / 2;
17 // 对左边数组进行递归
18 sort(data, left, center);
19 // 对右边数组进行递归
20 sort(data, center + 1, right);
21 // 合并
22 merge(data, left, center, right);
23 print(data);
24 }
25 /**
26 * 将两个数组进行归并，归并前面2个数组已有序，归并后依然有序
27 28
29 *
30 * @param data
31 * 数组对象
32 * @param left
33 * 左数组的第一个元素的索引
34 * @param center
35 * 左数组的最后一个元素的索引，center+1是右数组第一个元素的索引
36 * @param right
37 * 右数组最后一个元素的索引
38 */
39 public static void merge(int[] data, int left, int center, int right) {
40 // 临时数组
41 int[] tmpArr = new int[data.length];
42 // 右数组第一个元素索引
43 int mid = center + 1;
44 // third 记录临时数组的索引
45 int third = left;
46 // 缓存左数组第一个元素的索引
47 int tmp = left;
48 while (left <= center && mid <= right) {
49 // 从两个数组中取出最小的放入临时数组
50 if (data[left] <= data[mid]) {
51 tmpArr[third++] = data[left++];
52 } else {
53 tmpArr[third++] = data[mid++];
54 }
55 }
56 // 剩余部分依次放入临时数组（实际上两个while只会执行其中一个）
57 while (mid <= right) {
58 tmpArr[third++] = data[mid++];
59
60
61 }
62 while (left <= center) {
63 tmpArr[third++] = data[left++];
64 }
65 // 将临时数组中的内容拷贝回原数组中
66 // （原left-right范围的内容被复制回原数组）
67 while (tmp <= right) {
68 data[tmp] = tmpArr[tmp++];
69 }
70 }
71 public static void print(int[] data) {
72 for (int i = 0; i < data.length; i++) {
73 System.out.print(data[i] + "\t");
74 }
75 System.out.println();
76 }
77 }
（6）.桶排序算法
桶排序的基本思想是：把数组arr划分为n个大小相同子区间（桶），每个子区间各自排序，最后合并，基数排序是桶排序的一种特殊情况，可以把基数排序当成每个桶里只有一个元素的情况。
- 找出待排序数组中最大值Max、最小值Min
- 使用动态数组ArrayList作为桶，桶里放的元素也用ArrayList存储，桶的数量为(Max-Min)/arr.length+1
- 遍历数组arr，计算每个元素arr[i]放的桶
- 每个桶各自排序
1 public static void bucketSort(int[] arr){
2 int max = Integer.MIN_VALUE;
3 int min = Integer.MAX_VALUE;
4 for(int i = 0; i < arr.length; i++){
5 max = Math.max(max, arr[i]);
6 min = Math.min(min, arr[i]);
7 }
8 //创建桶
9 int bucketNum = (max - min) / arr.length + 1;
10 ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);
11 for(int i = 0; i < bucketNum; i++){
12 bucketArr.add(new ArrayList<Integer>());
13 }
14 //将每个元素放入桶
15 for(int i = 0; i < arr.length; i++){
16 int num = (arr[i] - min) / (arr.length);
17 bucketArr.get(num).add(arr[i]);
18 }
19 //对每个桶进行排序
20 for(int i = 0; i < bucketArr.size(); i++){
21 Collections.sort(bucketArr.get(i));
22 }
（7）.基数排序算法
将所有的比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零，然后从最低位开始，依次进行一次排序，这样从最低位一直到最高位排序完成以后，数列就变成一个有序序列。
1 public class radixSort {
2 inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,101,56,17,18,23,34,15,35,2 5,53,51};
3 public radixSort(){
4 sort(a);
5 for(int i=0;i<a.length;i++){
6 System.out.println(a[i]);
7 }
8 }
9 public void sort(int[] array){
10
11 //确定排序的趟数
12 for(int i=1;i<array.length;i++){
13 if(array[i]>max){
14 max=array[i];
15 }
16 }
17 int time=0;
18 //判断位数;
19 while(max>0){
20 max/=10;
21 time++;
22 }
23 //建立10个队列;
24 List<ArrayList> queue=newArrayList<ArrayList>();
25 for(int i=0;i<10;i++){
26 ArrayList<Integer>queue1=new ArrayList<Integer>();
27 queue.add(queue1);
28 }
29 //进行time次分配和收集;
30 for(int i=0;i<time;i++){
31 //分配数组元素;
32 for(intj=0;j<array.length;j++){
33 //得到数字的第time+1位数;
34 int x=array[j]%(int)Math.pow(10,i+1)/(int)Math.pow(10, i);
35 ArrayList<Integer>queue2=queue.get(x);
36 queue2.add(array[j]);
37 queue.set(x, queue2);
38 }
39 int count=0;//元素计数器
40 //收集队列元素;
41 for(int k=0;k<10;k++){
42 while(queue.get(k).size()>0){
43 ArrayList<Integer>queue3=queue.get(k);
44 array[count]=queue3.get(0);
45 queue3.remove(0);
46 count++;
47 }
48 }
49 }
50 }
51 }