C# 不同的排序顺序-分而治之？

我试图以不同的方式重新排列对象列表。这里我将使用整数，但可以是列表中的任何内容

下面的示例代码将

1,2,3,4,5,6,7,8

排序为以下顺序：

1,8,2,7,3,6,4,5

所以首先。最后。第二倒数第二等。它可能有点笨重，但它的工作

现在我要做的是以另一个顺序输出列表，这样它就一直一分为二。我认为这可能被称为分而治之，但在尝试/查看一些递归排序代码等之后，我不太清楚如何在这里实现它

我希望能像这样订购这些号码

1,8,4,2,6,3,5,7

第一、最后、一半、上一半、下一半等等

换句话说，我要做的是把这组数字一分为二。。。然后依次为每一半将其分成两半。等等：

1 2 3 4 5 6 7 8
1                      (first item)
              8        (last item)
      4                (mid item)
  2                     (mid of first half) 
          6              (mid of second half)
    3                    (mid of 1st chunk)
        5                (mid of 2nd chunk)
           7             (mid of 3rd chunk)

如果有人能用这个简单的例子告诉我怎么做，那就太好了

 static void Main(string[] args)
    {

        List<int> numberlist = new List<int>();

        numberlist.Add(1);
        numberlist.Add(2);
        numberlist.Add(3);
        numberlist.Add(4);
        numberlist.Add(5);
        numberlist.Add(6);
        numberlist.Add(7);
        numberlist.Add(8);

        int rev = numberlist.Count-1;
        int fwd = 0;

        // order 1,8,2,7,3,6,4,5

        for (int re = 0; re < numberlist.Count; re++)
        {
            if (re % 2 == 0)
            {
                Console.WriteLine(numberlist[fwd]);
                fwd++;                       
            }
            else
            {
                Console.WriteLine(numberlist[rev]);
                rev--;
            }
        }
        Console.ReadLine();
    }

---

我可以展示类似的选择；它的结果与您的结果略有不同

取数字0到7，用二进制表示：

000 001 010 011 100 101 110 111

现在，把它们颠倒过来：

00010001011000110101111

在十进制中，这表示0 4 2 6 1 3 5 7。首先是第一个元素，然后是其余元素的一半，然后是四分之一和四分之三，最后是所有奇数元素

---

显然，这个过程只适用于2的精确幂。

让我看看我是否理解这个问题。让我们举一个包含更多项的示例：

这是你要的订单吗

ABCDEFGHIJKLMNOPQ
A               Q  
        I
    E       M
  C   G   K   O
 B D F H J L N P

这似乎很简单。创建一个名为“Interval”的数据结构，它有两个字段：最大下限和最小上限。也就是说，在区间以下最大的元素和在区间以上最小的元素是什么。算法如下所示：

Input: the size of the array.
Yield the first item -- if there is one
Yield the last item -- if it is different from the first item.
Make a queue of intervals.
Enqueue the interval (0, array.Length - 1) 
While the queue is not empty:
    Dequeue the queue to obtain the current item.
    Is the interval empty? If so, skip this interval
    Otherwise, the interval has a GLB, a LUB, and a value in the middle.
    Yield the middle of the interval
    Enqueue the interval (bottom, middle)
    Enqueue the interval (middle, top)

让我们学习上面的例子。我们有数组

ABCDEFGHIJKLMNOPQ

Yield A
Yield Q
Enqueue A-Q. The queue is now A-Q
Is the queue empty? No.
Dequeue the queue. It is now empty.
current is A-Q
Is the current interval empty? no.
The middle is I.
Yield I.
Enqueue A-I. The queue is now A-I.
Enqueue I-Q. The queue is now A-I, I-Q.
Is the queue empty? No.
Dequeue the queue. It is now I-Q.
current is A-I.
Is the current interval empty? No.
The middle is E.
Yield E.
Enqueue A-E. The queue is now I-Q, A-E.
Enqueue E-I. The queue is now I-Q, A-E, E-I
Is the queue empty? No.
Dequeue. The queue is now A-E, E-I
current is I-Q
The middle is M
Yield M.
Enqueue I-M
Enqueue M-Q.  The queue is now A-E, E-I, I-M, M-Q
OK, let's start skipping some steps here. The state of the queue and the yields are:
Yield C
E-I, I-M, M-Q, A-C, C-E
Yield G
I-M, M-Q, A-C, C-E, E-G, G-I
Yield K
M-Q, A-C, C-E, E-G, G-I, I-K, K-M
yield O
A-C, C-E, E-G, G-I, I-K, K-M, M-O, O-Q
yield B
C-E, E-G, G-I, I-K, K-M, M-O, O-Q, A-B, B-C
OK, skip more steps...
Yield D, F, H, J, L, N, P
Queue is now A-B, B-C, C-D, D-E, ... P-Q
Every interval is now empty, so we skip all of htem and we are done.

有道理吗

这里的诀窍是要注意，您想要的顺序是对一棵树进行广度优先访问。您只需要能够“看穿”要遍历的树结构的数组

顺便说一句，排序似乎有点奇怪。大多数部分的排序似乎是“将范围分成两部分，并首先生成每个范围的中间部分”。那么，为什么这两个极端首先屈服，而不是最后屈服？我会发现订购：

ABCDEFGHIJKLMNOPQ
        I
    E       M
  C   G   K   O
 B D F H J L N P
A               Q  

---

更加直观明显；如果“处于中间”的事物总是优先于“处于极端”的事物，那么极端应该排在最后，而不是第一位。

我似乎没有明确的模式。你能对模式进行扩展吗？我同意Kyle的观点——我认为如果你能更清楚地描述你想要的模式，代码的实现就会更容易。你能“工作”一个例子吗？（也就是说，向我们更详细地展示您达成所需订单的步骤。）真正有帮助的是：（1）一个非常小的示例；比如说，只有四个项目，（2）一个中等规模的例子，（3）一个大型的例子，比如说有十六个项目。这将有助于演示任何递归模式。谢谢，对不起，我弄错了。现在是对的。。应该结束…3，5，7。我添加了一个有效的示例。。现在有意义了吗？每个子范围的处理顺序是什么？从最小到最大？附加样品正确吗？是的，谢谢。。这些例子似乎是正确的。谢谢你，尼尔。。对于不同的排序顺序，这是一个非常酷的主意。谢谢Eric。。这看起来像是我想要的图案。您只需要考虑如何实现您的算法。。。。谢谢你，埃里克。。我明白你现在在做什么。。我正在寻找加速一些空间算法的方法。。。这些东西离我很近，也离我很远，这对我的工作来说是最重要的。然后，中间的一切…@timemirror听起来像是图像像素化的反面-通过添加中间值一步一步地改进细节。@Neil-yer，与此非常类似。如果原始信息仍然有效，则继续添加更多细节，直到其失效。通常空间上相近的事物是相似的，所以以增量方式查看是浪费时间。。。相反，通过跳跃，你可以更快地解决问题。我只是想找到很多方法来实现这些跳跃，看看在不同的条件下哪一种效果更好。然后找出每次如何选择合适的方法。谢谢你的算法。。我也在尝试。

ABCDEFGHIJKLMNOPQ
        I
    E       M
  C   G   K   O
 B D F H J L N P
A               Q