void levelorder(list *node,int level){
if (node == NULL)
return;
if (level == 1)
printf("%d ", node->item);
else if (level > 1)
{
levelorder(node->left, level-1);
levelorder(node->right, level-1);
}
}
int main(){
int i ;
list *root = insert(1) ;
root->left = insert(2);
root->right = insert(3);
root->left->left = insert(4);
root->left->right = insert(5);
int h = height(root) ;
for(i=1;i<h;i++){
levelorder(root,i) ;printf("\n") ;
}
levelorder(root,h) ;
}
void CBinaryTree<type>::LevelorderTraversal(void)
{
CQueue<nodeType<type>*> queue;
std::cout<<"Levelorder: ";
levelorder(m_root,&queue);
std::cout<<std::endl;
}
int main()
{
int x = 1;
Tree<int>* tree = new Tree<int>(NULL,x,NULL);
x = 2;
Tree<int>* r = new Tree<int>(NULL,x,NULL);
x = 3 ;
Tree<int>* l = new Tree<int>(NULL,x,NULL);
x = 4 ;
Tree<int>* ll = new Tree<int>(NULL,x,NULL);
x = 5;
Tree<int>* rl = new Tree<int>(NULL,x,NULL);
x = 6;
Tree<int>* lr = new Tree<int>(NULL,x,NULL);
x = 7;
Tree<int>* rr = new Tree<int>(NULL,x,NULL);
r->setLeftTree(rl);
l->setLeftTree(ll);
r->setRightTree(rr);
l->setRightTree(lr);
tree->setRightTree(r);
tree->setLeftTree(l);
levelorder(tree);
deleteTree(tree);
return 0;
}
void btree_apply_by_level(t_btree *root, void (*applyf)(void *item,
int current_level, int is_first_elem))
{
int i;
int u;
i = 0;
u = 0;
levelorder(root, applyf, &i, &u);
}
//根据先序和中序遍历结果构建树
void bulid_by_preorder_inorder(){
int apreoder[] = { 1, 2, 4, 3, 5, 6};
int ainoder[] = { 4, 2, 1, 5, 3, 6};
int len = sizeof(apreoder)/sizeof(int);
vector<int> preoder = to_vector(apreoder,len);
vector<int> inoder = to_vector(ainoder,len);
treenode* root = bulid_by_preorder_inorder(preoder,inoder,0,len-1,0,len-1);
cout<<root->data<<endl;
levelorder(root);
}
void testcase()
{
BinaryNode<int> *proot=NULL;
proot=createTree(proot);
std::cout<<"前序遍历:"<<std::endl;
preorder(proot,visitNode<int>);
std::cout<<std::endl;
std::cout<<"前序遍历:"<<std::endl;
preorderNotRecursive(proot,visitNode<int>);
std::cout<<std::endl;
std::cout<<"中序遍历:"<<std::endl;
inorder(proot,visitNode<int>);
std::cout<<std::endl;
std::cout<<"中序遍历:"<<std::endl;
inorderNotRecursive(proot,visitNode<int>);
std::cout<<std::endl;
std::cout<<"后序遍历:"<<std::endl;
postorder(proot,visitNode<int>);
std::cout<<std::endl;
std::cout<<"后序遍历:"<<std::endl;
postorderNotRecursive(proot,visitNode<int>);
std::cout<<std::endl;
std::cout<<"层次遍历:"<<std::endl;
levelorder(proot,visitNode<int>);
std::cout<<std::endl;
//delete
//std::vector<BinaryNode<int>*> v;
levelorder(proot,destroyNode<int>);//std::back_inserter<decltype(proot)>(v));
std::for_each(v.begin(),v.end(),[](BinaryNode<int> *p){
delete p;
});
}
int main()
{
int x = 1;
Tree<int>* tree = new Tree<int>(NULL,x,NULL);
x = 2;
Tree<int>* r = new Tree<int>(NULL,x,NULL);
x = 3 ;
Tree<int>* l = new Tree<int>(NULL,x,NULL);
x = 4 ;
Tree<int>* ll = new Tree<int>(NULL,x,NULL);
x = 5;
Tree<int>* rl = new Tree<int>(NULL,x,NULL);
x = 6;
Tree<int>* lr = new Tree<int>(NULL,x,NULL);
x = 7;
Tree<int>* rr = new Tree<int>(NULL,x,NULL);
r->setLeftTree(rl);
l->setLeftTree(ll);
r->setRightTree(rr);
l->setRightTree(lr);
tree->setRightTree(r);
tree->setLeftTree(l);
Tree<int>* newTree = NULL;
assign(tree,newTree);
cout << "Level Order Original" << endl;
levelorder(tree);
cout << "Level Order Duplicate" << endl;
levelorder(newTree);
return 0;
}
int main(void)
{
struct node* root = NULL;
//struct node* root2 = NULL;
struct node *find = NULL;
char str[1024];
root = insert(root, 10);
root = insert(root, 15);
root = insert(root, 9);
root = insert(root, 8);
root = insert(root, 13);
root = insert(root, 7);
root = insert(root, 5);
root = insert(root, 18);
root = insert(root, 22);
root = insert(root, 3);
root = insert(root, 4);
root = insert(root, 2);
root = insert(root, 1);
print_ascii_tree(root);
find = search(root, 18);
print_ascii_tree(root);
find = search(root, 22);
printf("\n\n\nDATA found is %d\n", find->data);
find = min_node(root);
printf("Min in this tree is %d\n", find->data);
find = max_node(root);
printf("Mx in this tree is %d\n", find->data);
print_ascii_tree(root);
preorder(root);
printf("\n");
inorder(root);
printf("\n");
postorder(root);
printf("\n");
printf("DEPTH is %d\n", depth(root));
tree_to_string(root, str);
printf("The STR generated is %s\n", str);
//string_to_tree(&root2, str);
//print_ascii_tree(root2);
printf("COUNT is %d\n",nodes(root));
bool res = hassum(root, 45);
printf("Bool val is %d\n", (int)res);
levelorder(root);
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
root=insert(20);
root->left=insert(13);
root->right=insert(40);
root->left->left=insert(3);
root->left->right=NULL;
root->right->left=NULL;
root->right->right=insert(45);
root->left->left->left=NULL;
root->left->left->right=insert(8);
root->right->right->left=insert(43);
root->right->right->right=NULL;
//root->left->left->left=NULL;
//root->left->left->right=NULL;
///*root->left->right->left=NULL;*/
//root->left->right->right=insert(8);
///*root->right->left->left=NULL;*/
//printf("the preorder is\n");
///*root->right->left->right=NULL;*/
//root->right->right->left=insert(43);
///*root->right->right->right=NULL;*/
display(root);
/*int pre[]={20,10,3,12,40,35,50};
int in[]={3,10,12,20,35,40,50};
constructbin(in,pre,0,6);*/
/*printf("the postorder is\n");
post(root);*/
/*printf("\n modified tree is\n");
node *res=change(root);
display(res);*/
printf("nodeval\tnoofchild\n");
printf("---------------------------\n");
noofchild(root);
displaywithchild(root);
printf("the level ordering of the given bst is\n");
levelorder(root);
return 0;
}
int main(int argc, char** argv) {
BTreeNode* root = create();
printf("preorder :\n");
preorder(root);
printf("\ninorder :\n");
inorder(root);
printf("\npostorder:\n");
postorder(root);
printf("\n");
printf("\nleverorder:\n");
levelorder(root);
printf("\n");
printf("the number of leaves is : %d \n",getLeavesNum(root));
printf("the depth of the binary tree is :%d\n",getDepth(root));
return (EXIT_SUCCESS);
}
int main()
{
#if 0
int a[] = {2, 4, 1, 8, 3, 5, 9, 6, 7};
tree_t root = NULL;
for(int i = 0; i < 9; ++i)
{
root = insert(root,a[i]);
}
display(root);
printf("----------------------\n");
#endif
#if 0
printf("In-order traversal \n");
display(root);
printf("No of nodes: %d\n", count(root));
printf("----------------------\n");
printf("No of leaf nodes: %d\n",count_leaf(root));
printf("----------------------\n");
printf("Pre-order traversal\n");
post_traversal(root);
printf("----------------------\n");
printf("Post-order traversal\n");
pre_traversal(root);
printf("----------------------\n");
printf("Height of the tree is: %d\n", height(root));
printf("Least value in tree is: %d\n", least_of_tree(root));
printf("Max value of tree is: %d\n", max_of_tree(root));
int height_ = height(root);
int vertical_sum[10000];
for(int i = 0; i < 10000; ++i)
{
vertical_sum[i] = 0;
}
/*
I assumed Vertical sum for root is 1... :P if there are more no of nodes on the
left subtree of the root..they we cant implement this using arrays in c..as negative indices is not possible
*/
verticalSumArray(root,vertical_sum,1);
for(int i = 0;vertical_sum[i] != 0 ; ++i)
{
printf("%d : %d \n",i,vertical_sum[i]);
}
// tree_t mirrored_root = mirror_tree(root);
printf("----------------------\n");
// display(mirrored_root);
//printf("%d\n", RLMirrors(root));
//inorder(root);
tree_t largest = largestSumSubtree(root);
printf("%d\n",largest -> key);
int key = 1;
if(search(root,key) != NULL)
{
printf("%d is present\n",key);
}
else
{
printf("%d is absent\n",key);
}
iterativeInorder(root);
printf("----------------------\n");
iterativePreorder(root);
printf("----------------------\n");
iterativePostorder(root);
levelorder(root);
int height = 0;
printf("the diameter of the tree: %d\n",diameter(root));
int key = 9;
printAncestorsI(root,key);
int k = 3;
printKdistance(root,k);
int sum = 36;
if(hasSumPath(root,sum) == 1)
{
printf("Yes\n");
}
else
{
printf("No\n");
}
root = getNode(10);
root -> llink = getNode(8);
root -> rlink = getNode(2);
root -> llink -> llink = getNode(3);
root -> llink -> rlink = getNode(5);
root -> rlink ->rlink = getNode(2);
display(root);
printf("----------------------\n");
if(isSum(root))
{
printf("Yes\n");
}
else
{
printf("No\n");
}
root = getNode(20);
root -> llink = getNode(8);
root -> rlink = getNode(22);
root -> llink -> llink = getNode(4);
root -> llink -> rlink = getNode(12);
root -> llink -> rlink -> rlink = getNode(14);
root -> llink -> rlink -> llink = getNode(10);
int n1 = 4;
int n2 = 14;
printf("Least common ancestor of %d & %d is %d \n", n1,n2,lowestCommonAncestor(root,n1,n2));
printf("\n");
#endif
// printPaths(root);
#if 0
int num = 4;
printf("The no of bst for %d keys is %d\n", num,countTrees(num));i
#endif
#if 0
root = getNode(20);
root -> llink = getNode(8);
root -> rlink = getNode(22);
root -> llink -> llink = getNode(4);
root -> llink -> rlink = getNode(12);
root -> llink -> rlink -> llink = getNode(10);
root -> llink -> rlink -> rlink = getNode(14);
tree_t successor = inorderSuccessor(root,root -> llink);
if(successor != NULL)
{
printf("thei inorder successor is %d\n",successor -> key);
}
#endif
#if 0
root = getNode(20);
root -> llink = getNode(8);
root -> rlink = getNode(22);
root -> llink -> llink = getNode(100);
if(checkAllLeavesSameLevel(root) == 1)
{
printf("All the leaves are in the same level\n");
}
#endif
#if 0
display(root);
printf("-------------------------------------\n");
replaceNodeWithSum(root,0);
display(root);
int getSum(tree_t root)
{
if(root == NULL)
{
return 0;
}
else
{
return root -> key + getSum(root -> rlink);
}
}
#endif
// printf("%d\n",countTrees(3));
#if 0
root = getNode(10);
root->llink = getNode(20);
root->rlink = getNode(30);
if(isBalanced(root) == 1)
{
printf("The tree is balanced\n");
}
else
{
printf("Ther tree is unbalanced\n");
}
#endif
#if 0
tree_t root = NULL;
int array[] = {1,2,3,4,5,6,7,8,9};
int n = 9;
root = createMinimalBST(root,array,n);
display(root);
#endif
// tree_t root = NULL;
#if 0
root = getNode(20);
root -> llink = getNode(8);
root -> rlink = getNode(22);
root -> llink -> llink = getNode(4);
root -> llink -> rlink = getNode(12);
root -> llink -> rlink -> llink = getNode(10);
root -> llink -> rlink -> rlink = getNode(14);
// printPathWithSum(root,40);
// levelorderRecursive(root);
// rightView(root);
#endif
#if 0
int inorder[] = {4, 2, 5, 1, 6, 3};
int preorder[] = {1, 2, 4, 5, 3, 6};
int n = 6;
// int preIndex = 0;
// root = buildTreeWithInorderAndPreOrder(inorder,preorder,0,n - 1,&preIndex);
// display(root);
int index = 0;
printPostOrder(inorder,preorder,0,n - 1,&index);
#endif
#if 0
/*
10
-2 7
8 -4
*/
tree_t root = NULL;
root = getNode(10);
root->llink = getNode(-2);
root->rlink = getNode(7);
root->llink->llink = getNode(8);
root->llink->rlink = getNode(-4);
// printf("Sum: %d\n",maxSumPath(root));
pre_traversal(root);
printf("----------------------------------");
display(root);
#endif
return 0;
}
int main(int argc, char *argv[])
{
std::cerr << "reading graph...";
Eigen::SparseMatrix<double> g = readGraph(std::string(argv[1]));
std::cerr << "done." << std::endl;
#if DEBUG
std::cout << "Adjacency Matrix" << std::endl;
std::cout << g << std::endl;
#endif
std::vector<C_tuple*> C;
std::cerr << "getting C vector...";
getC(g, C);
std::cerr << "sorting...";
__gnu_parallel::sort(C.begin(), C.end(), C_tuple_compare);
//std::sort(C.begin(), C.end(), C_tuple_compare);
std::cerr << "done." << std::endl;
#if DEBUG
for (uint64_t i = 0; i < C.size(); i++)
{
std::cout << C[i]->i << ", " << C[i]->j << ", " << C[i]->value<< std::endl;
}
#endif
std::cerr << "creating T...";
node* root = createT(g, C);
std::cerr << "done." << std::endl;
#if DEBUG
//postorder(printNode, root);
levelorder(printNode, root);
node* left = root->leftChild;
while (left->leftChild) left = left->leftChild;
node* right = root->rightChild;
while (right->rightChild) right = right->rightChild;
node* lca = LCA(left, right);
std::cout << "lca for " << left->vertex << ", " << right->vertex << ": " << lca->vertex << std::endl;
left = right->parent->leftChild;
lca = LCA(left, right);
std::cout << "lca for " << left->vertex << ", " << right->vertex << ": " << lca->vertex << std::endl;
#endif
std::cerr << "counting vertices and edges...";
countVerticesAndEdges(g, root);
std::cerr << "done." << std::endl;
std::cerr << "computing density...";
computeDensity(root);
std::cerr << "done." << std::endl;
#if DEBUG
std::cout << "\nPrinting after the countVerticesAndEdges\n" << std::endl;
postorder(printNode, root);
#endif
std::cerr << "extracting subgraphs...";
extractSubgraphs(root, 0.75);
std::cerr << "done." << std::endl;
}
int main(int argc, char *argv[]){
element_type test_array[20];
int i;
BTREE T = init_tree();
TREE_NODE p;
int height;
for(i=0; i<20; i++){
test_array[i]= random(200);
printf("%d, ", test_array[i]);
}
printf("\n");
T = creat_tree(test_array, sizeof(test_array)/sizeof(test_array[0]), T);
height = height_recursive(T);
printf("height is %d\n", height);
printf("preorder:\n");
preorder_recursive(T);
printf("\n");
printf("inoder:\n");
inorder_recursive(T);
printf("\n");
printf("postorder:\n");
postorder_recursive(T);
printf("\n");
printf("preorder nonrec:\n");
preorder_norecursive(T);
printf("\n");
printf("inorder nonrec:\n");
inorder_norecursive(T);
printf("\n");
printf("postorder nonrec:\n");
postorder_norcursive(T);
printf("\n");
printf("levelorder:\n");
levelorder(T);
printf("\n");
printf("print leaf recursive:\n");
output_leaf_recursive(T);
printf("\n");
printf("print leaf norecursive\n");
output_leaf_norecursive(T);
printf("\n");
printf("find an element\n");
if(find_tree(177, T) == NULL)
printf("no such element\n");
else
preorder_recursive(find_tree(177, T));
printf("\n");
printf("min node\n");
visit(find_min(T)->element);
printf("\n");
printf("max node\n");
visit(find_max(T)->element);
printf("\n");
printf("delet:\n");
tree_delete(115, T);
preorder_recursive(T);
printf("\n");
printf("exchange tree:\n");
exchange_recursive(T);
preorder_recursive(T);
printf("\n");
printf("exchange tree norecursive:\n");
exchange_norecursive(T);
preorder_recursive(T);
printf("\n");
free_tree(T);
return 0;
}
