C++ 两个大小不同的排序数组的中值

我是从极客那里为极客解决这个问题的，但当我实现相同的代码时，我就开始为输入解决这个问题 A[]={1,2,3} B[]={3,6,9,12} 它给出了错误的输出为6，但它应该是3，有人请告诉我我的代码的问题

//code

#include<iostream>
#include<cmath>

using namespace std;


float single_median(int arr[],int size)//method to find median in an arr

{
    if(size == 0)
    return -1;

    else if(size%2==0)
    return (arr[size/2] + arr[size/2 -1])/2.0;

    else
    return arr[size/2];
}

float medianOf2(int a,int b)//median of two numbers
{
    return ((a+b)/2.0);
}

int medianOf3(int a,int b,int c)//median of 3 numbers
{
    int maximum = max(a,max(b,c));
    int minimum = min(a,min(b,c));
    return ((a+b+c) - maximum - minimum);
}

int medianOf4(int a, int b,int c,int d)//median of 4 numbers
{
    int maximum = max(a,max(b,max(c,d)));
    int minimum = min(a,min(b,min(c,d)));
    return ((a+b+c+d) - maximum - minimum);
}

int find_median(int A[],int m,int B[],int n)
{
    if(m<n)//here we will keep in mind that A is larger than B else we swap
    return find_median(B,n,A,m);

    if(n==0)//if smaller array has no element just find the median of larger array
    return single_median(A,m);

    if(n==1)//if smaller array has one element
    {
        if(m==1)
        return (A[0]+B[0])/2.0;//if both has one element just return the average

        else if(m&1)//when larger array has odd elements
        return medianOf2(medianOf3(B[0],A[m/2 - 1],A[m/2 + 1]),A[m/2]);

        else//for e
        return medianOf3(B[0],A[m/2],A[m/2 -1]);

    }

    if(n==2)
    {
        if(m==2)
        return medianOf4(A[0],B[0],A[1],B[1]);

        else if(m&1)
        return medianOf3(max(B[0],A[m/2 -1]),min(B[1],A[m/2 +1]),A[m/2]);

        else
        return medianOf4(max(B[0],A[m/2 -2]),min(B[1],A[m/2 +1]),A[m/2],A[m/2 -1]);

    }

    int mid_m = (m-1)/2;
    int mid_n = (n-1)/2;

    if(A[mid_m]<B[mid_n])
        find_median(A + mid_m,m/2 +1 ,B,n - mid_n);
    else
        find_median(A,n/2 +1, B + mid_n, n/2 + 1);


}

int main()
{
    int B[] = {1,2,3};
    int A[] = {3,6,9,12};

    cout<<find_median(A,4,B,3);
    return 0;
}

//代码
#包括
#包括
使用名称空间std；
float single_median（int-arr[]，int-size）//在arr中查找中值的方法
{
如果（大小==0）
返回-1；
else if（大小%2==0）
返回（arr[size/2]+arr[size/2-1]）/2.0；
其他的
返回arr[size/2]；
}
float medianOf2（inta，intb）//两个数字的中间值
{
回报率（（a+b）/2.0）；
}
int medianOf3（int a，int b，int c）//3个数字的中间值
{
int max=max（a，max（b，c））；
最小整数=最小（a，最小（b，c））；
返回（（a+b+c）-最大值-最小值）；
}
int medianOf4（int a，int b，int c，int d）//4个数字的中间值
{
int max=max（a，max（b，max（c，d））；
最小整数=min（a，min（b，min（c，d））；
返回（（a+b+c+d）-最大-最小）；
}
int find_中位数（int A[]，int m，int B[]，int n）
{
如果（m在返回结果之前忘记在
medianOf4
函数中将结果除以2.0：

int medianOf4(int a, int b,int c,int d)//median of 4 numbers
{
    int maximum = max(a,max(b,max(c,d)));
    int minimum = min(a,min(b,min(c,d)));
    return ((a+b+c+d) - maximum - minimum) / 2.0; # <-- forgot to add "/ 2.0"
}

intmedianof4（inta，intb，intc，intd）//4个数字的中间值
{
int max=max（a，max（b，max（c，d））；
最小整数=min（a，min（b，min（c，d））；
返回值（（a+b+c+d）-最大值-最小值）/2.0；
公共类解决方案{
公共双FindMediaTransortedArray（int[]nums1，int[]nums2）{
如果此处不允许（nums1==null | | | nums1.length“告诉我代码的问题”之类的问题，请参阅。好的，先生，我不会重复此操作，谢谢通知。
返回（（a+b+c+d）-最大-最小）；
@skvatss如果您认为此答案有助于解决您的问题，请单击绿色复选标记将其标记为“已接受”。这将有助于社区将注意力集中在未回答的问题上。
public class Solution {
public double FindMedianSortedArrays(int[] nums1, int[] nums2) {
    if(nums1== null || nums1.Length<1)
        return result(nums2);
    else if(nums2== null || nums2.Length<1)
        return result(nums1);

    int[] merged = new int[nums1.Length + nums2.Length];
    int num1Ind=0;
    int num2Ind=0;
    int currInd = 0;

    while(num1Ind<nums1.Length &&  num2Ind<nums2.Length){
        if(nums1[num1Ind]< nums2[num2Ind])
            merged[currInd++]=nums1[num1Ind++];
        else
            merged[currInd++]=nums2[num2Ind++];
    }

    if(num2Ind<nums2.Length)
        for(int i=num2Ind; i<nums2.Length; i++)
           merged[currInd++]=nums2[i];
    else if(num1Ind<nums1.Length)
        for(int i=num1Ind; i<nums1.Length; i++)
           merged[currInd++]=nums1[i];

    return result(merged);
}

private double result(int[] merged){
    if(merged.Length==1)
        return merged[0];
     if((merged.Length)%2 !=0)
        return (double)merged[merged.Length/2];
     return (double)(merged[merged.Length/2-1] + merged[merged.Length/2])/2;


}