Visual Studio 2019：RangeChecks 检测代码检测到超出范围的数组访问。

Question

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <conio.h>
#include <malloc.h>
#include <sys/timeb.h>
#include<math.h>
#include<cstring>
#define LeftChild(i)(2*(i)+1)
#define Cutoff ( 3 )

//基数排序
#define WIDTH 15  //排序数字的最大位数 
#define MAXK 10  //位数划分基于的基数，10表示为10进制划分 

struct TreeNode
{
    int Element;
};
int* Insertsort(int N)// 生成排序所需的数据 
{
    int i = 0;
    int* A;
    srand((unsigned int)time(NULL));
    A = (int*)malloc(sizeof(int) * N);
    for (i = 0; i < N; i++)
    {
        A[i] = (rand() << 16) + rand();
    }
    return A;
}

//插入排序
void Insertionsort(int A[], int N)
{
    int j, p, Tmp;
    for (p = 1; p < N; p++)
    {
        Tmp = A[p];
        for (j = p; j > 0 && A[j - 1] > Tmp; j--)
            A[j] = A[j - 1];
        A[j] = Tmp;
    }

}

//希尔排序
void Shellsort(int A[], int N)
{
    int i, j, Tmp, Increment;
    for (Increment = N / 2; Increment > 0; Increment /= 2)
    {
        for (i = Increment; i < N; i++)
        {
            Tmp = A[i];
            for (j = i; j >= Increment; j -= Increment)
                if (Tmp < A[j - Increment])
                    A[j] = A[j - Increment];
                else
                    break;
            A[j] = Tmp;
        }
    }
}

void percDown(int A[], int i, int N)//堆排序中调用的函数 
{
    int Child, Tmp;
    for (Tmp = A[i]; LeftChild(i) < N; i = Child)
    {
        Child = LeftChild(i);
        if (Child != N - 1 && A[Child + 1] > A[Child])
            Child++;
        if (Tmp < A[Child])
            A[i] = A[Child];
        else
            break;
    }

    A[i] = Tmp;
}
void Swap(int* p1, int* p2) {//交换函数 
    int Tmp;
    Tmp = *p1;
    *p1 = *p2;
    *p2 = Tmp;
}
//堆排序
void Heapsort(int A[], int N)
{
    int i;
    for (i = N / 2; i >= 0; i--)
    {
        percDown(A, i, N);
    }
    for (i = N - 1; i >= 0; i--)
    {
        Swap(&A[0], &A[i]);
        percDown(A, 0, i);
    }
}
void Merge(int A[], int Tmparray[], int Lpos, int Rpos, int RightEnd)//Msort函数中调用的Merge函数 
{
    int i, LeftEnd, NumElements, TmpPos;
    LeftEnd = Rpos - 1;
    TmpPos = Lpos;
    NumElements = RightEnd - Lpos + 1;

    while (Lpos <= LeftEnd && Rpos <= RightEnd)
        if (A[Lpos] <= A[Rpos])
            Tmparray[TmpPos++] = A[Lpos++];
        else
            Tmparray[TmpPos++] = A[Rpos++];
    while (Lpos <= LeftEnd)
        Tmparray[TmpPos++] = A[Lpos++];
    while (Rpos <= RightEnd)
        Tmparray[TmpPos++] = A[Rpos++];

    for (i = 0; i < NumElements; i++, RightEnd--)
    {
        A[RightEnd] = Tmparray[RightEnd];
    }


}

void Msort(int A[], int Tmparry[], int Left, int Right)//归并排序中调用的Msort函数 
{
    int Center;
    if (Left < Right)
    {
        Center = (Left + Right) / 2;
        Msort(A, Tmparry, Left, Center);
        Msort(A, Tmparry, Center + 1, Right);
        Merge(A, Tmparry, Left, Center + 1, Right);
    }
}
//归并排序
void Mergesort(int A[], int N)
{
    int* Tmparry;
    Tmparry =(int *) malloc(N * sizeof(int));
    if (Tmparry != NULL)

        Msort(A, Tmparry, 0, N - 1);
    free(Tmparry);
}
int Median3(int A[], int Left, int Right)//Qsort函数调用的Median3函数 
{
    int Center = (Left + Right) / 2;

    if (A[Left] > A[Center])
        Swap(&A[Left], &A[Center]);
    if (A[Left] > A[Right])
        Swap(&A[Left], &A[Right]);
    if (A[Center] > A[Right])
        Swap(&A[Center], &A[Right]);

    Swap(&A[Center], &A[Right - 1]);
    return A[Right - 1];

}

