java数据结构 3.选择排序

 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 0

3.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]+" ");
    }
}


}