Binary Tree

A rooted binary tree is a tree with a root node in which every node has at most two children.

Your task is to write a program which reads a rooted binary tree T and prints the following information for each node u of T:

• node ID of u
• parent of u
• sibling of u
• the number of children of u
• depth of u
• height of u
• node type (root, internal node or leaf)

If two nodes have the same parent, they are siblings. Here, if u and v have the same parent, we say u is a sibling of v (vice versa).

The height of a node in a tree is the number of edges on the longest simple downward path from the node to a leaf.

Here, the given binary tree consists of n nodes and evey node has a unique ID from 0 to n-1.

Input

The first line of the input includes an integer n, the number of nodes of the tree.

In the next n lines, the information of each node is given in the following format:

id left right

id is the node ID, left

Output

Print the information of each node in the following format:

node id: parent = p , sibling = s , degree = deg, depth = dep, height = h, type

p is ID of its parent. If the node does not have a parent, print -1.

s is ID of its sibling. If the node does not have a sibling, print -1.

deg, dep and h are the number of children, depth and height of the node respectively.

type is a type of nodes represented by a string (root, internal node or leaf. If the root can be considered as a leaf or an internal node, print root.

Please follow the format presented in a sample output below.

Constraints

• 1 ≤ n ≤ 25

Sample Input 1

9
0 1 4
1 2 3
2 -1 -1
3 -1 -1
4 5 8
5 6 7
6 -1 -1
7 -1 -1
8 -1 -1

Sample Output 1

node 0: parent = -1, sibling = -1, degree = 2, depth = 0, height = 3, root
node 1: parent = 0, sibling = 4, degree = 2, depth = 1, height = 1, internal node
node 2: parent = 1, sibling = 3, degree = 0, depth = 2, height = 0, leaf
node 3: parent = 1, sibling = 2, degree = 0, depth = 2, height = 0, leaf
node 4: parent = 0, sibling = 1, degree = 2, depth = 1, height = 2, internal node
node 5: parent = 4, sibling = 8, degree = 2, depth = 2, height = 1, internal node
node 6: parent = 5, sibling = 7, degree = 0, depth = 3, height = 0, leaf
node 7: parent = 5, sibling = 6, degree = 0, depth = 3, height = 0, leaf
node 8: parent = 4, sibling = 5, degree = 0, depth = 2, height = 0, leaf

Reference

Introduction to Algorithms, Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein. The MIT Press.

 求線段樹的高度就是求左右子樹的最大高度+1。

程式碼如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
const int maxn=30;
struct tree
{
    int height;  //節點高度
    int depth;   //節點深度
    int parent;  //節點的父節點
    int sibling; //節點的兄弟節點
    int left,right;//節點的左右孩子
    int degree;  //節點子節點個數
};
tree node[maxn];
int n;
void init()
{
    memset (node,-1,sizeof(node));
}
//求節點深度
int Sdepth (int x)
{
    if(node[x].parent==-1)
        node[x].depth=0;
    if(node[x].depth!=-1)
        return node[x].depth;
    return Sdepth(node[x].parent)+1;
}
//求節點高度
int Sheight(int x)
{
    if(x==-1)
       return -1;
    return max(Sheight(node[x].left)+1,Sheight(node[x].right)+1);
}
int main()
{
    scanf("%d",&n);
    init();
    for (int i=0;i<n;i++)
    {
        int x,left,right;
        scanf("%d%d%d",&x,&left,&right);
        left==-1? node[x].degree=0:node[x].degree=1,node[left].sibling=right,node[left].parent=x;
        right==-1? :node[x].degree=node[x].degree+1,node[right].sibling=left,node[right].parent=x;
        node[x].left=left; node[x].right=right;
    }
    for (int i=0;i<n;i++)
    {
        printf("node %d: parent = %d, sibling = %d, degree = %d, depth = %d, height = %d, ",i,node[i].parent,node[i].sibling,node[i].degree,node[i].depth=Sdepth(i),node[i].height=Sheight(i));
        if(node[i].parent==-1)
            printf("root\n");
        else if(node[i].left==-1&&node[i].right==-1)
            printf("leaf\n");
        else
            printf("internal node\n");
    }
    return 0;
}