是否有一种使用二进制树按数字位数排序的算法？

Question

我已经查看了可以找到的排序算法，但是没有看到任何一种算法使用数字位。 我认为，我创建了一种新型的排序算法。 我命名为Bitsort 。 描述在github中 。


您知道这样的排序算法吗？


复杂度为O（nk） 。 k是数组元素的位大小。 数组顺序并不重要。 每次复杂度为O（nk） 。 但是它占用了很多内存。 它取决于N。但是当N增加时，内存相对减少。 如果N为1，则为最大内存比率（R = Node / N）（= bitsize） 。 如果N为最大值，则内存比率降低到R =2。因此R * N是存储整个位树需要多少个节点。 如果N等于最大值->（2 ^ 32为整数），我们需要2N个节点来存储所有数组。 每个节点都有2个地址指针。

同时，N不是数组中的数字计数。 N是唯一的数字计数。

如果数组中的所有元素都相同，则N等于1。

总结

    Memory = P*N*R (P: pointer size, N: unique count, R: NodeCount(C)/N)


    I create a formula for R for 32 bit integer.
    R = 31 - 3.3*LOG10(N)

我将数字从MSB（最高有效位）到LSB（最低有效位）放到二叉树中。 如果以前添加了它们，那么我将增加价值之叶的数量。

我只有1次从头到尾在源数组上移动，并且“排序树”已被填充。

void bitSort(int * array, int arraySize) {
    int i, j;
    Block* block;
    clock_t start, end;

    //create a buffer. root node is first node in buffer. 
    root = initBlockBuffer();
    const unsigned long long digit = ((unsigned long long) 1) << (ARRAY_ELEMENT_TYPE_SIZE_1);

    //for every array element (n !IMPORTANT)
    for (i = 0; i < arraySize; i++) {
        // start at root
        Block* activeBlock = root;

        register int value = array[i];
        register int bit;

        //for every bit of value (k !IMPORTANT)
        for (j = 0; j < ARRAY_ELEMENT_TYPE_SIZE_1; j++){

            //from msb to lsb get the bit   
            bit = (digit & (value << j)) >> (ARRAY_ELEMENT_TYPE_SIZE_1);

            // get the related node from bit 
            block = activeBlock->node[bit];


            // if the node is not exists
            if (block == 0) {

                // get next blank node from the buffer.
                block = nextFreeBlock();

                //connect new node to previous node  
                activeBlock->node[bit] = block;
            }

            // jump to new node.
            activeBlock = block;
        }

        //after all last node is leaf. 
        //Getting from last bit of value
        if(activeBlock->cnt[value & 1] == 0) leafCount++;  
        //and count of this leaf, increasing 1
        activeBlock->cnt[value & 1]++;  

    }
}

一些结果

---

如果我们创建一个具有1000000（一百万）个4字节整数的数组，则为：-相同的数字-从1增加到1000000-随机均匀分布

相同的数字

Leaf Count    : 1
Node Count    : 31
Node Size     : 16 byte
Total Memory  : 512 byte
Duration Sort : 178721 us (0.02s)
Duration Read : 4994 us (0.005s)

从1增加到1000000

Leaf Count    : 1000000
Node Count    : 1000018
Node Size     : 16 byte
Total Memory  : 16000304 byte (16MB)
Duration Sort : 218556 us (0.2s)
Duration Read : 14321 us (0.01s)

随机均匀分布

Leaf Count    : 999768 (uniq numbers, >%0,02 repetition)
Node Count    : 11181318
Node Size     : 16 byte
Total Memory  : 178913456 byte (179MB)
Duration Sort : 1460578 us (1.4s)
Duration Read : 666933 us (0.7s)

有没有您所知道的算法？

例

示例：我们假设有3位长度的数字。

array = {7, 3, 2, 5, 0, 7, 3, 2, 7};

L   : level
msb : most significant bit
lsb : least significant bit

              msb       lsb
               L1   L2   L3
7 = 111  -->    1    1    1
3 = 011  -->    0    1    1
2 = 010  -->    0    1    0
5 = 101  -->    1    0    1
0 = 000  -->    0    0    0
7 = 111  -->    1    1    1
3 = 011  -->    0    1    1
2 = 010  -->    0    1    0
7 = 111  -->    1    1    1

首先二叉树只有根节点。

                        0_____________________|_____________________1                          
                       /                                             \                         

第一个数字使用从msb到lsb的自己的位添加到二叉树中。 （加数：7 =>（111）（3bit空间））

             0_____________________|_____________________1                          
L1  ----->                                                \                         
                                                 0_________\_________1              
L2  ----------------------------------------->                        \             
                                                                   0___\___1        
L3  ---------------------------------------------------------->             \       
                                                                            [1]     

然后其他人随之而来。 （加数：3、2、5、0）

                        0_____________________|_____________________1                          
                       /                                             \                         
            0_________/_________1                           0_________\_________1              
           /                     \                         /                     \             
      0___/___1               0___\___1               0___/___1               0___\___1        
     /                       /         \                       \                       \       
   [1]                     [1]         [1]                     [1]                      1     

如果树中已有数字，则其计数增加1。（数字：7、3、2、7）

                        0_____________________|_____________________1                          
                       /                                             \                        
            0_________/_________1                           0_________\_________1              
           /                     \                         /                     \            
      0___/___1               0___\___1               0___/___1               0___\___1        
     /                       /         \             /         \             /         \       
   [1]                     [2]         [2]                     [1]                     [3]     

递归读取时，可以得到排序数组。

sorted_array =  [1x(000), 2x(010), 2x(011), 1x(101), 3x(111)]
sorted_array =  [1x0, 2x2, 2x3, 1x5, 3x7]
sorted_array =  [0, 2, 2, 3, 3, 5, 7, 7, 7]

Answer 1

好吧，你错了。 您已经设计了一个排序的二叉树（这不是您的发明）。 确实，您不需要具有所有键（如您在示例中所做的那样）即可完成树。 这样，它的平均运行树为O(n*log(n)) ，因为每次插入都需要覆盖所有树节点，直到您要放置密钥的地方。 另外，如果您已经获得有序集合，则该树将在列表中退化（您始终会转到右侧分支，直到到达插入位置），然后退化为O(n²) 。

另外，如果要考虑集合中的每个键（就像在所有样本中一样），则可以通过仅实现大小为2^n的数组并考虑A[n]左儿子来节省指针空间。是索引为2*n的单元格，右子元素为索引2*n+1的单元格。 在这种情况下，您只需要存储与键关联的数据，而不必存储指针。 如果考虑构建多维数组（具有与位一样多的维数）并且每个索引从0到1的可能性，也会导致这种方法。 在这种情况下，考虑到数组的大小，您可以将数组视为线性数组，将数据直接线性地直接存储到数组单元中。