求两个有序数组的中位数的几种方法
思路一:
def median_1(A, B):
# 思路一: 先组合成一个有序数列,再取中位数
# 时间复杂度O(m+n)
len_A = len(A)
len_B = len(B)
C = []
if len_A == len_B == 0:
raise ValueError
i = j = 0
for k in range(0, len_A + len_B):
if j == len_B or (i < len_A and A[i] <= B[j]):
C.append(A[i])
i += 1
else:
C.append(B[j])
j += 1
half = (len_A + len_B) // 2
if (len_A + len_B) % 2 == 0:
return (C[half - 1] + C[half]) / 2
else:
return C[half]
思路二:
def median_2(A, B):
# 思路二: 没有必要完全产生出第三个列表,我们在一开始就可以知道需要取的索引,且可以用变量记录而不新建列表
# 时间复杂度: O((m+n)/2) => O(m+n)
len_A = len(A)
len_B = len(B)
if len_A == len_B == 0:
raise ValueError
half = (len_A + len_B) // 2 + 1
pre = cur = i = j = 0
for k in range(0, half):
if j == len_B or (i < len_A and A[i] <= B[j]):
pre = cur
cur = A[i]
i += 1
else:
pre = cur
cur = B[j]
j += 1
if (len_A + len_B) % 2 == 0:
return (pre + cur) / 2
else:
return cur
思路三:
def median_3(A, B, k=None):
# 思路三: 求中位数的问题可以看作是求第(m+n)/2小的数的问题.如果是偶数个,则是第(m+n)/2小和第(m+n)/2+1小的均值.
# 时间复杂度: O(log(m+n))
m, n = len(A), len(B)
if m > n:
n, m, A, B = m, n, B, A
if n == 0:
raise ValueError
if k == None:
k1 = (m + n + 1) // 2
k2 = (m + n + 2) // 2
return (median_3(A, B, k1) + median_3(A, B, k2)) / 2
if m == 0:
return B[k - 1]
if k == 1:
return A[0] if A[0] <= B[0] else B[0]
half = k // 2
index_A = min(m - 1, half - 1)
index_B = min(n - 1, half - 1)
if A[index_A] <= B[index_B]:
return median_3(A[index_A + 1:], B, k - index_A - 1)
else:
return median_3(A, B[index_B + 1:], k - index_B - 1)
思路四:
def median_4(A, B):
# 思路四:二分法, i = 0 ~ m, j = (m + n + 1) / 2 - i, 需保证j>=0, 即n>=m
# 时间复杂度: O(log(min(m,n)))
m, n = len(A), len(B)
if m > n:
m, n, A, B = n, m, B, A
if n == 0:
raise ValueError
i_min = 0
i_max = m
half = (m + n + 1) // 2
while i_min <= i_max:
i = (i_min + i_max) // 2
j = half - i
if i > 0 and A[i - 1] > B[j]:
# i太大了
i_max = i - 1
elif i < m and A[i] < B[j - 1]:
# i太小了
i_min = i + 1
else:
if i == 0:
max_of_left = B[half - 1]
elif j == 0:
max_of_left = A[half - 1]
else:
max_of_left = max(A[i - 1], B[j - 1])
if (m + n) % 2 == 1:
return max_of_left
if i == m:
min_of_right = B[j]
elif j == n:
min_of_right = A[i]
else:
min_of_right = min(A[i], B[j])
return (max_of_left + min_of_right) / 2
