程序员必备排序之选择排序、堆排序

选择排序的基本思想是：每一趟在后面的n-i+1个待排序元素中选取关键字最小的元素，作为有序子序列的第i个元素，直到第n-1趟做完。

各大排序性能比较：

三、选择排序

3.1直接选择排序

1、基本思想：简单选择排序确实比较简单，其思想就是每次在后面待排序的数组中选择最小的数字放在数组前端。

2、代码实现：

package sort;

public class selectSort {
	public selectSort(int[] a){
		int min;
		for(int i=0;i<a.length-1;i++){
			min = i;		//min 存放最小值得索引
			for(int j=i+1;j<a.length;j++){
				if(a[min]>a[j])		min = j;	//若后面有更小值，min记录其索引
			}
			if(min!=i){
				int temp = a[min];
				a[min]  = a[i];
				a[i] = temp;
			}
		}
	}
	public void print(int[] a){
		for(int i=0;i<a.length;i++)
			System.out.print(a[i]+",");
	}
	public static void main(String[] args){
		 int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
		  selectSort sort = new selectSort(a);
		  sort.print(a);
	}
}

3.2堆排序

1、基本思想：在排序过程中将L[1.2..n]看成一颗完全二叉树的顺序存储结构，利用完全二叉树中双亲节点和孩子节点之间的内在关系，在当前无序区中选择关键字最大（或最小）的元素。

2、代码实现：

package sort;
import java.util.Arrays;
/*
 * 
 * 小根堆算法
 * 
 * */
public class dui {		
     int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
    public  dui(){
       heapSort(a);
    }
    public  void heapSort(int[] a){
        System.out.println("开始排序");
        int arrayLength=a.length;
     
        //循环建堆
        for(int i=0;i<arrayLength;i++){
            buildMaxHeap(a,arrayLength-1-i);		 //建堆
            swap(a,0,arrayLength-1-i);		//交换堆顶和最后一个元素
            System.out.println(Arrays.toString(a));
        }
    }
    private  void swap(int[] data, int i, int j) {
        // TODO Auto-generated method stub
        int tmp=data[i];
        data[i]=data[j];
        data[j]=tmp;
    }
    private void buildMaxHeap(int[] data, int lastIndex) {		//对data数组从0到lastIndex建大顶堆
        for(int i=(lastIndex-1)/2;i>=0;i--){		 //从lastIndex处节点（最后一个节点）的父节点开始
            int k=i;								   				   //k保存正在判断的节点
            while(k*2+1<=lastIndex){			 //如果当前k节点的子节点存在
                int biggerIndex=2*k+1;			 //k节点的左子节点的索引
                if(biggerIndex<lastIndex&&data[biggerIndex]>data[biggerIndex+1]){
                	//如果biggerIndex小于lastIndex，即biggerIndex+1代表的k节点的右子节点存在，且左子节点的值较大
                        biggerIndex++;			 //biggerIndex总是记录较小子节点的索引
                }
                if(data[k]>data[biggerIndex]){        //如果k节点的值大于其较小的子节点的值
                    swap(data,k,biggerIndex);            //交换他们
                    k=biggerIndex;                       //将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值小于其左右子节点的值
                }else{
                    break;
                }
            }
        }
    }
    public static void main(String[] args){
    	dui dui = new dui();
    }
}