void Qsort(int A[], int Left, int Right)//快速排序调用的Qsort函数 
{
    int i, j;
    int Pivot;
    if (Left + Cutoff <= Right)
    {
        Pivot = Median3(A, Left, Right);
        i = Left; j = Right - 1;
        for (; ; )
        {
            while (A[++i] < Pivot)
            {
                //空循环体 
            }
            while (A[--j] > Pivot)
            {
                //空循环体 
            }
            if (i < j)
                Swap(&A[i], &A[j]);
            else
                break;

        }

        Swap(&A[i], &A[Right - 1]);
        Qsort(A, Left, i - 1);
        Qsort(A, i + 1, Right);
    }
    else
        Insertionsort(A + Left, Right - Left + 1);
}
//快速排序 
void Quicksort(int* A, int N)
{
    Qsort(A, 0, N - 1);
}
int* InvertedOrder(int A[], int N)//倒序函数 
{
    int i;
    int Tmp;
    for (i = 0; i < N; i++)
    {
        Tmp = A[N];
        A[N] = A[i];
        A[i] = Tmp;
    }
    return A;
}

//基数排序 
void radixSort(int A[], int N);
void innerCountingSort(int A[], int N, int d);
int getDValue(int value, int d);
void radixSort(int A[], int N) {

    int i;
    for (i = 0; i < WIDTH; i++) {
        //    WIDTH为所排数据中最大数据的位数
        //    当 i = WIDTH时，表示所有数据已经排完      
        innerCountingSort(A, N, i);
    }
}
void innerCountingSort(int A[], int N, int d) {

    int i, j, k[MAXK] = { 0 };
    //    MAXK为位数划分基于的基数，以10进制划分  
    int* ip = (int*)malloc(sizeof(int) * N);
    int* bp = (int*)malloc(sizeof(int) * N);


    for (i = 0; i < N; i++) {

        ip[i] = getDValue(A[i], d);
        k[ip[i]]++;
    }

    for (j = 1; j < MAXK; j++) {

        k[j] = k[j] + k[j - 1];
    }

    for (i = N - 1; i >= 0; i--) {

        bp[k[ip[i]] - 1] = A[i];
        k[ip[i]]--;
    }

    for (i = 0; i < N; i++) {
        A[i] = bp[i];
    }

    free(ip);
    free(bp);
}
//获取一个数第d位数的值，位数索引从0开始  
int getDValue(int value, int d) {

    for (; d > 0 && value > 0; d--) {

        value = value / MAXK;
    }

    return value % MAXK;
}

void print(int* p, int N) {

    int i;
    for (i = 0; i < N; i++) {

        printf("%d\t", p[i]);
    }
}

int main()
{
    int N=0, k;
    int a, b, c, d, e, f;
    int* A, * sort1;
    struct timeb time1, time2;
    sort1 = (int*)malloc(sizeof(int) * N);

    printf("请输入需要生成的随机数的个数：");
    scanf("%d", &N);

    printf("输入数据类型（1 - 随机，2 - 正序，3 - 逆序）\n");
    scanf("%d", &k);

    A = Insertsort(N);

    if (k == 1)
    {

    }
    else if (k == 2)
    {
        Shellsort(A, N);
    }
    else
    {
        Shellsort(A, N);
        A = InvertedOrder(A, N);

    }
    memcpy(sort1, A, N);//将sort数据备份到sort1 

    ftime(&time1);
    Insertionsort(A, N);
    ftime(&time2);
    printf("插入排序。。。。。。。完毕！！！\n");
    a = (time2.time - time1.time) * 1000 + (time2.millitm - time1.millitm);

    memcpy(A, sort1, N);//将sort1数据拷贝到sort ，保证数据的无序性 
    ftime(&time1);
    Shellsort(A, N);
    ftime(&time2);
    printf("希尔排序。。。。。。。完毕！！！\n");
    b = (time2.time - time1.time) * 1000 + (time2.millitm - time1.millitm);

    memcpy(A, sort1, N);
    ftime(&time1);
    Heapsort(A, N);
    ftime(&time2);
    printf("堆 排 序。。。。。。。完毕！！！\n");
    c = (time2.time - time1.time) * 1000 + (time2.millitm - time1.millitm);

    memcpy(A, sort1, N);
    ftime(&time1);
    Mergesort(A, N);
    ftime(&time2);
    printf("归并排序。。。。。。。完毕！！！\n");
    d = (time2.time - time1.time) * 1000 + (time2.millitm - time1.millitm);

    memcpy(A, sort1, N);
    ftime(&time1);
    Quicksort(A, N);
    ftime(&time2);
    printf("快速排序。。。。。。。完毕！！！\n");
    e = (time2.time - time1.time) * 1000 + (time2.millitm - time1.millitm);

    memcpy(A, sort1, N);
    ftime(&time1);
    Quicksort(A, N);
    ftime(&time2);
    printf("基数排序。。。。。。。完毕！！！\n");
    f = (time2.time - time1.time) * 1000 + (time2.millitm - time1.millitm);

    printf("- - -排序时间（单位：ms）- - -\n");
    printf("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n");
    printf("|  + 插入 +  |  + 希尔 +  |  + 堆 +  |  + 归并 +  |  + 快速+  |  + 基数 + |  \n");
    printf("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n");
    printf("|  +  %d  +   |  +   %d +   |  +  %d  +  |  +  %d  +  |  +  %d  +  |  +  %d  + |  \n", a, b, c, d, e, f);
    printf("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n");


}