如何获取Window实例的hWnd？(How to get the hWnd of Window instance?)

 以下是一些Python代码，可以为您的示例生成类似的输出： 
 
def f(low, high):
    ranges = collections.deque([(low, high)])
    while ranges:
        low, high = ranges.popleft()
        mid = (low + high) // 2
        yield mid
        if low < mid:
            ranges.append((low, mid))
        if mid + 1 < high:
            ranges.append((mid + 1, high))
 
 例： 
 
>>> list(f(0, 20))
[10, 5, 15, 2, 8, 13, 18, 1, 4, 7, 9, 12, 14, 17, 19, 0, 3, 6, 11, 16]
 
 与Python中的约定一样， low, high范围不包括端点，因此结果包含从0到19的数字。 
 
 该代码使用FIFO来存储仍需要处理的子范围。 FIFO在整个范围内初始化。 在每次迭代中，下一个范围都会弹出，并且中点会放弃。 然后，如果当前范围的下部和上部子范围非空，则将其附加到FIFO。 
 
 编辑 ：这是C99中完全不同的实现： 
 
#include <stdio.h>

int main()
{
    const unsigned n = 20;
    for (unsigned i = 1; n >> (i - 1); ++i) {
        unsigned last = n;    // guaranteed to be different from all x values
        unsigned count = 1;
        for (unsigned j = 1; j < (1 << i); ++j) {
            const unsigned x = (n * j) >> i;
            if (last == x) {
                ++count;
            } else {
                if (count == 1 && !(j & 1)) {
                    printf("%u\n", last);
                }
                count = 1;
                last = x;
            }
        }
        if (count == 1)
            printf("%u\n", last);
    }
    return 0;
}
 
 这避免了使用一些技巧来确定先前迭代中是否已经发生整数的FIFO的必要性。 
 
 你也可以很容易地在C中实现原来的解决方案。既然你知道FIFO的最大尺寸（我猜它是类似于（n + 1）/ 2的，但是你需要仔细检查这个），你可以使用环形缓冲区保持排队的范围。 
 
 编辑2 ：这是C99的又一个解决方案。 它被优化为仅执行一半循环迭代，并且仅使用位操作和添加，而不用乘法或除法。 它也更简洁，并且在结果中不包含0 ，所以您可以按照您的初始设想在开始时使用它。 
 
for (int i = 1; n >> (i - 1); ++i) {
    const int m = 1 << i;
    for (int x = n; x < (n << i); x += n << 1) {
        const int k = x & (m - 1);
        if (m - n <= k && k < n)
            printf("%u\n", x >> i);
    }
}
 
 （这是我一开始就想写的代码，但花了我一些时间来围绕它。） 

Here is some Python code producing similar output to your example:
 
def f(low, high):
    ranges = collections.deque([(low, high)])
    while ranges:
        low, high = ranges.popleft()
        mid = (low + high) // 2
        yield mid
        if low < mid:
            ranges.append((low, mid))
        if mid + 1 < high:
            ranges.append((mid + 1, high))
 
Example:
 
>>> list(f(0, 20))
[10, 5, 15, 2, 8, 13, 18, 1, 4, 7, 9, 12, 14, 17, 19, 0, 3, 6, 11, 16]
 
The low, high range excludes the endpoint, as is convention in Python, so the result contains the numbers from 0 to 19.
 
The code uses a FIFO to store the subranges that still need to be processed. The FIFO is initialised with the full range. In each iteration, the next range is popped and the mid-point yielded. Then, the lower and upper subrange of the current range is appended to the FIFO if they are non-empty.
 
Edit: Here is a completely different implementation in C99:
 
#include <stdio.h>

int main()
{
    const unsigned n = 20;
    for (unsigned i = 1; n >> (i - 1); ++i) {
        unsigned last = n;    // guaranteed to be different from all x values
        unsigned count = 1;
        for (unsigned j = 1; j < (1 << i); ++j) {
            const unsigned x = (n * j) >> i;
            if (last == x) {
                ++count;
            } else {
                if (count == 1 && !(j & 1)) {
                    printf("%u\n", last);
                }
                count = 1;
                last = x;
            }
        }
        if (count == 1)
            printf("%u\n", last);
    }
    return 0;
}
 
This avoids the necessity of a FIFO by using some tricks to determine if an integer has already occured in an earlier iteration.
 
You could also easily implement the original solution in C. Since you know the maximum size of the FIFO (I guess it's something like (n+1)/2, but you would need to double check this), you can use a ring buffer to hold the queued ranges.
 
Edit 2: Here is yet another solution in C99. It is optimised to do only half the loop iterations and to use only bit oprations and additions, no multiplication or divisions. It's also more succinct, and it does not include 0 in the results, so you can have this go at the beginning as you initially intended.
 
for (int i = 1; n >> (i - 1); ++i) {
    const int m = 1 << i;
    for (int x = n; x < (n << i); x += n << 1) {
        const int k = x & (m - 1);
        if (m - n <= k && k < n)
            printf("%u\n", x >> i);
    }
}
 
(This is the code I intended to write right from the beginning, but it took me some time to wrap my head around it.)