我试图编写一个可以反转数组并打印其inverse permutation而不形成新数组的函数。
给定一个大小为n的整数数组，其范围从1到n，我们需要找到该数组的逆排列。
反向排列是通过在数组中元素值指定的位置插入元素的位置而获得的排列。
我写了可以反转数组的代码，但是我必须形成一个新数组才能做到这一点。
#include<iostream>
using namespace std;
void inverse(int arr[], int size) {
int arr2[size];
for (int i = 0; i < size; i++)
arr2[arr[i] - 1] = i + 1;
for (int i = 0; i < size; i++)
cout << arr2[i] << " ";
}
int main() {
int arr[] = {2, 3, 4, 5, 1};
int size = sizeof(arr) / sizeof(arr[0]);
inverse(arr, size);
return 0;
}
答案 0 :(得分：3)
我真的希望您自己编写代码，这是我的做法：
取两个变量，一个指向数组的开始，另一个指向数组的最后 在两个位置交换元素 分别递增开始和递减结束指针 在开始指针小于结束指针的情况下重复上述步骤
编辑1： 干得好： https://www.geeksforgeeks.org/inverse-permutation/
没有其他解决方案适合您的情况
我了解您正在寻找一种不同的方法，但是让我们在这里讨论可行性：
您需要存储要替换的值，以备将来参考，否则您将无法对其进行跟踪！ 有人可能会争辩说，为了方便起见，我们将保留“ visited”标志，但这只会使代码更加丑陋，复杂和复杂，实际上并没有帮助。因此，我认为，除了给出的解决方案外根本不可行！
答案 1 :(得分：1)
对于初学者来说，有执行任务的标准算法std::reverse。
这是一个演示程序。
#include <iostream>
#include <iterator>
#include <algorithm>
int main()
{
int arr[] = { 2, 3, 4, 5, 1 };
for ( const auto &item : arr ) std::cout << item << ' ';
std::cout << '\n';
std::reverse( std::begin( arr ), std::end( arr ) );
for ( const auto &item : arr ) std::cout << item << ' ';
std::cout << '\n';
}
其输出为
2 3 4 5 1
1 5 4 3 2
如果您要专门为数组编写自己的函数，则可以例如通过以下方式查看
#include <iostream>
#include <utility>
template <typename T>
void reverse( T *a, size_t n )
{
for ( size_t i = 0; i < n / 2; i++ )
{
std::swap( a[i], a[n - i - 1] );
}
}
int main()
{
int arr[] = { 2, 3, 4, 5, 1 };
const size_t N = sizeof( arr ) / sizeof( *arr );
for ( const auto &item : arr ) std::cout << item << ' ';
std::cout << '\n';
::reverse( arr, N );
for ( const auto &item : arr ) std::cout << item << ' ';
std::cout << '\n';
}
其输出与上面显示的相同
2 3 4 5 1
1 5 4 3 2
答案 2 :(得分：0)
我发现了这篇最近的论文 https://arxiv.org/pdf/1901.01926.pdf，其中所有内容都经过精心排版和解释。 显然，时间和空间复杂度之间总是存在折衷，并且还没有 O(n) 时间和原地的算法（还没有？）。 （该论文声称是第一个次二次确定性就地算法。）
您发布的算法未在论文中列出，时间上为 O(n)，空间上为 O(n)（即异地）。
我把它贴在这里供参考，也是为了检查其他实现的正确性。 为简单起见，我使用了零基索引。
// O(n) out-of-place algorithm
template<class It, class Size, class ItOut>
void inverse_permutation_n(It first, Size n, ItOut d_first){
for(Size i = 0; i != n; ++i){
d_first[first[i]] = i;
}
}
然后是从论文中的伪代码翻译而来的表中列为“民间传说”的算法（论文中的清单 3）。
#include<algorithm> // for std::min
template<class It, class Index>
void reverse_cycle(It t, Index start){
auto cur = t[start];
auto prev = start;
while( cur != start ){
auto next = t[cur];
t[cur] = prev;
prev = cur;
cur = next;
}
t[start] = prev;
}
template<class It, class Index>
auto cycle_leader(It t, Index start){
auto cur = t[start];
auto smallest = start;
while(cur != start){
smallest = std::min(smallest, cur);
cur = t[cur];
}
return smallest;
}
// O(n²) in-place algorithm
template<class It, class Size>
void inverse_permutation_n(It first, Size n){
for(Size i = 0; i != n; ++i){
if( cycle_leader(first, i) == i ) reverse_cycle(first, i);
}
}
上述算法在平均情况下是 O(n²) 时间。 原因是对于每个点，您必须遵循一个长度为 O(n) 的循环才能找到领导者。
然后您可以在此基础上通过在循环前导搜索中放置快捷方式来构建，一旦循环前导小于起点，搜索将返回 false。
template<class It, class Index>
auto cycle_leader_shortcut(It t, Index start){
auto cur = t[start];
while(cur != start){
if(cur < start) return false;
cur = t[cur];
}
return true;
}
// O(n log n) in-place algorithm
template<class It, class Size>
void inverse_permutation_shortcut_n(It first, Size n){
for(Size i = 0; i != n; ++i){
if( cycle_leader_shortcut(first, i) ) reverse_cycle(first, i);
}
}
幸运的是，这个算法是 O(N log N)（我认为平均而言）。 原因是循环迭代随着序列中点的增加而变短，因为一个点更有可能具有已经反转的低值。
这是基准和结果：
#include<numeric> // for iota
#include<random>
// initialize rng
std::random_device rd;
std::mt19937 g(rd());
static void BM_inverse_permutation(benchmark::State& state){
// allocate memory and initialize test buffer and reference solution
auto permutation = std::vector<std::size_t>(state.range(0));
std::iota(permutation.begin(), permutation.end(), 0);
auto reference_inverse_permutation = std::vector<std::size_t>(permutation.size());
for(auto _ : state){
state.PauseTiming(); // to random shuffle and calculate reference solution
std::shuffle(permutation.begin(), permutation.end(), g);
// inverse_permutation_n(permutation.cbegin(), permutation.size(), reference_inverse_permutation.begin());
benchmark::DoNotOptimize(permutation.data());
benchmark::ClobberMemory();
state.ResumeTiming();
inverse_permutation_n(permutation.begin(), permutation.size());
benchmark::DoNotOptimize(permutation.data());
benchmark::ClobberMemory();
// state.PauseTiming(); // to check that the solution is correct
// if(reference_inverse_permutation != permutation) throw std::runtime_error{""};
// state.ResumeTiming();
}
state.SetItemsProcessed(state.iterations()*permutation.size() );
state.SetComplexityN(state.range(0));
}
BENCHMARK(BM_inverse_permutation)->RangeMultiplier(2)->Range(8, 8<<10)->Complexity(benchmark::oNSquared);
static void BM_inverse_permutation_shortcut(benchmark::State& state){
// allocate memory and initialize test buffer and reference solution
auto permutation = std::vector<std::size_t>(state.range(0));
std::iota(permutation.begin(), permutation.end(), 0);
auto reference_inverse_permutation = std::vector<std::size_t>(permutation.size());
for(auto _ : state){
state.PauseTiming(); // to random shuffle and calculate reference solution
std::shuffle(permutation.begin(), permutation.end(), g);
// inverse_permutation_n(permutation.cbegin(), permutation.size(), reference_inverse_permutation.begin());
benchmark::DoNotOptimize(permutation.data());
benchmark::ClobberMemory();
state.ResumeTiming();
inverse_permutation_shortcut_n(permutation.begin(), permutation.size());
benchmark::DoNotOptimize(permutation.data());
benchmark::ClobberMemory();
// state.PauseTiming(); // to check that the solution is correct
// if(reference_inverse_permutation != permutation) throw std::runtime_error{""};
// state.ResumeTiming();
}
state.SetItemsProcessed(state.iterations()*permutation.size() );
state.SetComplexityN(state.range(0));
}
BENCHMARK(BM_inverse_permutation_shortcut)->RangeMultiplier(2)->Range(8, 8<<10)->Complexity(benchmark::oNLogN);
BENCHMARK_MAIN();
$ c++ a.cpp -O3 -DNDEBUG -lbenchmark && ./a.out
2021-03-30 21:16:55
Running ./a.out
Run on (12 X 4600 MHz CPU s)
CPU Caches:
L1 Data 32K (x6)
L1 Instruction 32K (x6)
L2 Unified 256K (x6)
L3 Unified 12288K (x1)
Load Average: 1.26, 1.80, 1.76
***WARNING*** CPU scaling is enabled, the benchmark real time measurements may be noisy and will incur extra overhead.
-----------------------------------------------------------------------------------------------
Benchmark Time CPU Iterations UserCounters...
-----------------------------------------------------------------------------------------------
BM_inverse_permutation/8 476 ns 478 ns 1352259 items_per_second=16.7276M/s
BM_inverse_permutation/16 614 ns 616 ns 1124905 items_per_second=25.9688M/s
BM_inverse_permutation/32 1106 ns 1107 ns 630398 items_per_second=28.9115M/s
BM_inverse_permutation/64 2929 ns 2931 ns 238236 items_per_second=21.835M/s
BM_inverse_permutation/128 10748 ns 10758 ns 64708 items_per_second=11.898M/s
BM_inverse_permutation/256 41556 ns 41582 ns 16600 items_per_second=6.15656M/s
BM_inverse_permutation/512 164006 ns 164023 ns 4245 items_per_second=3.12151M/s
BM_inverse_permutation/1024 621341 ns 620840 ns 1056 items_per_second=1.64938M/s
BM_inverse_permutation/2048 2468060 ns 2466060 ns 293 items_per_second=830.474k/s
BM_inverse_permutation/4096 10248540 ns 10244982 ns 93 items_per_second=399.805k/s
BM_inverse_permutation/8192 55926122 ns 55926230 ns 10 items_per_second=146.479k/s
BM_inverse_permutation_BigO 0.82 N^2 0.82 N^2
BM_inverse_permutation_RMS 18 % 18 %
BM_inverse_permutation_shortcut/8 499 ns 501 ns 1193871 items_per_second=15.9827M/s
BM_inverse_permutation_shortcut/16 565 ns 567 ns 1225056 items_per_second=28.2403M/s
BM_inverse_permutation_shortcut/32 740 ns 742 ns 937909 items_per_second=43.1509M/s
BM_inverse_permutation_shortcut/64 1121 ns 1121 ns 619016 items_per_second=57.0729M/s
BM_inverse_permutation_shortcut/128 1976 ns 1977 ns 355982 items_per_second=64.745M/s
BM_inverse_permutation_shortcut/256 3644 ns 3645 ns 191387 items_per_second=70.2375M/s
BM_inverse_permutation_shortcut/512 7282 ns 7288 ns 95434 items_per_second=70.2481M/s
BM_inverse_permutation_shortcut/1024 14732 ns 14752 ns 47417 items_per_second=69.4165M/s
BM_inverse_permutation_shortcut/2048 30590 ns 30398 ns 23079 items_per_second=67.3728M/s
BM_inverse_permutation_shortcut/4096 64374 ns 64039 ns 10766 items_per_second=63.9613M/s
BM_inverse_permutation_shortcut/8192 196961 ns 195786 ns 3646 items_per_second=41.8416M/s
BM_inverse_permutation_shortcut_BigO 1.74 NlgN 1.73 NlgN
BM_inverse_permutation_shortcut_RMS 27 % 27 %