python中两个list该如何排序

Posted 2023-04-11

就是，第一个list1是分数，第二个list2是姓名，然后把list1排序之后，与之相对的把list2排序，这个怎么弄啊，虽然可能问题很简单，但是大神们救救我把Orz，提前将膝盖奉上。

这个其实很简单，先给你提供下思路，别使用自带 sort() 排序。自己写个排序算法，根据list1分数排序，在排序的过程中同时将list2姓名根据list1的排序算法走一遍，即可得到对等的序列。

#-*- coding:utf-8 -*-
name = ['a', 'b', 'c', 'd', 'e', 'f']
score = [96, 97, 92, 93, 99, 91]

def insert_sort2(num_list, name):
    """
    插入排序， 稍微修改之后
    """
    for i in range(len(num_list)-1):
        for j in range(i+1, len(num_list)):
            if num_list[i]>num_list[j]:
                num_list[i],num_list[j] = num_list[j],num_list[i]
                name[i],name[j] = name[j],name[i]
    return num_list,name

print insert_sort2(score, name)

def insert_sort(num_list):
    """
    插入排序，正常的
    """
    for i in range(len(num_list)-1):
        for j in range(i+1, len(num_list)):
            if num_list[i]>num_list[j]:
                num_list[i],num_list[j] = num_list[j],num_list[i]
    return num_list

# 输出： ([91, 92, 93, 96, 97, 99], ['f', 'c', 'd', 'a', 'b', 'e'])
#　使用　list1,list2 = insert_sort(list1, list2) 这样就可以得到了

参考技术A data=[(score, name) for score, name in zip(list1,list2)] #先转化成元组
data.sort() #按照分数排序
list1=[score for score,name in data] #将排好序的分数姓名的元组分开
list2=[name for score,name in data]
这么简单，不需要楼上写的那么复杂 参考技术B #似乎可以更简单
list1 = [1, 2, 3, 4, 5, 6]
list2 = ['a', 'b', 'c', 'd', 'e', 'f']
c = list(zip(list1,list2))
c.sort(reverse = True) #降序
list1[:],list2[:] = zip(*c)
print(list1,list2)
#当然如果使用MongoDB的话，可以直接进行排序

如何在python中合并两个排序的链表[关闭]

【中文标题】如何在python中合并两个排序的链表[关闭]

【英文标题】：how to merge two sorted linked lists in python [closed]

【发布时间】：2014-04-26 18:12:51

【问题描述】：

我尝试了很多算法来合并链表...

def merge_lists(head1,head2):
    if head1 is None and head2 is None:
        return None
    elif head1 is None:
        return head2
    elif head2 is None:
        return head1
    if head1.value <= head2.value:
        result = head1
    else:
        result = head2
    while head1 != None or head2 != None:
        if head1 != None and head2 != None:
            if head1.value <= head2.value:
                result.next = head1
                head1 = head1.next
            else:
                result.next = head2
                head2 = head2.next
        elif(head1!=None):
            result.next = head1
        elif(head2!=None):
            result.next = head2
    return result
    pass

例如，测试用例是

assert [] == merge_lists([],[])
assert [1,2,3] == merge_lists([1,2,3], [])
assert [1,2,3] == merge_lists([], [1,2,3])
assert [1,1,2,2,3,3,4,5] == merge_lists([1,2,3], [1,2,3,4,5])
assert [1,10] == merge_lists([10], [1])
assert [1,2,4,5,6,7] == merge_lists([1,2,5], [4,6,7])

谁能给我通过这些测试用例的代码？提前致谢。

【问题讨论】：

发布您尝试过的代码（算法），并告诉我们您为什么认为它们不起作用。也许list#extend() 和sorted() 函数会有所帮助。

这些“链表”中的“链表”在哪里？

我希望 pass 实际上不是您尝试过的算法之一。

我们不会为你做作业。你甚至没有给我们足够的上下文让我们给你代码，即使我们想要。

"can any one give me the code to pass these test cases?" - 我们是否应该相信您编写了这些测试用例，但甚至无法尝试实现相关算法？？

【参考方案1】：

此操作只是在执行Merge Sort 的“合并”步骤，可以在O(l1+l2) 时间内完成。

一般的前提是同时迭代两个（已经排序的）列表，但只推进具有最低头值的列表，同时在结果输出中使用高级值。当两个源列表都用完时，操作完成。

这里有一些pseudo-code（由***提供），对于链表数据类型来说翻译起来应该不会太难。为链表实现它时，可以创建一个新列表，也可以破坏性地修改其中一个列表。

function merge(left, right)
    // receive the left and right sublist as arguments.
    // 'result' variable for the merged result of two sublists.
    var list result
    // assign the element of the sublists to 'result' variable until there is no element to merge. 
    while length(left) > 0 or length(right) > 0
        if length(left) > 0 and length(right) > 0
           // compare the first two element, which is the small one, of each two sublists.
            if first(left) <= first(right)
                // the small element is copied to 'result' variable.
                // delete the copied one(a first element) in the sublist.
                append first(left) to result
                left = rest(left)
            else
                // same operation as the above(in the right sublist).
                append first(right) to result
                right = rest(right)
        else if length(left) > 0
            // copy all of remaining elements from the sublist to 'result' variable, 
            // when there is no more element to compare with.
            append first(left) to result
            left = rest(left)
        else if length(right) > 0
            // same operation as the above(in the right sublist).
            append first(right) to result
            right = rest(right)
    end while
    // return the result of the merged sublists(or completed one, finally).
    // the length of the left and right sublists will grow bigger and bigger, after the next call of this function.
    return result

【讨论】：

如何计算链表的长度？

@srikarthikmodukuri length(l) > 0 表示“是一个非空链表”（例如，当前节点 l 是有效/非无）

@srikarthikmodukuri 顺便说一句，我刚刚看到的另一个问题中的代码，你永远不会更新循环中的 temp 节点，所以它永远不会真正“附加”。

根据你的算法我写了代码，但它进入了无限循环。你能帮我吗？提前致谢

@srikarthikmodukuri 无限循环是由temp 节点的突变引起的。对应的 l1/l2 节点的next 属性被设置之前它被遍历。

【参考方案2】：

def merge_lists(x,y):
    comb = []
    comb += x + y
    comb.sort()
    return comb