简单排序有：冒泡排序、选择排序、插入排序
高级排序有：快速排序、希尔排序、归并排序
冒泡排序和选择排序的区别： 冒泡排序交易值的次数比较多，相互交换
选择排序是比较值，然后获取值最小的index，然后的去交换值，是第一个和最小的交换，选择排序交换的次数比较少
1、冒泡排序法int[] arr={9,257,1,26,5,69};//定义一个数组
int temp;//定义一个临时变量
for(int i=0;i<arr.length-1;i++){ //外层循环遍历 (数组长度-1)次
for(int j=0;j<arr.length-i-1;j++){ //内存循环每循环一遍会把最大值移到另一端，所以出现 -1次
if(arr[j+1]<arr[j]){
temp = arr[j]; //临时变量，交换
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
2、快速排序
快速排序的原理：选择一个关键值作为基准值。比基准值小的都在左边序列（一般是无序的），比基准值大的都在右边（一般是无序的）。一般选择序列的第一个元素。
public class FastSort{
public static void main(String []args){
System.out.println("Hello World");
int[] a = {12,20,5,16,15,1,30,45,23,9};
int start = 0;
int end = a.length-1;
sort(a,start,end);
for(int i = 0; i<a.length; i++){
System.out.println(a[i]);
}
}
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、插入排序
for(int index = 1; index<length; index++){//外层向右的index，即作为比较对象的数据的index
int temp = array[index];//用作比较的数据
int leftindex = index-1;
while(leftindex>=0 && array[leftindex]>temp){//当比到最左边或者遇到比temp小的数据时，结束循环
array[leftindex+1] = array[leftindex];
leftindex--;
}
array[leftindex+1] = temp;//把temp放到空位上
}
4、选择排序
for(int i=0; i<length-1; i++){
int minIndex = i;
for(int j=minIndex+1;j<length;j++){
if(array[j]<array[minIndex]){
minIndex = j;
}
}
int temp = array[i];
array[i] = array[minIndex];
array[minIndex] = temp;
}
5、希尔排序
步骤1：比如现在有数组{82 ,31 ,29 ,71, 72, 42, 64, 5,110} 第一次取增量设置为array.length/2 = 4 先从82开始以4为增量遍历直到末尾，得到（82,42） 排序得到{42 ,31 ,29 ,71, 72, 82, 64, 5,110}。 然后从第二个数31开始重复上一个步骤，得到（31,64） 排序得到{42 ,31 ,29 ,71, 72, 82, 64, 5,110}....... 以4为增量的遍历完数组之后，得到的结果是{42 ,31,5,71,72,82,64,29,110}
然后重新区增量,这儿设定为incrementNum/2 = 2，对{42 ,31,5,71,72,82,64,29,110}重复步骤1。 完事之后，在取新的增量，重复步骤1。 直到取到的增量小于1，退出循环。
/**
* 希尔排序
* @param arrays 需要排序的序列
*/
public static void sort(int[] arrays){
if(arrays == null || arrays.length <= 1){
return;
}
//增量
int incrementNum = arrays.length/2;
while(incrementNum >=1){
for(int i=0;i<arrays.length;i++){
//进行插入排序
for(int j=i;j<arrays.length-incrementNum;j=j+incrementNum){
if(arrays[j]>arrays[j+incrementNum]){
int temple = arrays[j];
arrays[j] = arrays[j+incrementNum];
arrays[j+incrementNum] = temple;
}
}
}
//设置新的增量
incrementNum = incrementNum/2;
}
}
6、归并排序
import java.util.Arrays;
/**
*归并排序算法
*
*/
public class MergerSort {
private static void sort(int[] array, int start, int end) {
if (start >= end)
return;
int mid = (start + end) >> 1;
// 递归实现归并排序
sort(array, start, mid);
sort(array, mid + 1, end);
mergerSort(array, start, mid, end);
}
// 将两个有序序列归并为一个有序序列(二路归并)
private static void mergerSort(int[] array, int start, int mid, int end) {
// TODO Auto-generated method stub
int[] arr = new int[end + 1]; // 定义一个临时数组，用来存储排序后的结果
int low = start; // 临时数组的索引
int left = start;
int center = mid + 1;
// 取出最小值放入临时数组中
while (start <= mid && center <= end) {
arr[low++] = array[start] > array[center] ? array[center++] : array[start++];
}
// 若还有段序列不为空，则将其加入临时数组末尾
while (start <= mid) {
arr[low++] = array[start++];
}
while (center <= end) {
arr[low++] = array[center++];
}
// 将临时数组中的值copy到原数组中
for (int i = left; i <= end; i++) {
array[i] = arr[i];
}
}
public static void main(String[] args) {
int[] array = { 58, 48, 69, 87, 49, 59, 25, 35, 68, 48 };
sort(array, 0, array.length - 1);
System.out.println(Arrays.toString(array));
}
}