Swift函数报Missing return错误的原因咨询（求两有序数组中位数）

我来帮你拆解这个问题。首先，你说得没错——从逻辑上看，while imin <= imax这个循环一定会进入分支触发return，但Swift的编译器是静态类型检查器，它不会运行你的代码去验证逻辑，只会通过代码结构判断是否存在函数走到末尾却没有返回值的可能性。

在你的代码里，编译器没办法100%确定这个while循环一定会执行至少一次（哪怕我们知道逻辑上它肯定会），所以它会认为存在一种极端情况：循环一次都不跑，函数直接走到末尾，没有返回值，于是抛出这个错误。

另外，你的代码还有一个隐藏的逻辑错误，虽然不是当前报错的直接原因，但会导致中位数计算错误：

if m+n % 2 == 1{

这里的运算符优先级有问题，%的优先级比+高，所以实际计算的是m + (n % 2)，而不是你想要的(m + n) % 2，必须加上括号修正。

修复方案 #

1. 添加兜底返回语句 #

在while循环结束后，添加一个编译器认可的返回值（虽然逻辑上永远不会走到这里），用fatalError更能体现这是逻辑上不可能到达的分支。

2. 修正运算符优先级错误 #

把m+n % 2改成(m + n) % 2，确保奇偶判断正确。

完整修复后的代码 #

import UIKit

var num1 = [1,2,2,5]
var num2 = [2,3,9,9]

class Solution {
    func findMedianSortedArrays(_ nums1: [Int], _ nums2: [Int]) -> Double {
        var A = nums1
        var B = nums2
        var m = nums1.count
        var n = nums2.count
        var max_of_left : Int = 0
        var min_of_right = 0
        
        // 确保A是较短的数组，优化二分效率
        if n < m {
            let temp = nums1
            let tempt = m
            A = nums2
            B = temp
            m = n
            n = tempt
        }
        
        guard n != 0 else {
            fatalError("Arrays must be non-empty")
        }

        var imin = 0
        var imax = m
        let half_len = (m + n + 1) / 2

        while imin <= imax {
            let i = (imin + imax) / 2
            let j = half_len - i

            if i > 0 && A[i-1] > B[j] {
                imax = i - 1
            } else if i < m && A[i] < B[j-1] {
                imin = i + 1
            } else {
                // 找到正确的分割点，计算左半部分最大值
                if i == 0 {
                    max_of_left = B[j-1]
                } else if j == 0 {
                    max_of_left = A[i-1]
                } else {
                    max_of_left = max(A[i-1], B[j-1])
                }

                // 总长度为奇数，直接返回左半部分最大值
                if (m + n) % 2 == 1 {
                    return Double(max_of_left)
                }

                // 计算右半部分最小值
                if i == m {
                    min_of_right = B[j]
                } else if j == n {
                    min_of_right = A[i]
                } else {
                    min_of_right = min(A[i], B[j])
                }

                // 总长度为偶数，返回平均值
                return Double(max_of_left + min_of_right) / 2.0
            }
        }
        
        // 兜底返回，逻辑上永远不会执行到这里
        fatalError("Invalid input or logic error")
    }
}

let a = Solution()
print(a.findMedianSortedArrays(num1, num2)) // 输出2.5，符合预期

验证 #

修复后，编译器的「missing return」错误会消失，同时运算符优先级的修正也保证了奇偶长度的判断正确。测试你的示例输入num1 = [1,2,2,5]和num2 = [2,3,9,9]，总长度是8（偶数），中位数是(2+3)/2=2.5，代码输出正确。

内容的提问来源于stack exchange，提问作者Janghyup Lee