Question

Phobos是否有一些可变参数算法来定义l值参考参数？像

这样的东西

int a=3;
int b=2;
int c=1;

orderInPlace(a,b,c);

// a is now 1
// b is now 2
// c is now 3

也是一个功能变体，比如order(a, b, c)，它返回一个元组也很不错。

如果没有，我想我们应该使用std.algorithm:swap。

另见http://forum.dlang.org/thread/eweortsmcmibppmvtriw@forum.dlang.org#post-eweortsmcmibppmvtriw:40forum.dlang.org。

Answer 1

Adam的解决方案有效，尽管它使用了元素的临时副本。使用small modification to std.algorithm，可以编写一个对元素进行排序的版本：

import std.algorithm;
import std.stdio;
import std.traits;
import std.typecons;

struct SortableRef(T)
{
    private T * _p;
    @property ref T value() { return *_p; }
    alias value this;
    void opAssign(T * value) { _p = value; }
    @disable void opAssign(SortableRef!T value);
    void proxySwap(SortableRef!T other) { swap(*_p, *other._p); }
}

template PointerTo(T) { alias T* PointerTo; }
void orderInPlace(T...)(ref T values)
    if (!is(CommonType!(staticMap!(PointerTo, T)) == void))
{
    alias CommonType!T E;
    SortableRef!E[values.length] references;
    foreach (i, ref v; values)
        references[i] = &v;
    references[].sort();
}

void main()
{
    int a=3;
    int b=1;
    int c=2;
    orderInPlace(a, b, c);
    writeln([a, b, c]);
}

但是，只有传递给orderInPlace的值很大，无法分配或以其他方式复制时才是实用的。

Answer 2

我不认为Phobos有一个，但你可以这样做：

void orderInPlace(T...)(ref T t) {
    import std.algorithm;
    T[0][T.length] buffer;
    foreach(idx, a; t)
        buffer[idx] = a;
    auto sorted = sort(buffer[]);
    foreach(idx, a; t)
        t[idx] = sorted[idx];
}

std.algorithm，sort需要一个数组，但这很容易 - 我们将元组复制到堆栈数组中，对其进行排序，然后将信息复制回元组。所以也许并不完美，但它确实有效。您可以通过返回t而不是执行ref来使其正常运行。

Answer 3

这里的排序网络可能是最有效的，因为参数数量很少，而且它们的编号是编译时已知的（无循环条件）。

冒泡排序非常适合排序网络。我把它扔在了一起。它的工作原理非常简单：

import std.stdio, std.string;

void bubbleSort(T...)(ref T values)
{
    static if (T.length > 1)
    {
        foreach(I, _; T[0 .. $ - 1])
        {
            pragma(msg, format("[%s %s]", I, I + 1));
            compareAndSwap(values[I], values[I + 1]);
        }
        bubbleSort(values[0 .. $ - 1]);
    }
}
void compareAndSwap(T)(ref T a, ref T b)
{
    import std.algorithm;
    if(a > b)
        swap(a, b);
}

void main()
{
    int a =  10;
    int b =  30;
    int c =  11;
    int d =  20;
    int e =   4;
    int f = 330;
    int g =  21;
    int h = 110;
    shellSort(a, b, c, d, e, f, g, h);
    writefln("%s %s %s %s %s %s %s %s!", a, b, c, d, e, f, g, h);
}

虽然说实话，如果这是标准库，任何少于10个参数的排序网络都应该是手写的。

编辑：我完全改变了之前的算法，这实际上非常缺乏。冒泡排序不是最佳，但它实际上可以用于排序算法。那里有一些pragma可以看到构建的网络。

元素的就地排序

3 个答案: