时间和空间复杂度在二叉树的每个级别上创建元素矢量（NON-BST）

Question

Could you please help me understand calculating the time and space complexity of the below function.

function(): Role: create vector of nodes at each levels

1. create a queue.
2. add the root
3. copy the elements in the queue to the vector.
4. traverse the vector and append the child(left & right) to the queue.
5. repeat steps 3 & 4 until the queue is empty.

below is the code.

struct node {
     int value;
     struct node* p_left;
     struct node* p_right;
};

void levels_list(struct node* p_btree) {
     if(!p_btree) {
          return ;
     }


     std::queue<struct node*> q;
     std::vector<std::vector<struct node*> > v1;

     q.push(p_btree);
     bool choice = false;

     while(!q.empty()) {
          std::vector<struct node*> v;

          while(!q.empty()) {
               v.push_back(q.front());
               q.pop();
          }

          for(int i = 0; i < v.size(); i++) {
               if(v[i]->p_left) {
                    q.push(v[i]->p_left);
               }
               if(v[i]->p_right) {
                    q.push(v[i]->p_right);
               }
          }

          v1.push_back(v);
          v.clear();
     }
}

I see that it is O(n^2), am I correct? There are two loops the first one is outer and the second one is the inner which pushes the elements into the vector from the queue.

Thanks

Answer 1

At the beginning of each iteration, q has a set of nodes. At the end of each iteration, q has a set of its children. So each iteration of the loop is a level.

Each level only processes the nodes at that level. Push back to a vector is O(1) , push and pop from a queue is O(1) (amortized).

We don't do anything fancier than that. So this is O(n) computation time. Since the size of v and q will never be greater than n (If there is a fully complete row in the bt, it'll be ciel(n/2) ), and v1 only contains one of each node, this is also O(n) in space.

That being said, the above code is an excellent example of how you can write a complexity fine algorithm poorly. You end up doing a lot of unnecessary copies and allocations...There is no reason to use a queue like this, or even any intermediate data structure...you know the output vector and can keep track of the limits of where each level is in the output vector, so you can just iterate over it until you reach a level whose size is 0. If you know the number of elements of the BST you can preallocate this and it'll be nice and cache friendly.