前言

此专栏包含408考研数据结构全部内容，除其中使用到C++引用外，全为C语言代码。使用C++引用主要是为了简化指针的使用，避免二重指针的出现。

已完成内容

[数据结构]：01-顺序表（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：02-单链表（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：03-栈（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：04-循环队列（数组）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：05-循环队列（链表）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：06-队列（链表带头结点）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：07-二叉树（无头结点）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：08-顺序查找（顺序表指针实现形式）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：09-二分查找（顺序表指针实现形式）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：10-二叉排序树（无头结点）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：11-冒泡排序（顺序表指针实现形式）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：12-快速排序（顺序表指针实现形式）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：13-插入排序（顺序表指针实现形式）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：14-选择排序（顺序表指针实现形式）（C语言实现）_Chandni.的博客-CSDN博客

堆排序实现

01-开发环境

语言：C/C++14

编译器：MinGW64

集成开发环境：CLion2022.1.3

02-文件布局

请在CLion集成开发环境中创建C++可执行程序，否则无法运行，原因上面已解释。

03-代码

01-主函数

用于测试堆排序。

// 顺序表以指针形式实现(申请堆空间，可动态控制顺序表大小)--数组实现形式不可以动态控制顺序表大小
#include "./Head/PSeqSearchData.h"
#include "./Source/PSeqListFunction.cpp"
#include "./Source/SortCommon.cpp"
#include "./Source/SortFunction.cpp"

int main() {
    // 顺序表初始化
    PSeqList PSL;
    PSeqListCreate(PSL, 10);
    PSeqListPrint(PSL);

    // 调试内容
//    int Array[] = {2, 3, 1, 5, 1, 10};
    memcpy(PSL.data, Array, sizeof(Array));
//    PSL.data = Array;
//    PSL.ListLength = 6;

    // 堆排序
    HeapSort(PSL.data, PSL.ListLength);
    PSeqListPrint(PSL);
    return 0;
}

02-头文件

用于存储结构体和常量等。

//
// Created by 24955 on 2023-03-02.
// 顺序表以指针形式实现(申请堆空间，可动态控制顺序表大小)-数组实现形式不可以动态控制顺序表大小
//

#ifndef INC_01_SEQUENCESEARCH_PSEQSEARCHDATA_H
#define INC_01_SEQUENCESEARCH_PSEQSEARCHDATA_H
// 头文件
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

// 常量
typedef int ElemType;

// 结构体
// 顺序表结构体(以指针形式实现)
typedef struct {
    ElemType *data;
    int ListLength;
}PSeqList;
#endif //INC_01_SEQUENCESEARCH_PSEQSEARCHDATA_H

03-PSeqListFunction.cpp

用于存储顺序表初始化和打印输出等函数。

//
// Created by 24955 on 2023-03-02.
// 顺序表以指针形式实现(申请堆空间，可动态控制顺序表大小)--数组实现形式不可以动态控制顺序表大小
// 不使用哨兵
//
// 顺序表初始化
void PSeqListCreate(PSeqList &PSList, int Length) {
    /*
     * 1. 为顺序表申请堆空间
     * 2. 根据Length大小设置顺序表长度
     * 3. 随机数初始化顺序表*/
    PSList.ListLength = Length;
    PSList.data = (ElemType *) malloc((PSList.ListLength) * sizeof(ElemType));
    srand(time(NULL));
    for (int i = 0; i < PSList.ListLength; i++) {
        PSList.data[i] = rand() % 100;
    }
}

// 顺序表打印输出
void PSeqListPrint(PSeqList PSList) {
    /*
     * 1. 0号元素为哨兵因此从1号元素开始打印输出*/
    for (int i = 0; i < PSList.ListLength; i++) {
        printf("%3d", PSList.data[i]);
    }
    printf("\n");
}

04-SortCommon.cpp

用于存储排序公用函数。

//
// Created by 24955 on 2023-03-06.
//
// 交换两值元素
void Swap(ElemType &ElemOne, ElemType &ElemTwo) {
    /*
     * 1. 交换两元素值*/
    ElemType TemporaryData;
    TemporaryData = ElemOne;
    ElemOne = ElemTwo;
    ElemTwo = TemporaryData;
}

05-SortFunction.cpp

用于存储堆排序函数。

//
// Created by 24955 on 2023-03-06.
// 堆排序时间复杂度O(n*log2n)，空间复杂度O(1)
//
// 将一颗树调整为最大堆(大根堆)
void AdjustToMaxHeap(ElemType *Data, int ChildPos, int Length) {
    /*
     * 1. 计算父亲、左孩子结点下标
     * 2. 判断孩子结点是否大于数组长度，不大于进入循环
     * 3. 判断是否包含右孩子，并记录较大孩子的下标
     * 4. 比较较大孩子与父亲数值大小
     * 5. 若孩子较大，发生交换，并将当前孩子结点当做父节点，判断其子树是否满足最大堆条件
     * 6. 若父亲较大，则表明后续子树已满足最大堆条件，可结束循环*/
    // 记录父亲结点下标，计算左孩子结点下标
    int ParentPos = ChildPos;
    int SonPos = ParentPos * 2 + 1;
    // 循环判断子树是否满足最大堆条件
    while (SonPos < Length) {
        // 判断是否包含右孩子
        if (SonPos + 1 <= Length - 1) {
            // 比较左、右孩子大小，并记录较大孩子的下标
            if (Data[SonPos + 1] > Data[SonPos]) {
                SonPos++;
            }
        }
        // 比较较大孩子与父亲数值大小
        if (Data[SonPos] > Data[ParentPos]) {
            // 若孩子较大，发生交换
            Swap(Data[SonPos], Data[ParentPos]);
            // 并将当前孩子结点当做父节点，判断其子树是否满足最大堆条件
            ParentPos = SonPos;
            SonPos = ParentPos * 2 + 1;
        } else {
            // 若父亲较大，则表明后续子树已满足最大堆条件，可结束循环
            break;
        }
    }
}

// 堆排序
void HeapSort(ElemType *Data, int Length) {
    /*
     * 1. 先将树调整成一个最大堆
     * 2. 交换0号元素(最大值)与最后一个元素交换
     * 3. 剔除已完成的最后一个元素后调整根树
     * 4. 使其为最大堆，交换0号元素与当前最后一个元素(已排序好的剔除)
     * 5. 循环n-1次即排序完成*/
    // i = Length / 2 - 1;最后一个子树所在位置
    // 对每一颗子树进行操作
    for (int i = Length / 2 - 1; i >= 0; i--) {
        // 生成最大堆
        AdjustToMaxHeap(Data, i, Length);
    }
    // 将0号元素(最大值)与最后一个元素交换
    Swap(Data[0], Data[Length - 1]);

    // 后续均为调整0号根树，数组长度每次-1
    for (int len = Length - 1; len > 0; len--) {
        AdjustToMaxHeap(Data, 0, len);
        Swap(Data[0], Data[len - 1]);
    }
}