void preorder_traversal(treenode *T){
if(T==NULL)
return;
printf("%d ", T->id);
preorder_traversal(T->lc);
preorder_traversal(T->rc);
}
void preorder_traversal(struct node* node){
if(node!=NULL){
printf("%d ",node->data);
preorder_traversal(node->left);
preorder_traversal(node->right);
}
}
void preorder_traversal(tree_node *node)
{
if (node != NULL) {
printf("%d, ", node->data);
preorder_traversal(node->left);
preorder_traversal(node->right);
}
}
void postorder_traversal(struct node * root)
{
if (root != NULL) {
preorder_traversal(root->left);
preorder_traversal(root->right);
printf("%d ", root->data);
}
}
// Function for preorder traversal of Binary Tree
void preorder_traversal(struct node* tree)
{
if(tree == NULL)
return;
printf("\t%d", tree->data);
preorder_traversal(tree->left);
preorder_traversal(tree->right);
}
void preorder_traversal( tree *T )
{
if(T!=NULL)
{
printf("%d ",T->item);
preorder_traversal( T->left );
preorder_traversal( T->right );
}
}
void preorder_traversal(BTreeNode *root) {
if (root == NULL) {
return;
}
printf("value = %d\n", root->value);
preorder_traversal(root->left);
preorder_traversal(root->right);
}
void preorder_traversal(minHeap *hp, int i) {
if((2i) < hp->size) {
preorder_traversal(hp, (2i)) ;
}
if((2i+1) < hp->size) {
preorder_traversal(hp, (2i+1)) ;
}
printf("%d ", hp->elem[i].data) ;
}
void preorder_traversal(struct node *root, int *arr, int* i2){
if (root != NULL && arr != NULL)
{
arr[*i2] = root->data;
(*i2)++;
preorder_traversal(root->left, arr, i2);
preorder_traversal(root->right, arr, i2);
}
}
void preorder_traversal(struct node *root, int *arr, int *index){
if (root == NULL)
return;
arr[*index] = root->data;
*index = *index + 1;
preorder_traversal(root->left, arr, index);
preorder_traversal(root->right, arr, index);
}
// 先序遍历
void preorder_traversal(ky_rbtree_s *root)
{
int *key;
int *value;
if ( root != ky_rbtree_nil )
{
key = root->key;
value = root->value;
printf( "key: %d value: %d color: %s\n", *key, *value, color_str(root) );
preorder_traversal(root->left);
preorder_traversal(root->right);
}
}
main()
{
tree *t;
t=NULL;
int i,q,w,flag;
char c,d;
while(1)
{
scanf("%d",&q);
c=getchar();
// insert(q,&t1);
if(c=='\n')
break;
}
while(1)
{
scanf("%d",&w);
d=getchar();
insert(w,&t);
if(d=='\n')
break;
}
inorder_traversal(t);
printf("\n");
preorder_traversal(t);
printf("\n");
postorder_traversal(t);
printf("\n");
levelprint(t);
printf("\n");
}
unsigned int ParsedGraph::preorder_traversal( Node * node )
{
unsigned int nodes_visited=0;
if( node->visited() == true ){
mrn_dbg(1, mrn_printf(FLF, stderr, "%s:%u: Node is own ancestor",
node->_hostname.c_str(), node->_local_rank ) );
error( ERR_TOPOLOGY_CYCLE, UnknownRank, "%s:%u: Node is own ancestor",
node->_hostname.c_str(), node->_local_rank );
_cycle_free=false;
return 0;
}
else{
node->visit();
nodes_visited++;
if(node->_children.size() == 0){
return nodes_visited;
}
}
for(unsigned int i=0; i<node->_children.size(); i++){
nodes_visited+=preorder_traversal(node->_children[i]);
}
return nodes_visited;
}
void preorder(struct node *root, int *arr){
if (arr == NULL)
return;
int i=0;
preorder_traversal(root, arr, &i);
}
string CBinarySearchDictionary::preorder_traversal(Node *pNode)
{
string strValue = "";
string strLeft = "";
string strRight = "";
if (pNode != NULL)
{
strLeft = preorder_traversal(pNode->pLeft);
strRight = preorder_traversal(pNode->pRight);
strValue = pNode->strNameValue + "\t" + strLeft + "\t" + strRight;
}
return strValue;
}
void KTREE::preorder_traversal(TNode* node)
{
cout <<" "<<node->getElement();
for (int i=0;i<MAX;i++)
if (node->getChild(i)!=0)
{
cout <<" ";
preorder_traversal(node->getChild(i));
}
}
bool ParsedGraph::validate()
{
unsigned int visited_nodes = preorder_traversal( _root );
if( visited_nodes != _nodes.size() ) {
mrn_dbg(1, mrn_printf(FLF, stderr, "Failure: "
"visited nodes(%d) != total nodes(%d)!\n",
visited_nodes, _nodes.size() ));
error( ERR_TOPOLOGY_NOTCONNECTED, UnknownRank, "parsed graph not connected" );
_fully_connected = false;
}
fflush(stdout);
return ( _cycle_free && _fully_connected );
}
void KTREE::preorder_traversal()
{
TNode *tmp; //pre order
tmp=top;
if (top==0)
cout <<"empty tree !!!"<<endl;
else
{
cout <<tmp->getElement()<<" ";
for (int i=0;i<MAX;i++)
if (top->getChild(i)!=0)
preorder_traversal(top->getChild(i));
}
cout<<endl;
}
int main()
{
char msg[] = " deadbeef";
binary_tree_t t = create_tree(msg, 8);
printf("%d", tree_height(t));
sep;
preorder_traversal(t, print_node);
sep;
postorder_traversal(t, print_node);
sep;
inorder_traversal(t, print_node);
return 0;
}
void test_tree() {
vector<char> output;
Node<char> *tree = populate_test_tree();
// level-order
output.clear();
levelorder_traversal(tree, output);
assert(output == expected_output_levelorder);
// pre-order
output.clear();
preorder_traversal(tree, output);
assert(output == expected_output_preorder);
// in-order
output.clear();
inorder_traversal(tree, output);
assert(output == expected_output_inorder);
// post-order
output.clear();
postorder_traversal(tree, output);
assert(output == expected_output_postorder);
// pre-order (non-recursive)
output.clear();
preorder_traversal_nonrecursive(tree, output);
assert(output == expected_output_preorder);
// in-order (non-recursive)
output.clear();
inorder_traversal_nonrecursive(tree, output);
assert(output == expected_output_inorder);
// post-order (non-recursive)
output.clear();
postorder_traversal_nonrecursive(tree, output);
assert(output == expected_output_postorder);
}
int main(int argc, const char *argv[])
{
BTreeNode *root = NULL;
int operation = 0;
int value = 0;
while (operation != -1) {
printf("operations\n");
printf("1 : insert a value\n");
printf("2 : show the tree\n");
printf("3 : breadth_first_traversal\n");
printf("0 : exit\n");
scanf("%d", &operation);
switch (operation) {
case 1:
printf("input a value to insert:");
scanf("%d", &value);
insert_value(&root, value);
break;
case 2: {
printf("do preorder_traversal\n");
preorder_traversal(root);
printf("end preorder_traversal\n");
break;
}
case 3:
printf("do bfs\n");
breadth_first_traversal(root);
printf("end do bfs\n");
break;
default:
operation = -1;
break;
}
}
return 0;
}
int main()
{
char choice[100];
char choice2[100];
int element;
struct node * root = NULL;
do {
scanf("%s", choice);
if (!strcmp(choice, "preorder\0")) {
preorder_traversal(root);
printf("\n");
} else if (!strcmp(choice, "postorder\0")) {
postorder_traversal(root);
printf("\n");
} else if (!strcmp(choice, "inorder\0")) {
inorder_traversal(root);
printf("\n");
} else if (!strcmp(choice, "insert\0")) {
scanf(" %d", &element);
tree_insert(&root, element);
} else if (!strcmp(choice, "successor\0")) {
scanf(" %d", &element);
tree_insert(&root, element);
} else if (!strcmp(choice, "insert\0")) {
scanf(" %d", &element);
tree_insert(&root, element);
} else if (!strcmp(choice, "delete\0")) {
scanf(" %d", &element);
tree_delete(&root, element);
}
} while (strcmp(choice, "exit\0"));
return 0;
}
static int traverse_dump(struct bitree *tree, TRAVE_DIRECTION dir)
{
int cnt = -1, depth;
const char *str = NULL;
if (!tree)
goto exit;
if (dir >= TRAVE_PREORDER && dir < TRAVE_MAX)
str = TRAVERSE_STRINGS[dir];
switch (dir) {
case TRAVE_PREORDER:
cnt = preorder_traversal(tree->root, visit);
break;
case TRAVE_INORDER:
cnt = inorder_traversal(tree->root, visit);
break;
case TRAVE_POSTORDER:
cnt = postorder_traversal(tree->root, visit);
break;
case TRAVE_LEVELORDER:
cnt = levelorder_traversal(tree->root, visit, &depth);
fprintf(stdout, "%s: depth:%d\n", str, depth);
break;
default:
break;
}
fprintf(stdout, "%s: total %d nodes traversed\n",
(str == NULL) ? "N/A" : str , cnt);
dump_visit_list(TRUE);
exit:
return cnt;
}
int main()
{
int choice, counter, flag, num;
char temp[LIMIT];
struct node *root = NULL;
system("clear");
//root->left = create_leaf_node(2);
//root->right = create_leaf_node(31);
//root->left->left = create_leaf_node(14);
//root->left->right = create_leaf_node(5);
//root->right->left = create_leaf_node(44);
//root->right->right = create_leaf_node(15);
do
{
// Display Menu for Operation on Binary Tree
printf("\n This program implements a AVL Tree \n");
printf("\n 1. Insert an element");
printf("\n 2. Delete an element");
printf("\n 3. Search an element");
printf("\n 4. Perform Inorder Traversal");
printf("\n 5. Perform Preorder Traversal");
printf("\n 6. Perform Postorder Traversal");
printf("\n 7. Display AVL Tree (Level Order)");
printf("\n 8. Exit");
printf("\n Enter your choice(1-8) : ");
scanf("%s", temp);
if (strlen(temp) > 1 || atoi(temp) < 1 || atoi(temp) > 8)
{
choice = 0;
}
else
choice = atoi(temp);
memset(temp, 0 , LIMIT);
switch(choice)
{
case 1:
do
{
flag = 0;
printf("\n Enter the integer element to be inserted : ");
scanf("%s", temp);
for(counter = 0; counter < strlen(temp); counter++)
{
if (temp[counter] < 48 || temp[counter] > 57)
{
printf("\n Invalid Data Type Entered .. Please input valid data type ... ");
flag = 1;
break;
}
}
num = atoi(temp);
}while(flag == 1);
root = insert_node(root, num);
printf("\n Element Inserted");
break;
case 2:
do
{
flag = 0;
printf("\n Enter the element to be deleted : ");
scanf("%s", temp);
for(counter = 0; counter < strlen(temp); counter++)
{
if (temp[counter] < 48 || temp[counter] > 57)
{
printf("\n Invalid Data Type Entered .. Please input valid data type ... ");
flag = 1;
break;
}
}
num = atoi(temp);
}while(flag == 1);
flag = binary_search(root, num);
if (flag == 1)
{
root = delete_node(root, num);
printf("\n Element Deleted");
}
else
printf("\n Deletion Element not found");
break;
case 3:
do
{
flag = 0;
printf("\n Enter the element to be searched : ");
scanf("%s", temp);
for(counter = 0; counter < strlen(temp); counter++)
{
if (temp[counter] < 48 || temp[counter] > 57)
{
printf("\n Invalid Data Type Entered .. Please input valid data type ... ");
flag = 1;
break;
}
}
num = atoi(temp);
}while(flag == 1);
flag = binary_search(root, num);
if (flag == 1)
printf("\n Element Found");
else
printf("\n Element not found");
break;
case 4:
printf("\n The Inorder Traversal of Entered Binary Tree is : \n");
inorder_traversal(root);
break;
case 5:
printf("\n The Preorder Traversal of Entered Binary Tree is : \n");
preorder_traversal(root);
break;
case 6:
printf("\n The Postorder Traversal of Entered Binary Tree is : \n");
postorder_traversal(root);
break;
case 7:
level_order_traversal(root);
break;
case 8:
break;
default:
printf("\nInvalid Choice\n");
}
}while(choice != 8);
return 0;
}
void preorder(struct node* root, int *arr)
{
int i2 = 0;
preorder_traversal(root, arr, &i2);
}
void pre_visit(treenode *T){
printf("result by using preorder traversal: ");
preorder_traversal(T);
printf("\n");
}
string CBinarySearchDictionary::preorder()
{
return preorder_traversal(root);
}
int main()
{
ky_rbtree_t *rbTree;
int isQuit = 0;
int key;
int value;
uint8 c;
int i;
rbTree = ky_rbtree_new(sizeof(int), sizeof(int), ky_cmp_int);
srand( time(NULL) );
for (i=0; i<50; i++) // 随机插入
{
key = rand() % 100;
value = rand() % 1000;
ky_rbtree_add( rbTree, &key, &value );
test_two_red( rbTree->tree ); // 每次插入都进行测试
black_count( rbTree->tree );
}
test_two_red( rbTree->tree );
printf("黑色路径长度: %d\n", black_count( rbTree->tree ) );
//printf("################################################\n");
//preorder_traversal( rbTree->tree );
//printf("################################################\n\n");
for (i=0; i<200; i++) // 随机删除
{
key = rand() % 100;
ky_rbtree_del( rbTree, &key );
test_two_red( rbTree->tree ); // 每次删除都进行测试
black_count( rbTree->tree );
}
test_two_red( rbTree->tree );
printf("黑色路径长度: %d\n", black_count( rbTree->tree ) );
printf("################################################\n");
preorder_traversal( rbTree->tree );
printf("################################################\n");
/*
while (1)
{
printf("\n\n1. add\n2. mod\n3. del\n4. show data\n5. quit\nplease input your choise: ");
scanf("%d", &c);
switch ( c )
{
case 1:
printf("please input yout key and value: ");
scanf("%d %d", &key, &value);
ky_rbtree_add( rbTree, &key, &value );
break;
case 2:
printf("please input your key and value: ");
scanf("%d %d", &key, &value);
ky_rbtree_mod( rbTree, &key, &value );
break;
case 3:
printf("please input yout key: ");
scanf("%d", &key);
ky_rbtree_del( rbTree, &key );
break;
case 4:
printf("################################################\n");
preorder_traversal( rbTree->tree );
printf("################################################\n");
break;
case 5:
isQuit = 1;
break;
default:
break;
}
if ( isQuit == 1 )
{
ky_rbtree_release( rbTree );
break;
}
}
*/
return 0;
}
void preorder_traversal(const Basic &b, Visitor &v)
{
b.accept(v);
for (const auto &p: b.get_args()) preorder_traversal(*p, v);
}
