如何在Python中对一个向量中的两个向量进行排序？

我需要编写一个函数来接收两个已经按升序排序的数组（a[]和B[]），它的函数用a和B的大小之和精确地分配数组C[]，并在C[]中交错a[]和B[]的元素，以便数组C[]按升序排序。尽可能高效地编写函数。不需要加入数组，也不需要使用冒泡法或插入法对数组C[]进行排序

例如： A[]={1,3,6,7}和B[]={2,4,5}，新向量是C[]={1,2,3,4,5,6,7}

我的代码没有停止运行，我做错了什么

def union(v1, v2):
    c = [0, 0, 0, 0, 0, 0, 0, 0]
    auxv1 = 0
    auxv2 = 0
    i = 0
    j = 0
    k = 0
    while i < len(v1)-1:
        auxv1 = v1[i]
    while j < len(v2)-1:
        auxv2 = v2[j]
    while k < len(c):
        if auxv1 < auxv2:
            c[k] = auxv1
            i += 1
            k += 1
        else:
            c[k] = auxv2
            j += 1
            k += 1
    if i == len(v1)-1 and j == len(v2)-1:
        return c

def接头（v1、v2）： c=[0,0,0,0,0,0,0,0,0] auxv1=0 auxv2=0 i=0 j=0 k=0 当i您可以迭代两个列表，然后在列表

c

中添加

a

或

b

的元素，其中一个元素较小。
下面是一个例子

c=[]
i = j = 0

while True:
    if j == len(b):
        c+=a[i:]
        break
    elif i == len(a):
        c+=b[j:]
        break
    elif a[i] < b[j]:
        c.append(a[i])
        i+=1
    else:
        c.append(b[j])
        j+=1

c=[]
i=j=0
尽管如此：
如果j==len（b）：
c+=a[i:]
打破
elif i==len（a）：
c+=b[j:]
打破
如果a[i]

---

就两个列表的长度而言，这种方法的时间复杂度是线性的。

@newbie编写了一个非常清晰的算法，该算法也非常快——它进行的列表操作的数量正好等于结果中的元素数量，即线性

但是，通过查看一个列表中的值的运行情况，可以找到一个次线性算法，该算法应该在另一个列表中的下一个值之前插入

我猜这可以在运行时间较长且运行时间较长的列表上执行得更快。。（和往常一样，在性能方面，您需要使用自己的数据进行测试）

a=[1,3,6,7]
b=[2,4,5,9,11,12,13,14,15,16]
c=[]
a1=a2=b1=b2=0
alen=len（a）
blen=len（b）
clen=alen+blen
a2+b2

我们不能使用嵌套循环当i停止时，

应该发生什么？在Python中，你不能比
list（sorted（A+B））
更快，因为Python的排序速度惊人（）。你的代码有很多问题，从前两个开始，while循环不会改变循环变量（i和j），因此将永远运行……你想让我们调试你的代码，还是提供一个新的解决方案？@bereal你读过timsort链接了吗？它可能会执行两次运行检查和一次合并，并且将是O（n）——它也将是C代码（并且正确；-），感谢您的解决方案。但是，当我输入两个长度相同的列表时，程序会给出一个错误（“列表索引超出范围-第5行”）。
a = [1,3,6,7]
b = [2,4,5,9,11,12,13,14,15,16]
c = []

a1 = a2 = b1 = b2 = 0
alen = len(a)
blen = len(b)
clen = alen + blen

while a2 + b2 < clen:
    print "processed:", a2 + b2
    if b2 == blen:    # done with b..
        c += a[a1:]   # just append rest of a
        break         # and we're done
    else:
        # find indexes a1..a2 such that all items come before the next b
        next_b = b[b2]
        while a2 < alen and a[a2] < next_b:
            a2 += 1
        c += a[a1:a2]   # extend c with the chunk we've found
        a1 = a2

    if a2 == alen:    # we're done with a
        c += b[b1:]   # just append rest of b
        break         # and we're done
    else:
        next_a = a[a2]
        while b2 < blen and b[b2] < next_a:
            b2 += 1
        c += b[b1:b2]
        b1 = b2

print c