程序員必備排序之選擇排序、堆排序

選擇排序的基本思想是：每一趟在後面的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();
    }
}