main函数调用了子函数B，结果在执行完B后程序直接跳转到另外一个子函数C处（C也调用了B，B执行完
直接跳转到C调用B的地方）。这是为什么啊？
我查了查网上的回答，说是数组越界/指针的问题。
请各位大神指点指点出现这种情况问题都有可能是什么？我好自检代码。

代码太长了，不好贴。
我的确是问问题表述不清楚，检讨。。。
问题简单来说是：子函数执行完后没有返回调用它的主函数，而是返回到另外一个函数中（该函数也调用了子函数），这个可能是什么原因造成的？
另外，我说越界指针等问题是网上搜到的一些答案，想从这里得到的就是我遇到的这个问题是否常见？出现这种问题的原因可能是什么？

好的，这是代码，单步调试也做了，从main函数的fft执行完，直接跳到子函数SquareFFT调用fft函数处了。程序不报错，只是就停到那里了

typedef struct _complex_ //复数类型  
{  
    float real;       //实部  
    float imag;       //虚部  
}complex;
void main(short start1, short end1, short start2, short end2, float *x1, float *x2， short N1， short N2){
        float *R1; 
        float *R2; 
        float *g1; 
        float *g2; 
        complex *G1; 
        complex *G2; 

        R1=(float *)malloc(N1*sizeof(float));
    R2=(float *)malloc(N1*sizeof(float));
    g1=(float *)malloc(sizeof(float)*N1);
    g2=(float *)malloc(sizeof(float)*N2);
    G1 = (complex *)malloc(sizeof(complex) * N1);
    G2 = (complex *)malloc(sizeof(complex) * N2);

    for(i=start1;i<end1;i++){
        g1[i-start1]=x1[i];
    }
    for(i=start2;i<end2;i++){
        g2[i-start2]=x2[i];
    }   
   
    memset(G1, 0, sizeof(complex) * N1);
    memset(G2, 0, sizeof(complex) * N2);

    for (i = 0; i < N1; i++)             //实部赋值，虚部为零
    {
        G1[i].real = g1[i];
    }
    for (i = 0; i < N2; i++)             //实部赋值，虚部为零
    {
        G2[i].real = g2[i];
    }
    
    fft(N1,G1);                //程序执行到此处出现问题
    fft(N2,G2);
}


子函数1
//傅里叶变化
void fft(int N,complex *f)
{
    complex t,wn;//中间变量
    int i,j,k,m,n,l,r,M;
    int la,lb,lc;
    /*----计算分解的级数M=log2(N)----*/
    for(i=N,M=1;(i=i/2)!=1;M++);
    /*----按照倒位序重新排列原信号----*/
    for(i=1,j=N/2;i<=N-2;i++)
    {
        if(i<j)
        {
            t=f[j];
            f[j]=f[i];
            f[i]=t;
        }
        k=N/2;
        while(k<=j)
        {
            j=j-k;
            k=k/2;
        }
        j=j+k;
    }

    /*----FFT算法----*/
    for(m=1;m<=M;m++)               //每一级
    {
        la=pow(2.0,m);              //la=2^m代表第m级每个分组所含节点数   即信号点数N
        lb=la/2;                    //lb代表第m级每个分组所含碟形单元数   即N/2
                                    //同时它也表示每个碟形单元上下节点之间的距离
        /*----碟形运算----*/
        for(l=1;l<=lb;l++)
        {
            r=(l-1)*pow(2.0,M-m);
            for(n=l-1;n<N-1;n=n+la)     //遍历每个分组，分组总数为N/la
            {
                lc=n+lb;                //n,lc分别代表一个碟形单元的上、下节点编号
                Wn_i(N,r,&wn,1);        //wn=Wnr
                c_mul(f[lc],wn,&t);     //t = f[lc] * wn复数运算
                c_sub(f[n],t,&(f[lc]));//f[lc] = f[n] - f[lc] * Wnr
                c_plus(f[n],t,&(f[n]));//f[n] = f[n] + f[lc] * Wnr
            }
        }
    }
}

子函数2
void squareFFT(int iLength, float *pSrc, float *pResult)
{
    int iLoop;
    complex *pstSrc = (complex *)malloc(sizeof(complex) * iLength);
    if (NULL == pstSrc)
    {
    printf("source wrong");
    }
    memset(pstSrc, 0, sizeof(complex) * iLength);

    for (iLoop = 0; iLoop < iLength; iLoop++)             //实部赋值，虚部为零
    {
        pstSrc[iLoop].real = pSrc[iLoop];
    }

    fft(iLength, pstSrc);                                  //////单步调试，main函数调用了fft执行完就跳到这一步了

    for (iLoop = 0; iLoop < iLength; iLoop++)
    {
        pResult[iLoop] = pstSrc[iLoop].real * pstSrc[iLoop].real + pstSrc[iLoop].imag * pstSrc[iLoop].imag;
    }

    free(pstSrc);
    
}

没有交叉调用，也试过单步调试。
代码已经贴出来了，多谢回答。

代码已贴