Java算法排序之--简单排序、堆排序

简单选择排序

（1）基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；

然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。

（2）实例：

（3）用java实现

public class selectSort {  
    public selectSort(){  
        int a[]={1,54,6,3,78,34,12,45};  
        int position=0;  
        for(int i=0;i<a.length;i++){  
              
            int j=i+1;  
            position=i;  
            int temp=a[i];  
            for(;j<a.length;j++){  
            if(a[j]<temp){  
                temp=a[j];  
                position=j;  
            }  
            }  
            a[position]=a[i];  
            a[i]=temp;  
        }  
        for(int i=0;i<a.length;i++)  
            System.out.println(a[i]);  
    }  
}
堆积排序(Heapsort)是指利用堆积树（堆）这种资料结构所设计的一种排序算法，可以利用数组的特点快速定位指定索引的元素。堆排序是不稳定的排序方法，辅助空间为O(1)， 最坏时间复杂度为O(nlog2n) ，堆排序的堆序的平均性能较接近于最坏性能。 
堆排序利用了大根堆(或小根堆)堆顶记录的关键字最大(或最小)这一特征，使得在当前无序区中选取最大(或最小)关键字的记录变得简单。
（1）用大根堆排序的基本思想
① 先将初始文件R[1..n]建成一个大根堆,此堆为初始的无序区
② 再将关键字最大的记录R[1](即堆顶)和无序区的最后一个记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，且满足R[1..n-1].keys≤R[n].key
③由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，由此得到新的无序区R[1..n-2]和有序区R[n-1..n]，且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。
……
直到无序区只有一个元素为止。
（2）大根堆排序算法的基本操作： 
① 初始化操作：将R[1..n]构造为初始堆；
② 每一趟排序的基本操作：将当前无序区的堆顶记录R[1]和该区间的最后一个记录交换，然后将新的无序区调整为堆(亦称重建堆)。
注意： 
①只需做n-1趟排序，选出较大的n-1个关键字即可以使得文件递增有序。
②用小根堆排序与利用大根堆类似，只不过其排序结果是递减有序的。堆排序和直接选择排序相反：在任何时刻堆排序中无序区总是在有序区之前，且有序区是在原向量的尾部由后往前逐步扩大至整个向量为止。
代码实现：
public class Test {   
public static int[] Heap = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 }; // 预设数据数组   
public static void main(String args[]) {   
int i; // 循环计数变量   
int Index = Heap.length; // 数据索引变量   
System.out.print("排序前: ");   
for (i = 1; i < Index - 1; i++)   
System.out.printf("%3s", Heap);   
System.out.println("");   
HeapSort(Index - 2); // 堆排序   
System.out.print("排序后: ");   
for (i = 1; i < Index - 1; i++)   
System.out.printf("%3s", Heap);   
System.out.println("");   
}   
/**   
* 建立堆   
*/   
public static void CreateHeap(int Root, int Index) {   
int i, j; // 循环计数变量   
int Temp; // 暂存变量   
int Finish; // 判断堆是否建立完成   
j = 2 * Root; // 子节点的Index   
Temp = Heap[Root]; // 暂存Heap的Root 值   
Finish = 0; // 预设堆建立尚未完成   
while (j <= Index && Finish == 0) {   
if (j < Index) // 找最大的子节点   
if (Heap[j] < Heap[j + 1])   
j++;   
if (Temp >= Heap[j])   
Finish = 1; // 堆建立完成   
else {   
Heap[j / 2] = Heap[j]; // 父节点 = 目前节点   
j = 2 * j;   
}   
}   
Heap[j / 2] = Temp; // 父节点 = Root值   
}   
public static void HeapSort(int Index) {   
int i, j, Temp;   
// 将二叉树转成Heap   
for (i = (Index / 2); i >= 1; i--)   
CreateHeap(i, Index);   
// 开始进行堆排序   
for (i = Index - 1; i >= 1; i--) {   
Temp = Heap; // Heap的Root值和最后一个值交换   
Heap = Heap[1];   
Heap[1] = Temp;   
CreateHeap(1, i); // 对其余数值重建堆   
System.out.print("排序中: ");   
for (j = 1; j <= Index; j++)   
System.out.printf("%3s",Heap[j]);   
System.out.println("");   
}   
}   
} 
堆可以被看成是一棵树，结点在堆中的高度可以被定义为从本结点到叶子结点的最长简单下降路径上边的数目；定义堆的高度为树根的高度。我们将看到，堆结构上的一些基本操作的运行时间至多是与树的高度成正比，为O（lgn）。通过阅读本文，希望能帮助到你