Move Sub-Tree of N-Ary Tree

Move Sub-Tree of N-Ary Tree - Problem

Given the root of an N-ary tree with unique values, and two nodes p and q.

You should move the subtree of node p to become a direct child of node q. If p is already a direct child of q, do not change anything. Node p must be the last child in the children list of node q.

Return the root of the tree after adjusting it.

There are 3 cases for nodes p and q:

1. Node q is in the sub-tree of node p.

2. Node p is in the sub-tree of node q.

3. Neither node p is in the sub-tree of node q nor node q is in the sub-tree of node p.

In cases 2 and 3, you just need to move p (with its sub-tree) to be a child of q, but in case 1 the tree may be disconnected, thus you need to reconnect the tree again.

Input & Output

Example 1 — Move Node to Sibling

$ Input: root = [1,2,3,null,4,5,null,null,6,null], p = 2, q = 3

› Output: [1,3,null,2,5,null,null,4,null,null,6,null]

💡 Note: Move node 2 and its subtree (including node 4) to become the last child of node 3. Node 3 already has child 5, so node 2 becomes the second child.

Example 2 — q in Subtree of p

$ Input: root = [1,2,3,null,4,5,null,null,6,null], p = 1, q = 2

› Output: [2,4,1,null,null,3,null,null,5,null,null,6,null]

💡 Note: Node q=2 is in subtree of p=1. Move p=1 under q=2, and q=2 becomes the new root since original root was moved.

Example 3 — Already Direct Child

$ Input: root = [1,2,3,null,4,5,null], p = 4, q = 2

› Output: [1,2,3,null,4,5,null]

💡 Note: Node p=4 is already a direct child of q=2, so no change is needed.

Constraints

The total number of nodes is between [2, 1000]
Each node has a unique value
Node.val == p != Node.val == q
p and q are different and both exist in the tree

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8 M Microsoft 6

The key insight is to identify the three relationship cases between nodes p and q, then handle tree restructuring accordingly. The single-pass DFS approach is optimal, finding both nodes and their parents in one traversal. Time: O(n), Space: O(h) where h is tree height.

Common Approaches

✓ Brute Force DFS with Multiple Passes

⏱️ Time: O(n²) Space: O(h)

Traverse the tree multiple times to find p, q, their parents, and determine which case applies. Then perform the move operation by updating parent-child relationships.

Single Pass DFS

⏱️ Time: O(n) Space: O(h)

Use a single DFS traversal to find both nodes p and q, track their parents, and determine their relationship. Then perform the move operation efficiently.

Brute Force DFS with Multiple Passes — Algorithm Steps

Step 1: Find node p and its parent with DFS
Step 2: Find node q and its parent with DFS
Step 3: Check if p is ancestor of q or vice versa
Step 4: Remove p from its current parent and add to q's children

Visualization

Tap to expand

Step-by-Step Walkthrough

Find P and Parent

DFS to locate node p and its parent

Find Q and Parent

DFS to locate node q and its parent

Check Relationships

Determine if p is ancestor of q or vice versa

Move Subtree

Remove p from parent and add to q's children

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAXN 1000
#define MAXOUT 8000

struct Node {
    int val;
    int children[500];
    int childrenSize;
};

static struct Node pool[MAXN];
static int poolIdx = 0;

int newNode(int val) {
    pool[poolIdx].val = val;
    pool[poolIdx].childrenSize = 0;
    return poolIdx++;
}

static int vals[MAXN];
static int isNullArr[MAXN];
static int dataSize;

void parseInput(const char* line) {
    dataSize = 0;
    int len = strlen(line);
    int i = 1;
    while (i < len - 1) {
        while (i < len-1 && (line[i]==' '||line[i]==',')) i++;
        if (i >= len-1) break;
        if (strncmp(line+i,"null",4)==0) {
            isNullArr[dataSize]=1; vals[dataSize]=0; dataSize++; i+=4;
        } else {
            int neg=0; if(line[i]=='-'){neg=1;i++;}
            int num=0;
            while(i<len-1&&line[i]>='0'&&line[i]<='9') num=num*10+(line[i++]-'0');
            vals[dataSize]=neg?-num:num; isNullArr[dataSize]=0; dataSize++;
        }
    }
}

int buildTree() {
    if (dataSize==0||isNullArr[0]) return -1;
    poolIdx = 0;
    int queue[MAXN]; int front=0, rear=0;
    int root = newNode(vals[0]);
    queue[rear++] = root;
    int i = 1;
    while (front < rear && i < dataSize) {
        int cur = queue[front++];
        while (i < dataSize && !isNullArr[i]) {
            int child = newNode(vals[i++]);
            pool[cur].children[pool[cur].childrenSize++] = child;
            queue[rear++] = child;
        }
        if (i < dataSize && isNullArr[i]) i++;
    }
    return root;
}

