# Constraints

Time Limit: 1 secs, Memory Limit: 32 MB

# Description

A right-heavy tree is a binary tree where the value of a node is greater than or equal to the values of the nodes in its left subtree and less than the values of the nodes in its right subtree. A right-heavy tree could be empty.

Write a program that will create a right-heavy tree from a given input sequence and then traverse the tree and printing the value of the node each time a node is visited using inorder, preorder and postorder traversal.

The program should create the nodes in the tree dynamically. Thus, basically the tree can be of any size limited only by the amount of memory available in the computer.

# Input

The input will contain several test cases, each of them as described below.

The first number in the input indicates the number of nodes in the tree. Then, the input is followed by the integers comprising the values of the nodes of the tree.

# Output

For each test case, the output must follow the description below. The outputs of two consecutive cases will be separated by a blank line. The output will be the sequence of node and labeled by the traversal method used, as shown in the sample output below.

# Sample Input

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

# Sample Output

Inorder: 1 2 3 4 5 6 7 8
Preorder: 8 2 1 4 3 7 5 6
Postorder: 1 3 6 5 7 4 2 8

Inorder: 2 2 3 3 3 5 5 6 9
Preorder: 5 5 3 2 2 3 3 6 9
Postorder: 2 3 3 2 3 5 9 6 5

Inorder: 1 1 2 2 3 4 4 5
Preorder: 4 2 1 1 2 4 3 5
Postorder: 1 2 1 3 4 2 5 4

Inorder:
Preorder:
Postorder:

#include <stdio.h>

struct Node {
Node *l, *r;
int id;
Node () {
}
Node (int id_) {
id = id_;
l = NULL;
r = NULL;
}
};
Node *nodes;

inline void insert(int key) {
Node *temp;
temp = nodes;
while (1) {
if (temp->id >= key) {
if (temp->l == NULL) {
temp->l = new Node(key);
return;
} else {
temp = temp->l;
}
} else {
if (temp->r == NULL) {
temp->r = new Node(key);
return;
} else {
temp = temp->r;
}
}
}
}

inline  void inorder(Node *t) {
if (t->l != NULL)
inorder(t->l);
printf(" %d", t->id);
if (t->r != NULL)
inorder(t->r);
}

inline void preorder(Node *t) {
printf(" %d", t->id);
if (t->l != NULL)
preorder(t->l);
if (t->r != NULL)
preorder(t->r);
}

inline void postorder(Node *t) {
if (t->l != NULL)
postorder(t->l);
if (t->r != NULL)
postorder(t->r);
printf(" %d", t->id);
}

int main() {
int num;
bool first = false;
while (scanf("%d", &num) != EOF) {
if (first)
printf("\n");
first = true;

if (num == 0) {
printf("Inorder: \nPreorder: \npostorder: \n");
break;
}

int digit[num];
for (int c = 0; c < num; ++c)
scanf("%d", &digit[c]);

nodes = new Node(digit[0]);
for (int c = 1; c < num; ++c) {
insert(digit[c]);
}

//
printf("Inorder:");
inorder(nodes);
printf("\n");
//
printf("Preorder:");
preorder(nodes);
printf("\n");
//
printf("Postorder:");
postorder(nodes);
printf("\n");
}
return 0;
}

#### thinkphp5微信开发实践教程

2017年08月15日 11:23

#### Sicily 1310. Right-Heavy Tree

2013-09-07 20:17:18

#### SOJ 1310. Right-Heavy Tree

2013-08-26 00:21:27

#### 1310. Right-Heavy Tree

2015-01-13 19:48:22

#### Sicily AVL Tree

2016-12-09 16:27:16

#### sicily 1156.Binary tree

2014-12-15 17:08:55

#### sicily inorder traversal for Binary Tree[递归和非递归]

2013-12-29 01:50:50

#### Sicily 1156 Binary tree

2012-01-26 20:27:52

#### Right-heavy tree——笛卡尔树

2016-05-23 20:29:24

#### Binary Tree Level Order Traversal -- LeetCode

2014-04-11 01:48:49

## 不良信息举报

sicily 1310. Right-Heavy Tree