使用交换距离在选择排序后恢复原始阵列

如何解决使用交换距离在选择排序后恢复原始阵列

我是CS的新手，我有一个非常艰巨的任务要做。这让我很害怕。 在选择排序期间，我们可以获取交换距离-（（未排序数组中元素的索引值）与（已排序数组中元素的索引值）之间的差。例如，我们可以找到它（这是交换距离的总和（我自己编写的代码，计算交换距离的总和是我的上一个任务），但是我们可以轻松获得交换距离的列表）：

x = [int(i) for i in input().split()]
def sel_sort(a):
    swap_dist_sum = 0 
    for i in range(len(a)): 
        min_idx = i 
        for j in range(i+1,len(a)): 
            if a[min_idx] > a[j]: 
                min_idx = j       
        a[i],a[min_idx] = a[min_idx],a[i]
        swap_dist_sum += (min_idx - i)  # new index in sorted list - index from unsorted list
    return swap_dist_sum                # for each element
print(sel_sort(x))

这只是介绍（此定义很少见）。 我有（n-1）个数字，它们是交换距离；第一次排序迭代中的第一个元素，第二次迭代中的第二个，依此类推。我必须在n个元素的未排序数组中恢复元素的原始顺序。 我不知道该怎么办。也许您可以建议我查找/阅读/使用库/小代码提示/等。

Sample Input:  # swap distances
1 3 0 1

Sample Output:  # original list
4 1 3 5 2

我的第一步应该是这样的：

swap_dist_l = [int(i) for i in input().split()]  # list containing all swap distances
sorted_l = [i for i in range(1,len(swap_dist_l) + 2)]  # already sorted list

因此，我应该有unsorted_l，其元素的原始未排序顺序。 对不起，我的讲话很难理解！ 附言我没有发现任何类似/重复的问题。如果我不擅长搜索，请发送链接！

解决方法

您应该执行与您获得的交换距离相对应的交换，但是交换顺序相反，因此请从右开始：

#include <string_view>

template <typename T> constexpr std::string_view type_name();

template <>
constexpr std::string_view type_name<void>()
{ return "void"; }

namespace detail {

using type_name_prober = void;

template <typename T>
constexpr std::string_view wrapped_type_name() 
{
#ifdef __clang__
    return __PRETTY_FUNCTION__;
#elif defined(__GNUC__)
    return __PRETTY_FUNCTION__;
#elif defined(_MSC_VER)
    return __FUNCSIG__;
#else
#error "Unsupported compiler"
#endif
}

constexpr std::size_t wrapped_type_name_prefix_length() { 
    return wrapped_type_name<type_name_prober>().find(type_name<type_name_prober>()); 
}

constexpr std::size_t wrapped_type_name_suffix_length() { 
    return wrapped_type_name<type_name_prober>().length() 
        - wrapped_type_name_prefix_length() 
        - type_name<type_name_prober>().length();
}

} // namespace detail

template <typename T>
constexpr std::string_view type_name() {
    constexpr auto wrapped_name = detail::wrapped_type_name<T>();
    constexpr auto prefix_length = detail::wrapped_type_name_prefix_length();
    constexpr auto suffix_length = detail::wrapped_type_name_suffix_length();
    constexpr auto type_name_length = wrapped_name.length() - prefix_length - suffix_length;
    return wrapped_name.substr(prefix_length,type_name_length);
}

为给定的示例调用如下：

def unsort(data_l,swap_dist_l):
    for i,dist in reversed(list(enumerate(swap_dist_l))):
        # swap
        data_l[i+dist],data_l[i] = data_l[i],data_l[i+dist]

,

让我们看看简单列表lst = [3,1,2]的选择排序是如何工作的：

我们首先查看索引0，然后找到索引1处的最小元素1。

然后我们交换它们，即lst[0],lst[1] = lst[1],lst[0]

然后我们看一下索引1，找到索引2处最小的元素2。

然后我们交换它们，即lst[1],lst[2] = lst[2],lst[1]

现在列表已排序，并且我们有交换距离列表swap_dst = [1,1]

为了恢复列表，我们需要反转为进行排序而进行的交换，换句话说，我们需要再次执行相同的交换，但顺序相反。

lst = [1,2,3]
lst[1],lst[1]
lst[0],lst[0]
print(lst) # [3,2]

因此，您需要做的是找出如何使用交换距离来查找进行了哪些交换，然后再次进行这些交换。