选择排序（JAVA版）

选择排序

①初始状态：无序区为R[1..n]，有序区为空。

②第1趟排序

在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[1]交换，使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

……

③第i趟排序

第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R[i..n](1≤i≤n-1)。该趟排序从当前无序区中选出关键字最小的记录R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区.这样，n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果。

 

优点：稳定，比较次数与冒泡排序一样；

 

缺点：相对之下还是慢。

选择排序改进了冒泡排序，比较次数和冒泡排序一样，交换次数少于冒泡排序。交换次数由冒泡排序0（N*N）减少到0(N)。

//selectSort.java
//select select
public class selectSort 
{
public static void main(String[] args)
{
int maxSize=100;
ArraySel arr;
arr=new ArraySel(maxSize);
arr.insert(77);
arr.insert(99);
arr.insert(44);
arr.insert(55);
arr.insert(22);
arr.insert(88);
arr.insert(11);
arr.insert(00);
arr.insert(66);
arr.insert(33);
arr.display();
arr.selectSort();
arr.display();
}
}


class ArraySel
{
private int[] a;
private int nElems;

//构造函数
public ArraySel(int max)
{
a=new int[max];
nElems=0;
}

//插入数据
public void insert(int value)
{
a[nElems]=value;
nElems++;
}

//显示数组数据
public void display()
{
for(int j=0;j<nElems;j++)
System.out.println(a[j]+" ");
System.out.println(" ");
}

//选择排序
public void selectSort()
{
int out,min,in;
for(out=0;out<nElems-1;out++)
{
min=out;
for(in=out+1;in<nElems;in++)
{
if(a[in]<a[min])
min=in;
}
swap(out,min);
}

}

//交换位置
private void swap(int one,int two)
{
int temp=a[one];
a[one]=a[two];
a[two]=temp;
}
}

交换步骤分析：

原数组：     77 99 44 55 22 88 11 0   66 33 

交换第1次：0  99 44 55 22 88 11 77  66 33    比较9次

交换第2次：0 11 44 55 22 88  99 77  66 33   比较8次

交换第3次：0 11 22 55 44 88  99 77  66 33   比较7次

交换第4次：0 11 22 33 44 88  99 77  66 55   比较6次

交换第5次：0 11 22 33 44 88  99 77  66 55    比较5次

交换第6次：0 11 22 33 44 55  99 77  66 88   比较4次

交换第7次：0 11 22 33 44 55  66 77  99 88   比较3次

交换第8次：0 11 22 33 44 55  66 77  99 88   比较2次

交换第9次：0 11 22 33 44 55  66 77  88 99   比较1次

冒泡排序效率分析：

比较的次数：9+8+7+6+5+4+3+2+1=45

当数组大小为N时，比较的次数为：

(N–1) + (N–2) + (N–3) + ... + 1 = N*(N–1)/2

所以比较的次数大概为N*N/2次比较

比较次数为：0(N*N)

交换次数为：0(N);

时间复杂度为0（N*N）；