int findNode(int rootIdx, int targetVal, int* parentIdx) {
    if (rootIdx < 0) return -1;
    int queue[MAXN]; int front=0, rear=0;
    int parentOf[MAXN];
    for(int i=0;i<MAXN;i++) parentOf[i]=-1;
    queue[rear++] = rootIdx;
    while (front < rear) {
        int idx = queue[front++];
        if (pool[idx].val == targetVal) {
            *parentIdx = parentOf[idx];
            return idx;
        }
        for (int i=0; i<pool[idx].childrenSize; i++) {
            int cid = pool[idx].children[i];
            parentOf[cid] = idx;
            queue[rear++] = cid;
        }
    }
    return -1;
}

int isAncestorOf(int ancestorIdx, int descendantVal) {
    if (ancestorIdx < 0) return 0;
    int queue[MAXN]; int front=0, rear=0;
    queue[rear++] = ancestorIdx;
    while (front < rear) {
        int idx = queue[front++];
        if (pool[idx].val == descendantVal) return 1;
        for (int i=0; i<pool[idx].childrenSize; i++) queue[rear++]=pool[idx].children[i];
    }
    return 0;
}

void removeChild(int parentIdx, int childIdx) {
    struct Node* p = &pool[parentIdx];
    for (int i=0; i<p->childrenSize; i++) {
        if (p->children[i] == childIdx) {
            for (int j=i; j<p->childrenSize-1; j++) p->children[j]=p->children[j+1];
            p->childrenSize--;
            return;
        }
    }
}

int solution(int root, int p, int q) {
    if (root < 0 || p == q) return root;
    int pParent=-1, qParent=-1;
    int pIdx = findNode(root, p, &pParent);
    int qIdx = findNode(root, q, &qParent);
    if (pIdx < 0 || qIdx < 0) return root;
    if (pParent == qIdx) return root;
    if (isAncestorOf(pIdx, q)) {
        if (pParent >= 0) removeChild(pParent, pIdx);
        int dummy;
        int qIdxNew = findNode(pIdx, q, &dummy);
        if (qIdxNew >= 0) pool[qIdxNew].children[pool[qIdxNew].childrenSize++] = pIdx;
        if (pParent < 0) return qIdxNew;
        return root;
    } else {
        if (pParent >= 0) removeChild(pParent, pIdx);
        pool[qIdx].children[pool[qIdx].childrenSize++] = pIdx;
        return root;
    }
}

static int outVals[MAXOUT];
static int outIsNull[MAXOUT];
static int outSize;

void collectTree(int rootIdx) {
    outSize = 0;
    if (rootIdx < 0) return;
    outIsNull[outSize]=0; outVals[outSize]=pool[rootIdx].val; outSize++;
    int queue[MAXN]; int front=0, rear=0;
    queue[rear++] = rootIdx;
    while (front < rear) {
        int idx = queue[front++];
        for (int i=0; i<pool[idx].childrenSize; i++) {
            int cid = pool[idx].children[i];
            outIsNull[outSize]=0; outVals[outSize]=pool[cid].val; outSize++;
            queue[rear++] = cid;
        }
        outIsNull[outSize]=1; outVals[outSize]=0; outSize++;
    }
    // Keep through the null after the last non-null value, drop the rest
    int lastVal=-1;
    for (int i=outSize-1;i>=0;i--) { if(!outIsNull[i]){lastVal=i;break;} }
    if (lastVal>=0 && lastVal+1<outSize && outIsNull[lastVal+1]) outSize=lastVal+2;
    else if (lastVal>=0) outSize=lastVal+1;
    else outSize=0;
}

void printTree(int rootIdx) {
    if (rootIdx < 0) { printf("[]"); return; }
    collectTree(rootIdx);
    printf("[");
    for (int i=0; i<outSize; i++) {
        if (i) printf(",");
        if (outIsNull[i]) printf("null"); else printf("%d", outVals[i]);
    }
    printf("]");
}

int main() {
    char line[10000];
    if (!fgets(line, sizeof(line), stdin)) return 1;
    int len = strlen(line);
    if (len > 0 && line[len-1]=='\n') line[--len]='\0';
    int p, q;
    if (scanf("%d", &p) != 1) return 1;
    if (scanf("%d", &q) != 1) return 1;
    parseInput(line);
    int root = buildTree();
    int result = solution(root, p, q);
    printTree(result);
    printf("\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Multiple DFS traversals in worst case, each taking O(n) time

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth up to tree height h

✓ Linear Space

12.5K Views

Medium Frequency

~25 min Avg. Time

234 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force DFS with Multiple Passes — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler