int main()
{
/*
1. Inserting the elements.
2. Searching the elements.
3. Inroder, postorder and preorder.
4. Height of the tree.
*/
struct node *root = NULL;
insert_elements(&root, 5);
insert_elements(&root, 5);
insert_elements(&root, 3);
insert_elements(&root, 7);
printf("\nHeight of the BST: %d\n", height_BST(root));
insert_elements(&root, 1);
insert_elements(&root, 2);
insert_elements(&root, 6);
insert_elements(&root, 8);
print_tree_inorder(root);
printf("\n");
//print_tree_postorder(root);
insert_elements(&root, 22);
print_tree_postorder(root);
printf("\n");
print_tree_preorder(root);
printf("\n");
// A tree with only the root is of height 0
printf("\nHeight of the BST: %d\n", height_BST(root));
printf("\n%d\n", search_elements(&root, 4));
}
struct list *insert_elements(struct node *n, struct list *l)
{
struct list *l1 = n->p;
while(l1 != NULL)
{
l = list_insert(l, l1->a);
l1 = l1->next;
}
if(n->left !=NULL)
l = insert_elements(n->left, l);
if(n->right != NULL)
l = insert_elements(n->right, l);
return l;
}
int main()
{
vector<int> coll;
insert_elements(coll, 1, 9);
print_elements(coll, "coll: ");
// shuffle all elements randomly
random_shuffle(coll.begin(), coll.end());
print_elements(coll, "shuffled: ");
// sort them again
sort(coll.begin(), coll.end());
print_elements(coll, "sorted: ");
// shuffle elements with default engine
default_random_engine dre;
shuffle(coll.begin(), coll.end(), dre);
print_elements(coll, "shuffled: ");
MyRandom rd;
random_shuffle(coll.begin(), coll.end(), rd);
print_elements(coll, "own random engine shuffled result: ");
}
int main()
{
vector<int> coll;
vector<int>::iterator pos;
insert_elements(coll, 1, 9);
print_elements(coll, "coll: ");
// define an object for the predicate (using a lambda)
auto isEven = [](int elem) {
return elem % 2 == 0;
};
// print whether all, any, or none of the elements are/is even
cout << boolalpha << "all even?: "
<< all_of(coll.cbegin(), coll.cend(), isEven) << endl;
cout << "any even?: "
<< any_of(coll.cbegin(), coll.cend(), isEven) << endl;
cout << "none even?: "
<< none_of(coll.cbegin(), coll.cend(), isEven) << endl;
}
struct node *merge(struct node *T, int l, int u)
{
struct node *N;
N = (struct node *)malloc(sizeof(struct node));
N->p = NULL;
N->l = l;
N->u = u;
N->left = N->right = NULL;
struct list *p = N->p;
struct node *b, *c, *prev, *prev0;
prev0 = b = T;
while(b!=NULL)
{
if((l < b->l) && (u >= b->l))
{
prev = b;
c = b->left;
while(c != NULL)
{
if(l > c->u)
{
prev = c;
c = c->right;
}
else if(l < c->l)
{
struct list *temp = c->p;
struct node *del = c;
while(temp != NULL)
{
p = list_insert(p, temp->a);
temp = temp->next;
}
if(c->right != NULL)
p = insert_elements(c->right, p);
c = c->left;
if(del == prev->left)
prev->left = c;
else
prev->right = c;
free(del);
}
else
{
if(c->right != NULL)
p = insert_elements(c->right, p);
c->right = NULL;
struct list *temp = c->p;
struct list *prev1 = c->p;
while(temp != NULL && temp->a < l)
{
prev1 = temp;
temp = temp->next;
}
if(prev1 == c->p)
c->p = NULL;
else if(prev1 != NULL)
prev1->next = NULL;
while(temp != NULL)
{
p = list_insert(p, temp->a);
temp = temp->next;
}
if(c->l == l)
{
struct node *del = c;
c = c->left;
if(del != NULL && del == prev->left)
prev->left = c;
else if(del != NULL && del == prev->right)
prev->right = c;
free(del);
}
else
{
c->u = l-1;
}
N->left = b->left;
break;
}
}
N->left = b->left;
}
if((u > b->u) && (l <= b->u))
{
prev = b;
c = b->right;
while(c != NULL)
{
if(u < c->l)
{
prev = c;
c = c->left;
}
else if(u > c->u)
{
struct list *temp = c->p;
struct node *del = c;
while(temp != NULL)
{
p = list_insert(p, temp->a);
temp = temp->next;
}
if(c->left != NULL)
p = insert_elements(c->left, p);
c = c->right;
if(del == prev->left)
prev->left = c;
else
prev->right = c;
free(del);
}
else
{
if(c->left != NULL)
p = insert_elements(c->left, p);
c->left = NULL;
struct list *temp = c->p;
struct list *prev1 = temp;
while(temp != NULL && temp->a <= u)
{
p = list_insert(p, temp->a);
prev1 = temp;
temp = temp->next;
}
c->p = temp;
if(c->u == u)
{
struct node *del = c;
c = c->right;
if(del != NULL && del == prev->left)
prev->left = c;
else if(del != NULL && del == prev->right)
prev->right = c;
free(del);
}
else
{
c->l = u+1;
}
N->right = b->right;
break;
}
}
N->right = b->right;
}
struct list *temp = b->p;
if(l >= b->l && l <= b->u)
{
if(l > b->l)
{
N->left = (struct node *)malloc(sizeof(struct node));
N->left->p = NULL;
N->left->l = b->l;
N->left->u = l-1;
while(temp != NULL && temp->a < l)
{
N->left->p = list_insert(N->left->p, temp->a);
temp = temp->next;
}
N->left->left = b->left;
N->left->right = NULL;
}
else
N->left = b->left;
}
while(temp !=NULL && temp->a >= l && temp->a <= u)
{
p = list_insert(p, temp->a);
temp = temp->next;
}
if(u >= b->l && u <= b->u)
{
if(u < b->u)
{
N->right = (struct node *)malloc(sizeof(struct node));
N->right->p = NULL;
N->right->u = b->u;
N->right->l = u+1;
while(temp != NULL)
{
N->right->p = list_insert(N->right->p, temp->a);
temp = temp->next;
}
N->right->right = b->right;
N->right->left = NULL;
}
else
N->right = b->right;
}
if(u < b->l)
{
prev0 = b;
b = b->left;
}
else if(l > b->u)
{
prev0 = b;
b = b->right;
}
else
{
if(T == b)
{
T = N;
break;
}
else if(b == prev0->left)
prev0->left = N;
else if(b == prev0->right)
prev0->right = N;
free(b);
break;
}
}
N->p = p;
return T;
}
