How to remove children of tree nodes with single child

Question

I have an array for pre-order traversal of a tree (node values are depth values). All I want to do is to minimize tree by removing the children of internal nodes having only one child.

As an example (a tree with max depth = 3) problem visualized here

Input array: [0, 1, 2, 3, 3, 1, 2, 3]
Output array: [0, 1, 2, 2, 1]

How should be the algorithm?

Answer 1

A simple O(nlog(n)) average-case algorithm arises from attacking the problem by divide-and-conquer approach.

Start with input_level = 0, output_level=0, left=0, right=n-1.

In each of the recursive steps, count the elements with value input_level+1 in the input array A in range [left, right]. These are the children of the current node. If there are no such elements, print output_level and return. If there is just one such element, "delete" the current node (i.e. do not print it), increase left by 1, and call the function recursively. If there are two or more such elements, print output_level, increase output_level by 1, and apply the function recursively to each of the intervals demarcated by the children elements. Always increase input_level when doing the recursive call.

For the example input A=[0, 1, 2, 3, 3, 1, 2, 3], first the algorithm would find elements with value 1, at indexes 1 and 5. Then it would print 0, increase output_level and current_level by 1, and call itself recursively two times: on ranges [1, 4] and [5, 7].

The complexity of this is O(n²) in the worst case (for the degenerate tree that is in fact a list), but O(nlog(n)) on the average, as a random n-ary tree has height O(log(n)).

Answer 2

The following algorithm runs in O(N). I guess I get it correct this time.

#include <algorithm>
#include <iostream>
#include <stack>
#include <tuple>
#include <utility>
#include <vector>

void mark_nodes(const std::vector<unsigned>& tree,
                std::vector<bool>& mark) {
  // {depth, index, mark?}
  using triple = std::tuple<unsigned, unsigned, bool>;
  std::stack<triple> stk;
  stk.push({0, 0, false});
  for (auto i = 1u; i < mark.size(); ++i) {
    auto depth = tree[i];
    auto top_depth = std::get<0>(stk.top());
    if (depth == top_depth) {
      stk.pop();
      if (stk.size()) std::get<2>(stk.top()) = false;
      continue;
    }
    if (depth > top_depth) {
      std::get<2>(stk.top()) = true;
      stk.push({depth, i, false});
      continue;
    }
    while (std::get<0>(stk.top()) != depth) {
      mark[std::get<1>(stk.top())] = std::get<2>(stk.top());
      stk.pop();
    }
    mark[std::get<1>(stk.top())] = std::get<2>(stk.top());
    stk.pop();
    if (stk.size()) std::get<2>(stk.top()) = false;
    stk.push({depth, i, false});
  }
  mark[0] = false;
}

std::vector<unsigned> trim_single_child_nodes(
    std::vector<unsigned> tree) {
  tree.push_back(0u);
  std::vector<bool> mark(tree.size(), false);
  mark_nodes(tree, mark);
  std::vector<unsigned> ret(1, 0);
  tree.pop_back();
  mark.pop_back();
  auto max_depth = *std::max_element(tree.begin(), tree.end());
  std::vector<unsigned> depth_map(max_depth + 1, 0);
  for (auto i = 1u; i < tree.size(); ++i) {
    if (mark[i]) {
      if (tree[i] > tree[i - 1]) {
        depth_map[tree[i]] = depth_map[tree[i - 1]];
      }
    } else {
      if (tree[i] > tree[i - 1]) {
        depth_map[tree[i]] = depth_map[tree[i - 1]] + 1;
      }
      ret.push_back(depth_map[tree[i]]);
    }
  }
  return ret;
}

int main() {
  std::vector<unsigned> input = {0, 1, 2, 3, 3, 1, 2, 3};
  auto output = trim_single_child_nodes(input);
  for (auto depth : output) {
    std::cout << depth << ' ';
  }
}