package collecttionDemo;
import java.util.Arrays;
public class SortDemo {
public static void main(String[] args)
{
int[] array={8,2,3,7,1} ;
// int[]
arraySSort=sSort(array);
int[]
arrayISort=iSort(array);
// int[]
arrayMSort=mSort(array);
// System.out.println(Arrays.toString(arraySSort));
// System.out.println(Arrays.toString(arrayMSort));
System.out.println(Arrays.toString(arrayISort));
}
/*选择排序:
a 将数组中的每个元素,与第一个元素比较如果这个元素小于第一个元素, 就将这个两个元素交换.
b
每轮使用a的规则, 可以选择出一个最小元素放到第一个位置.
c
经过n-1轮比较完成排序
简单说: 每轮选择最小的放到前面.
优点：移动数据的次数已知（n-1次）；
缺点：比较次数多。*/
public static
int[] sSort(int[] array){
int temp=0;
for(int
i=0;i<array.length;i++){
int
j=i+1;
for(;j<array.length;j++){
if(array[i]>array[j]){
temp=array[i];
array[i]=array[j];
array[j]=temp;
}
}
}
return
array;
}
/*冒泡排序
原理:
a
逐一比较数组中相邻的两个元素, 如果后面 的数字小于前面的数字, 就交换先后元素.
b 经过一个轮次的比较,
一定有一个最大的排在最后的位置.
c 每次比较剩下的元素, 经过n-1次比较, 可以实现排序
简单说:
比较相邻元素,大的向后交换
优点：稳定；
缺点：慢，每次只能移动相邻两个数据。
*/
public static int[] mSort(int[]
array){
int temp=0;
int
length=array.length;
for(int
i=0;i<length;i++){
for(int
j=0;j<length-1;j++){
if(array[j]>array[j+1]){
temp=array[j+1];
array[j+1]=array[j];
array[j]=temp;
}
}
i=0;
length=length-1;
}
return
array;
}
/*插入排序
原理: a 将数组分为两部分,
将后部分的第一张逐一与前部分每一张比较, 如果当前元素小,
就一点被比较元素.
b
找到合理位置插入.
原理说明: 将后组的每一个元素插入到前一组合适的位子上
优点：稳定，快；
缺点：比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是当数据总量庞大的时候，但用链表可以解决这个问题。
*/
public static int[] iSort(int[] array){
int
temp=0;
int length=array.length;
int
j;
for(int
i=1;i<length;i++){
temp=array[i];//待插入的数据
for(j=i-1;j>=0;j--){
if(temp<array[j]){
array[j+1]=array[j];
array[j]=temp;
}
}
}
return
array;
}
}
以上是重温的几种排序，这两天看web方面的东西却发现关于corejava的东西很多都忘记了，这几天恶补中！！！