堆排序-----数据结构

        堆排序，是对堆特性的充分利用。如果想要对数组进行升序排序，则可以创建大堆；如果想要对数组进行降序排序，则可以创建小堆。本次博客主要讲述数组的升序排序，对大堆的创建与删除操作。

        大堆排序的原理：首先对数组进行调整使其具有大堆的特性（子结点的关键字值小于父结点的关键字值），对于大堆的创建，将会以俩种方法进行讲述（一、上浮式调整；二、下沉式调整）。

上浮式调整：

        1.对于数组中的每一个元素，以新元素置于数组尾部的方式进行插入；

        2.对新插入的元素进行调整（将新插入关键字值与其父结点关键字的值进行比较，如果小于父结点关键字的值则进行交换，随后将f结点赋予子结点，求新子结点的父结点，并以此类推，直到子结点的下标为0或子结点的关键字值小于父结点值时本轮比较结束，继续插入新的元素，进入下一轮的比较）；

程序代码：

//上浮式调整
void AdjustUp(int array[],size_t size,size_t index){
    size_t child = index;
    size_t parent = (child-1)/2;
    while(child>0){
        if(array[parent] <array[child]){
            swap(&array[parent],&array[child]);
        }else{
            break;
        }
        child = parent;
        parent = (child - 1)/2;
    }
}

下沉式调整：

        1.以数组中第一个非叶子结点为开始结点，从后往前依次进入循环；

        2.以下标所指的结点作为父结点，并对其子结点进行计算，随后进行父结点的关键字值与子结点的关键字的值进行比较，如父结点的关键字值小于子结点的较大关键字值，则进行结点的交换，孩子结点的下标大于size值或父子结点的关键字大于孩子结点较大关键字的值时本轮循环结束，进行下一轮循环。

程序代码：

void AdjustDown(int array[],size_t size,size_t index){
    size_t parent = index;
    size_t child = 2 *parent +1;
    while(child<size){
        if(child+1<size&&array[child+1]>array[child]){
            child = child +1;
        }
        if(array[parent] <array[child]){
            swap(&array[parent],&array[child]);
        }
        parent = child;
        child = 2* parent +1;
    }
    return;
}

堆排序（大堆操作对数组进行升序排序）

        1.创建大堆；

        2.对堆进行删除操作，直至剩余一个元素或无元素时结束

                a）将堆顶元素与最后元素进行交换；

                b）将size值仅仅--操作；

                 c）对堆顶元素进行下沉式调整。

程序代码：

HeapSort为以下沉式创建堆；HeapSort1为以上升式创建堆

//主排序函数实现
void HeapSort(int array[],size_t size){
    if(size<=1){
        return;
    }
    HeapCreate(array,size);
    size_t i = 0;
    for(;i<size;++i){
        HeapPop(array,size-i);
    }
    return;
}

//主排序函数实现
void HeapSort1(int array[],size_t size){
    if(size<=1){
        return;
    }
    HeapCreate1(array,size);
    size_t i = 0;
    for(;i<size;++i){
        HeapPop(array,size-i);
    }
    return;
}

堆的删除代码：

void HeapPop(int array[],size_t size){
    if(size <= 1){
        return;
    }
    swap(&array[0],&array[size-1]);
    --size;
    AdjustDown(array,size,0);
    return;
}

测试代码：

//下沉式调整
void TestHeapSort(){
    printf("\n***********下沉式调整*********************\n");
    int arr[] = {1,3,6,2};
    int size = sizeof(arr)/sizeof(arr[0]);
    printf("排序前：");
    int i = 0;
    for(;i<size;++i){
        printf("%d ",arr[i]);
    }
    printf("\n");
    HeapSort(arr,size);
    printf("排序后：");
    i = 0;
    for(;i<size;++i){
        printf("%d ",arr[i]);
    }
    printf("\n");
    return;
}

//上浮式调整
void TestHeapSort1(){
    printf("\n***********上浮式调整*********************\n");
    int arr[] = {1,3,6,2};
    int size = sizeof(arr)/sizeof(arr[0]);
    printf("排序前：");
    int i = 0;
    for(;i<size;++i){
        printf("%d ",arr[i]);
    }
    printf("\n");
    HeapSort1(arr,size);
    printf("排序后：");
    i = 0;
    for(;i<size;++i){
        printf("%d ",arr[i]);
    }
    printf("\n");
    return;
}
//主函数
int main(){
    TestHeapSort();
    TestHeapSort1();
    return 0;
}

结果显示：