使用常量内存对O（n）中的BST进行排序

Question

这不是作业。这是一项有趣的任务：）

给出一个完整的二进制搜索，三个由数组表示。使用常量内存在O（n）中对数组进行排序。

示例：

树：

              8
           /     \
          4       12
         /\       / \
        2  6     10  14
       /\  /\    /\   /\
      1 3 5  7  9 11 13 15

阵列：8,4,12,2,6,10,14,1,3,5,7,9,11,13,15

输出：1,2,3,4,5,6,7,8,9,10,11,12,13,14,15

Answer 1

有可能，称之为家庭作业的人可能还没有尝试解决它。​​

我们使用以下作为子程序：

Given an array a1 a2 ... an b1 b2 .. bn, convert in O(n) time and O(1) space to

b1 a1 b2 a2 ... bn an

可以在此处找到解决方案：http://arxiv.org/abs/0805.1598

我们使用如下。

对前2 ^（k + 1） - 2个元素进行上述交织，从k = 1开始重复k = 2,3等，直到你越过数组的末尾。

例如，在您的数组中，我们得到（用括号标识的交错集）

 8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15   
[ ][ ]

 4, 8, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15   (k = 1, interleave 2)
[        ][        ]  

 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15   (k = 2, interleave 6)
[                      ][                     ]

 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15   (k = 3, interleave 14)

因此总时间为n + n / 2 + n / 4 + ... = O（n）。 使用的空间是O（1）。

这可以通过归纳来证明。

Answer 2

  

考虑O(1)就地变体，但现在这里是O(N)解决方案

O(N)空间解决方案

如果您可以使用O(N)输出数组，那么您只需执行inorder traversal即可。每次访问节点时，都将其添加到输出数组中。

这是Java中的一个实现：

import java.util.*;
public class Main {
    static void inorder(int[] bst, List<Integer> sorted, int node) {
        if (node < bst.length) {
            inorder(bst, sorted, node * 2 + 1);
            sorted.add(bst[node]);
            inorder(bst, sorted, node * 2 + 2);
        }
    }
    public static void main(String[] args) {
        int[] bst = { 8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15 };
        final int N = bst.length;
        List<Integer> sorted = new ArrayList<Integer>();
        inorder(bst, sorted, 0);
        System.out.println(sorted);
        // prints "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]"
    }
}

附件

• Source and output on ideone.com