Python 返回数据渲染的重新排序范围的算法

以下是一些例子：

given: 1,2,3   [list or range of numbers]
return: 2,1,3  [reordered list]

given: 1,2,3,4,5
return: 3 1 5 2 4 

given: 1,2,3,4,5,6,7
return: 4 1 7 2 6 3 5 OR 4 7 1 5 3 2 6 or similar

given: 1,2,4,5,6,7,8,9
return: 5,1,9,3,7,2,8,4,6 or similar

在渲染中，从中心开始，然后是最极端的情况，并变得越来越详细。这不是随机的。我是python的，但在comp-sci中必须有这个名字。谢谢你的帮助

编辑以添加 即使是—

given: 1234 
return: 2,1,4,3 OR 3,1,4,2 OR 2,4,1,3 OR 3,4,1,2

这应该做到：

def extreme_cases(upd_itrr, new_itrr):
    new_itrr.append(min(upd_itrr))
    new_itrr.append(max(upd_itrr))
    upd_itrr.remove(min(upd_itrr))
    upd_itrr.remove(max(upd_itrr))
    if len(upd_itrr) >= 2:
        extreme_cases(upd_itrr, new_itrr)
    return upd_itrr, new_itrr


def reordered_range(itr):
    new_itr = []
    center = 0
    if len(itr) % 2 != 0:
        center = itr[len(itr) // 2]
    elif len(itr) % 2 == 0:
        center = itr[(len(itr) // 2) - 1]
    new_itr.append(center)
    upd_itr = itr[:]
    upd_itr.remove(center)
    upd_itr, new_itr = extreme_cases(upd_itr, new_itr)
    if upd_itr:
        new_itr.append(upd_itr[0])
    return new_itr


print(reordered_range([1, 2, 3]))
print(reordered_range([1, 2, 3, 4]))
print(reordered_range([1, 2, 3, 4, 5]))
print(reordered_range([1, 2, 3, 4, 5, 6, 7]))
print(reordered_range([1, 2, 4, 5, 6, 7, 8, 9]))

输出：

[2, 1, 3]
[2, 1, 4, 3]
[3, 1, 5, 2, 4]
[4, 1, 7, 2, 6, 3, 5]
[5, 1, 9, 2, 8, 4, 7, 6]

---

一个有效的，但不公平的解决方案：

def sigorder(lst):
    result = []
    l = len(lst)
    if l <= 2:
        return lst
    if l > 2:
        result.append(lst[l/2])
        result.append(lst[0])
        result.append(lst[-1])
        right = sigord(lst[l/2+1:-1])
        left = sigord(lst[1:l/2])
        result.extend(slicezip(left, right))

    return result

长度为4-9的列表的输出：

[3, 1, 4, 2]
[3, 1, 5, 2, 4]
[4, 1, 6, 2, 5, 3]
[4, 1, 7, 2, 5, 3, 6]
[5, 1, 8, 3, 6, 2, 7, 4]
[5, 1, 9, 3, 7, 2, 6, 4, 8]

另一个解决方案：

import numpy as np
from copy import copy

def bisecting_order(lst):

    # bisecting order of an unordered list
    result = []
    l = len(lst)
    if l < 3:
        return lst
    result.append(closest(lst,np.mean(lst)))
    result.append(min(lst))
    result.append(max(lst))

    # get bisections
    while len(result)!=len(lst):
        temp_list = copy(result)
        temp_list.sort()
        for i in xrange(len(temp_list)-1):
            newnum = closest(lst,np.mean([temp_list[i],temp_list[i+1]]))
            if newnum in result:
                continue
            else:
                result.append(newnum)
    return result

def closest(mylist,mynum):
    return min(mylist, key=lambda x:abs(x-mynum))

将numpy导入为np
从副本导入副本
def平分顺序（lst）：
#无序列表的对分顺序
结果=[]
l=len（lst）
如果l<3：
返回lst
结果.追加（最接近（lst，np.平均值（lst）））
结果追加（最小值（lst））
结果追加（最大值（lst））
#得到二等分
而蓝（结果）=len（lst）：
临时列表=复制（结果）
临时列表排序（）
对于X范围内的i（透镜（温度列表）-1）：
newnum=最近（第一次，np.平均值（[temp_list[i]，temp_list[i+1]]））
如果结果为newnum：
持续
其他：
result.append（newnum）
返回结果
def最近值（mylist，mynum）：
返回最小值（mylist，key=lambda x:abs（x-mynum））

在极端情况下，它是否从边界到中间工作？我认为您必须指定更多的预期行为，因为对于这个问题，每个用户可以/不能根据自己的喜好接受不同的可能解决方案。（基于观点的答案通常不被接受）。在最初的极端案例之后，他发布的例子中似乎使用了“最初案例之后的下一个极端案例”。例如，在第三个例子中，4是中心，1和7是初始的最小值和最大值，然后是2和6，然后是3和5。当有偶数个输入时会发生什么？偶数情况下给出：1234-2,1,4,3或3,1,4,2或2,4,1,3或3,4,1,2，你想让它给你中间，结束，然后对分其余的值？对我来说，这听起来像是一个递归函数。所以这是正确的，但我想你明白为什么这不是我想要的。“递归二分法”这个术语听起来很贴切，但我还是很好奇是否有工具可以做到这一点？也许写它只是最简单的方法哈哈。你的代码从中心开始，然后是极端，从极端到中心。我感兴趣的是中间，然后是极端，然后平分所有间隙，直到使用了原始列表中的所有术语。这仍然很接近。我认为你打印的最后两个区域在第三个学期后没有正确地对分。我自己尝试一下，你能澄清一下你到底在寻找什么吗？您发布的第四个示例（1,2,4,5,6,7,8,9）正确吗？它返回5,1,9,3,7,2,8,4,6？这就是它！

[3, 1, 4, 2]
[3, 1, 5, 2, 4]
[4, 1, 6, 2, 5, 3]
[4, 1, 7, 2, 5, 3, 6]
[5, 1, 8, 3, 6, 2, 7, 4]
[5, 1, 9, 3, 7, 2, 6, 4, 8]

import numpy as np
from copy import copy

def bisecting_order(lst):

    # bisecting order of an unordered list
    result = []
    l = len(lst)
    if l < 3:
        return lst
    result.append(closest(lst,np.mean(lst)))
    result.append(min(lst))
    result.append(max(lst))

    # get bisections
    while len(result)!=len(lst):
        temp_list = copy(result)
        temp_list.sort()
        for i in xrange(len(temp_list)-1):
            newnum = closest(lst,np.mean([temp_list[i],temp_list[i+1]]))
            if newnum in result:
                continue
            else:
                result.append(newnum)
    return result

def closest(mylist,mynum):
    return min(mylist, key=lambda x:abs(x-mynum))