3.1 简单选择排序
原理：每一趟从待排序的记录中选出最小的元素，顺序放在已排好序的序列最后，直到全部记录排序完毕。也就是：每一趟在n-i+1(i=1，2，…n-1)个记录中选取关键字最小的记录作为有序序列中第i个记录。
代码实现：
public static void choose(int n){
int[] a=new int[n];
for(int i=0;i<n;i++){
a[i]=(int)(Math.random()*100);
}
for(int i=0;i<n-1;i++){
for(int j=i+1;j<n;j++){
if(a[i]>a[j]){
a[i]=a[j]+(a[j]=a[i])*0;
}
}
}
for(int i:a){
System.out.print(i+" ");
}运行结果：
16 32 42 48 73
Process finished with exit code 03.2 堆排序
堆：堆必须同时具备两个特性：1、结构性；2）堆序性
堆是一棵完全二叉树，所谓完全二叉树即叶节点只能出现在最下层和次下层，并且最下面一层的结点都集中在该层最左边的若干位置的二叉树。
- 结构性
堆是一棵完全二叉树，所谓完全二叉树即叶节点只能出现在最下层和次下层，并且最下面一层的结点都集中在该层最左边的若干位置的二叉树。
- 堆序性
堆序性说得通俗一点儿就是，父节点中的元素不小于（不大于）任意子节点的元素。这里的元素在本文中是以数字体现的。注：本文只讨论“大根堆”，即父节点中的元素不小于任意子节点的元素这种情形。所以，在一个大根堆中，一个节点的元素在其子树所有元素组成的集合中必定是最大值。这一结论至关重要。
public class MaxHeap {
int[] heap;
int heapsize;
public MaxHeap(int[] array)
{
this.heap=array;
this.heapsize=heap.length;
}
public void BuildMaxHeap()
{
for(int i=heapsize/2-1;i>=0;i--)
{
Maxify(i);//依次向上将当前子树最大堆化
}
}
public void HeapSort()
{
for(int i=0;i<heap.length;i++)
{
//执行n次，将每个当前最大的值放到堆末尾
int tmp=heap[0];
heap[0]=heap[heapsize-1];
heap[heapsize-1]=tmp;
heapsize--;
Maxify(0);
}
}
public void Maxify(int i)
{
int l=Left(i);
int r=Right(i);
int largest;
if(l<heapsize&&heap[l]>heap[i])
largest=l;
else
largest=i;
if(r<heapsize&&heap[r]>heap[largest])
largest=r;
if(largest==i||largest>=heapsize)//如果largest等于i说明i是最大元素 largest超出heap范围说明不存在比i节点大的子女
return ;
int tmp=heap[i];//交换i与largest对应的元素位置，在largest位置递归调用maxify
heap[i]=heap[largest];
heap[largest]=tmp;
Maxify(largest);
}
public void IncreaseValue(int i,int val)
{
heap[i]=val;
if(i>=heapsize||i<=0||heap[i]>=val)
return;
int p=Parent(i);
if(heap[p]>=val)
return;
heap[i]=heap[p];
IncreaseValue(p, val);
}
private int Parent(int i)
{
return (i-1)/2;
}
private int Left(int i)
{
return 2*(i+1)-1;
}
private int Right(int i)
{
return 2*(i+1);
}
}
public class Demo {
public static void main(String[] args)
{
int[] array=new int[]{1,2,3,4,7,8,9,10,14,16};
MaxHeap heap=new MaxHeap(array);
System.out.println("执行最大堆化前堆的结构：");
printHeapTree(heap.heap);
heap.BuildMaxHeap();
System.out.println("执行最大堆化后堆的结构：");
printHeapTree(heap.heap);
heap.HeapSort();
System.out.println("执行堆排序后数组的内容");
printHeap(heap.heap);
}
private static void printHeapTree(int[] array)
{
for(int i=1;i<array.length;i=i*2)
{
for(int k=i-1;k<2*(i)-1&&k<array.length;k++)
{
System.out.print(array[k]+" ");
}
System.out.println();
}
}
private static void printHeap(int[] array)
{
for(int i=0;i<array.length;i++)
{
System.out.print(array[i]+" ");
}
}
}