三种排序方法的比较

/**
* 对于三种排序方法的比较：冒泡排序，选择排序，插入排序
* 首先对于这三种排序都要进行这样的过程
* 两两比较，然后复制或者交换位置（在程序中交换位置因为涉及到在内存中的移动，所以更消耗性能一点）
*
*对于一个容量为N的数组来说：
*
* 冒泡排序：
* 首先需要比较的次数为N-1,N-2,N-3,N-4,.......1,总共是N*(N-1)/2
* 如果在随机的情况下需要交换的次数基本上是需要比较的次数的一半，

* 因此冒泡排序比较的次数和交换的次数均和N的平方成正比

*如果每次冒泡在遍历比较时加上一个exchange的判断，如果没有交换exchange =0，如果有交换exchange = 1；

*这样使用冒泡的最少比较次数可以变为N-1次

*
* 选择排序
* 首先选择排序需要比较的次数也是N*(N-1)/2
* 需要交换的次数少于N次，
*
* 插入排序
* 对于插入排序第一次最多需要一次，第二次最多需要两次，第三次最多需要三次，第N-1次最多需要N-1次
* 所以在随机的情况下，插入排序基本上需要N*(N-1)/4，在比较的次数方面比冒泡排序快了一倍
* 在交换的次数方面，交换的次数等于比较的次数，也为N*(N-1)/4，所以综合以上的话，插入排序要比选择排序稍微快一点
* 但是对于插入排序，如果一个数组是逆序，那么其效率就会下降，因为其比较的次数和交换的次数都会变成N*(N-1)/2。
*
* 对于上述三种排序来讲，都是外层循环嵌套内层循环，所以很容易让人怀疑其效率是O(N的平方)级别的
*
*/

/*
* 冒泡排序
*/
public static int[] sort(int[] arrays)
{
int length = arrays.length;

int max ;

int exchange = 1;//如果比那里一次后发现

for(int i=length-1;i>0,exchange==0;i--)

{

exchange = 0；

for(int j=0;j<i;j++)
{
if(arrays[j]>arrays[j+1])
{
max = arrays[j];
arrays[j] = arrays[j+1];

arrays[j+1] = max;

exchange = 1;

}
}
}
return arrays;
}

/**
* 选择 排序
* @param arrays
* @return
*/
public static int[] sort(int[] arrays)
{
int length = arrays.length;
int min ;
int index ;
for(int i=0;i<length-1;i++)
{
min = arrays[i];
index = i;
for(int j=i;j<length;j++)
{
if(min>arrays[j])
{
min = arrays[j];
index = j;
}
}
arrays[index] = arrays[i];
arrays[i] = min;
}
return arrays;
}

/**
* 插入排序
*/
public static int[] sort(int[] arrays)
{
int length = arrays.length;
int min;
for(int i=1;i<length;i++)
{
min = arrays[i];
for(int j=i-1;j>=0;j--)
{
if(min<arrays[j])
{
arrays[j+1] = arrays[j];
arrays[j] = min;
}
}
}
return arrays;
}