排序算法相关代码

SortFunc.h

//
//  SortFunc.hpp
//  FirstP
//
//  Created by 赫赫 on 2023/11/1.
//  排序算法代码

#ifndef SortFunc_hpp
#define SortFunc_hpp
#define MaxSize 100
#include 
#include 
#include 
#include 
using namespace std;

#endif /* SortFunc_hpp */

//待排序数组A，数组元素个数n
//一、插入排序
//直接插入排序(带哨兵)
void InsertSort(int A[],int n);
//折半插入排序(带哨兵)
void HalfInsertSort(int A[],int n);
//希尔排序
void ShellSort(int A[],int n);

//二、交换排序
//交换功能
void swap(int &a,int &b);
//冒泡排序
void BubbleSort(int A[],int n);
//快排(重点！！！)
//用第一个元素将待排序序列划分为左右两个部分，每一次划分确定一个元素位置
int Partition(int A[],int low,int high);
//快排函数体
void QuickSort(int A[],int low,int high);

//三、选择排序
//简单选择排序
void SelectSort(int A[],int n);

//堆排序(重点！！！)
//以k为根的子树调整为大根堆
void HeadAdjust(int A[],int k,int len);
//建立大根堆
void BuildMaxHeap(int A[],int len);
//堆排序函数体(调用上面的两个函数)
void HeapSort(int A[],int len);

//四、归并排序
int *B=(int *)malloc(MaxSize*sizeof(int));
//二路归并排序
void Merge(int A[],int low,int mid,int high);
void MergeSort(int A[],int low,int high);

SortFunc.cpp

//
//  SortFunc.cpp
//  FirstP
//
//  Created by 赫赫 on 2023/11/1.
// 

#include "SortFunc.hpp"

//直接插入排序(带哨兵)
//从前往后，从小到大排序
void InsertSort(int A[],int n){
    int i,j;
    //i从2开始时因为一个元素已经有序
    for(int i=2;i<=n;i++){//前i-1个是已经有序的序列
        if(A[i]high时停止折半查找操作，将high+1及以后的元素往后移
        for(j=i-1;j>=high+1;j--){
            A[j+1]=A[j];
        }
        A[high+1]=A[0];
    }
}
//希尔排序
//对每次分割开的特殊子表进行直接插入操作
void ShellSort(int A[],int n){
    int d,i=0,j=0;
    //此处数据依然是从1开始的，不过下标为0处并不是哨兵，而是暂存单元
    //d为步长
    for(d=n/2;d>=i;d=d/2){//步长变化，每次除以2
        for(i=d+1;i<=n;i++){
            if(A[i]0&&A[0]i;j--){
            if(A[j]=pivot){  //右侧元素大于中枢元素，不移动
            high--;
        }
        A[low]=A[high];         //将右侧小于中枢的元素移到左侧
        while(A[low]<=pivot){   //左侧元素小于中枢元素，不移动
            low++;
        }
        A[high]=A[low];         //将左侧大于中枢的元素移到右侧
    }
    A[low]=pivot;               //将中枢元素放到确定位置
    return low;                 //返回确定的中枢元素位置
}
//快排函数体
void QuickSort(int A[],int low,int high){
    if(lowA[j]){
                min=j;
            }
        }
        if(min!=i){//将最小元素放到前面
            swap(A[min],A[i]);
        }
    }
}

//堆排序(重点！！！)
//调整为大根堆(以k位置元素为根的子树)
void HeadAdjust(int A[],int k,int len){
    A[0]=A[k];//A[0]暂存子树的根节点
    for(int i=2*k;i<=len;i*=2){//这个就是小元素下坠的过程
        if(i=A[i]){
            break;
        }else{
            A[k]=A[i];
            k=i;            //记录修改的位置i，在下一次for循环用i作为根节点和子树去比较
        }
    }
    A[k]=A[0];
    
}
//建立大根堆
void BuildMaxHeap(int A[],int len){
    for(int i=len/2;i>0;i--){//从后往前调整所有非终端结点
        HeadAdjust(A, i, len);
    }
}
//堆排序函数体(调用上面的两个函数)
void HeapSort(int A[],int len){
    BuildMaxHeap(A, len);       //先初始建立大根堆
    for(int i=len;i>1;i--){     //n-1趟的交换和建堆过程
        swap(A[i],A[1]);        //堆顶元素和堆底元素交换
        HeadAdjust(A, 1, i-1);  //把剩余的待排序元素整理成堆
    }
}

//四、归并排序
//空间复杂度主要来自辅助数组B，空间复杂度O(n)
//时间复杂度O(nlog(n)),归并趟数log(n)趟
//二路归并排序Merge操作，时间复杂度O(n)
void Merge(int A[],int low,int mid,int high){
    int i,j,k;
    //将A待排序数组放入B中
    for(k=low;k