// Driver program to test above functions
int main()
{
struct node* root1=NULL,*root2=NULL;
struct Queue* queue1=createQueue(SIZE),*queue2 = createQueue(SIZE);
int i;
for(i = 1; i <= 12; ++i)
insert(&root1,i, queue1);
for(i = 1; i <= 12; ++i)
insert(&root2,i, queue2);
mirror(root2);
printf("The tree_1 elements are: ");
levelOrder(root1);
printf("\nThe tree_2 elements are: ");
levelOrder(root2);
printf("\n");
if(checkmirror(root1,root2))
printf("\nThe trees are mirror image");
else
printf("\nThe trees are not mirror image");
return 0;
}
void levelOrder(TreeNode* root, vector<vector<int>> &vec, int depth) {
if(!root) return ;
if(vec.size() == depth)
vec.push_back(vector<int>());
vec[depth].push_back(root->val);
if(root->left) levelOrder(root->left, vec, depth+1);
if(root->right) levelOrder(root->right, vec, depth+1);
}
void levelOrder(TreeNode* root, int iDeepth, VVI& result) {
if (!root) return;
if (iDeepth >= result.size())
result.resize(iDeepth + 1);
result[iDeepth].push_back(root->val);
levelOrder(root->left, iDeepth + 1, result);
levelOrder(root->right, iDeepth + 1, result);
}
void levelOrder(TreeNode* root, int level){
if(!root){
return;
}
if(res.size() < level){
res.push_back(vector<int>{});
}
res[level-1].push_back(root->val);
levelOrder(root->left, level+1);
levelOrder(root->right, level+1);
}
void Heap::heapify()
{
std::cout<<"original heap:"<<std::endl;
levelOrder();
int index = size-1;
for(int i = int(floor((index-1)/2)); i>=0; i--)
{
std::cout<<"i = "<<i<<std::endl;
trickleDown(i);
levelOrder();
std::cout<<"\n"<<std::endl;
}
}
int main() {
struct TreeNode *root = (struct TreeNode *)malloc(sizeof(struct TreeNode));
root->val = 1;
struct TreeNode *node1_1 = (struct TreeNode *)malloc(sizeof(struct TreeNode));
node1_1->val = 2;
struct TreeNode *node1_2 = (struct TreeNode *)malloc(sizeof(struct TreeNode));
node1_2->val = 3;
root->left = node1_1;
root->right = node1_2;
node1_1->left = NULL;
node1_1->right = NULL;
node1_2->left = NULL;
node1_2->right = NULL;
int returnSize = 0;
int *columnSizes = (int *)malloc(sizeof(int));
int **return_array = levelOrder(root, &columnSizes, &returnSize);
assert(returnSize == 2);
assert(return_array[0][0] == 1);
assert(return_array[1][0] == 2);
assert(return_array[1][1] == 3);
return 0;
}
int main(){
//[3,9,20,null,null,15,7]
struct TreeNode* root = malloc(sizeof(struct TreeNode));
root->val = 3;
struct TreeNode* t1 = malloc(sizeof(struct TreeNode));
t1->val = 9;
struct TreeNode* t2 = malloc(sizeof(struct TreeNode));
t2->val = 20;
struct TreeNode* t3 = malloc(sizeof(struct TreeNode));
t3->val = 15;
struct TreeNode* t4 = malloc(sizeof(struct TreeNode));
t4->val = 7;
root->left = t1;
root->right = t2;
t1->left = NULL;
t1->right = NULL;
t2->left = t3;
t2->right = t4;
t3->left = t3->right = t4->left = t4->right = NULL;
int* columnSizes = malloc(sizeof(int) * 10);
int **result;
int* returnSize = malloc(sizeof(int));
result = levelOrder(root, &columnSizes, returnSize);
printf("return size: %d\n", *returnSize);
for(int i = 0; i < *returnSize; i++){
for(int j = 0; j < columnSizes[i]; j++){
printf("%d, ", result[i][j]);
}
printf("\n");
}
}
int main(int argc, char **argv)
{
int readInts;
struct node *root = NULL;
struct Queue *queue = createQueue(SIZE);
FILE *fp;
fp = fopen(argv[1],"r");
if (fp == NULL)
printf("NO SUCH FILE EXISTS. PLEASE TRY AGAIN.");
while (fscanf(fp, "%d", &readInts) != EOF)
{
//printf("Inserting %d into tree...\n", readInts);
treeInsert(&root, readInts, queue);
}
fclose(fp);
//for (int i = 0; i <= 12; ++i)
// treeInsert(&root, i, queue);
//maxHeapify(root);
levelOrder(root);
printf("SIZE is %d\n", SIZE);
return 0;
}
int findBottomLeftValue(TreeNode* root) {
if(!root){
return 0;
}
levelOrder(root, 1);
return res.back().front();
}
vector<vector<int>> levelOrderBottom(TreeNode* root) {
vector<vector<int>> res;
vector<TreeNode*> tp;
if (root == NULL) return res;
tp.push_back(root);
levelOrder(res, tp);
return res;
}
}
void levelOrder(s* r,int level)
{
if(r==NULL)
{
return;
}
else if(level==1)
{
printf("%c -> ",r->data);
return;
}
else
{
level--;
levelOrder(r->left,level);
levelOrder(r->right,level);
}
vector<vector<int>> levelOrderBottom(TreeNode *root) {
// write your code here
vector<vector<int>> v = levelOrder(root);
vector<vector<int>> v2;
for (int i = v.size()-1; i >= 0; i--) {
v2.push_back(v[i]);
}
return v2;
}
int main()
{
struct TreeNode root;
root.val = 3;
root.left = NULL;
root.right=NULL;
int* columnSizes;
int returnSize;
levelOrder(&root, &columnSizes, &returnSize);
}
void levelOrder(vector<vector<int>>& res, vector<TreeNode*> tp){
vector<TreeNode*> mvt;
vector<int> mvi;
if (tp.empty())
return;
for (int i = 0; i < tp.size(); i++){
mvi.push_back(tp[i]->val);
if (tp[i]->left != NULL) mvt.push_back(tp[i]->left);
if (tp[i]->right != NULL) mvt.push_back(tp[i]->right);
}
levelOrder(res, mvt);
res.push_back(mvi);
}
// Driver program to test above functions
int main()
{
struct node* root = NULL;
struct Queue* queue = createQueue(SIZE);
int i;
for(i = 1; i <= 12; ++i)
insert(&root, i, queue);
printf("The tree elements are: ");
levelOrder(root);
printf("\nThe height of the tree is %d",findheight(root));
return 0;
}
// Driver program to test above functions
int main()
{
struct node* root = NULL;
struct Queue* queue = createQueue(SIZE);
int i;
for(i = 1; i <= 12; ++i)
insert(&root, i, queue);
levelOrder(root);
return 0;
}
// Driver program to test above functions
int main()
{
struct node* root = NULL;
struct Queue* queue = createQueue(SIZE);
int i,l=0;
for(i = 1; i <= 8; ++i)
insert(&root,i, queue);
printf("The tree elements are: ");
levelOrder(root);
int res = findmaxlevel(root);
printf("\nThe max level is %d and the corresponding sum is %d",res,max_sum);
return 0;
}
vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
vector<vector<int>> result = levelOrder(root);
int i = 1;
while(i < result.size())
{
reverse(result[i].begin(),result[i].end());
i += 2;
}
return result;
}
// Driver program to test above functions
int main()
{
struct node* root = NULL;
struct Queue* queue = createQueue(SIZE);
int i;
for(i = 1; i <= 12; ++i)
insert(&root,i, queue);
printf("The tree elements are: ");
levelOrder(root);
printf("\nThe number of leaf nodes are %d",leafnode(root));
printf("\nThe number of leaf nodes are %d",fullnode(root));
return 0;
}
// Driver program to test above functions
int main()
{
struct node* root = NULL;
struct Queue* queue = createQueue(SIZE);
int i;
for(i = 1; i <= 12; ++i)
insert(&root, rand(), queue);
printf("The tree elements are: ");
levelOrder(root);
printf("\nThe max element using recursion is %d",findmaxwithrecursion(root));
printf("\nThe max element withou using recursion is %d",findmaxwithoutrecursion(root));
return 0;
}
int main(){
int *columnSizes ;
int returnSize ;
struct TreeNode* root = createTree() ;
int** result = levelOrder(root,&columnSizes,&returnSize) ;
for(int i=0;i<returnSize;i++){
for(int j=0;j<columnSizes[i];j++){
printf("%c",(char)result[i][j]) ;
}
printf("\n") ;
}
// printT(root) ;
return 0 ;
}
vector<vector<int> > levelOrder(TreeNode *root) {
vector<vector<int>> ans;
if(root == NULL)
return ans;
vector<int> base;
base.push_back(root->val);
ans.push_back(base);
vector<vector<int>> left = levelOrder(root->left), right = levelOrder(root->right);
for(int i = 0; i < left.size(); ++ i)
{
vector<int> temp = left[i];
if(i < right.size())
for(int j = 0; j < right[i].size(); ++ j)
temp.push_back(right[i][j]);
ans.push_back(temp);
}
if(right.size() > left.size())
{
for(int i = left.size(); i < right.size(); ++ i)
ans.push_back(right[i]);
}
return ans;
}
/* function main begins program execution */
int main(void)
{
int i; /* counter to loop from 1-10 */
int item; /* variable to hold random values */
TreeNodePtr rootPtr = NULL; /* tree initially empty */
srand( time( NULL ) );
printf( "The numbers being placed in the tree are:\n" );
/* insert random values between 1 and 15 in the tree */
for ( i = 1; i <= 10; i++ ) {
item = 1 + rand() % 10;
printf( "%3d", item );
insertNode( &rootPtr, item );
} /* end for */
printf("\n\nInsert the value to remove: ");
scanf("%d", &item);
if( deleteNode( &rootPtr, item ) ) {
printf("Value not found or value is root: %d\n", item);
return -1;
}
/* traverse the tree preOrder */
printf( "\nThe preOrder traversal is:\n" );
preOrder( rootPtr );
/* traverse the tree inOrder */
printf( "\n\nThe inOrder traversal is:\n" );
inOrder( rootPtr );
/* traverse the tree postOrder */
printf( "\n\nThe postOrder traversal is:\n" );
postOrder( rootPtr );
/* traverse the tree levelOrder */
printf( "\n\nThe levelOrder traversal is:\n" );
levelOrder( rootPtr );
puts("\n\nShow the tree\n\n");
outputTree(rootPtr, 0);
putchar('\n');
return 0; /* indicates successful termination */
} /* end main */
// Driver program to test above functions
int main()
{
struct node* root = NULL;
struct Queue* queue = createQueue(SIZE);
int i,key;
for(i = 1; i <= 12; ++i)
insert(&root,i, queue);
printf("The tree elements are: ");
levelOrder(root);
printf("\nThe element you are searching for = ");
scanf("%d",&key);
int flag=0;
if(findkey(root,key))
printf("\nThe element exists in the tree");
else
printf("\nThe element doesnot exist in the tree");
return 0;
}
int main(int argc, char const *argv[])
{
// int A[100];
// findIJAncestor(A, 30, 90);
BiTree t = createABiTree();
// question1
preOrder(t);
cout<<endl;
inOrder(t);
cout<<endl;
postOrder(t);
cout<<endl;
levelOrder(t);
cout<<endl;
cout<<"height is "<<heightOfT(t)<<endl;
// question2
// int pre[] = {500,64,25,0,37,37,37,26,59,328,74,115,97,92,86,106,109,261,214,212,151,213,226,221,254,240,275,263,312,468,353,337,351,393,355,362,460,444,441,427,412,396,427,439,459,453,496,490,476,635,542,540,529,514,540,532,580,574,559,553,544,574,630,638,751,673,648,665,660,745,732,692,690,678,707,989,970,828,778,773,774,779,791,790,816,815,822,908,860,852,856,862,867,904,942,928,937,972,974,976};
// int in[] = {0,25,26,37,37,37,59,64,74,86,92,97,106,109,115,151,212,213,214,221,226,240,254,261,263,275,312,328,337,351,353,355,362,393,396,412,427,427,439,441,444,453,459,460,468,476,490,496,500,514,529,532,540,540,542,544,553,559,574,574,580,630,635,638,648,660,665,673,678,690,692,707,732,745,751,773,774,778,779,790,791,815,816,822,828,852,856,860,862,867,904,908,928,937,942,970,972,974,976,989};
// BiTree tt = createTwithPreIn(pre, in, 0, 99, 0, 99);
// preOrder(tt);
// postOrderNoRecurve(t);
// question3
initUFSets();
srand(time(NULL));
for (int i = 0; i < 100; ++i)
{
printf("%d ", rand() % 100);
Union(rand() % 100, rand() % 100);
}
for (int i = 0; i < 100; ++i)
{
printf("find(%d) = %d\n", i, Find(i));
}
return 0;
}
int main()
{
Node* root=NULL;
//Min(root);
//Max(root);
insert(root,15);
insert(root,13);
insert(root,24);
insert(root,24);
insert(root,100);
insert(root,240);
Search(root,24);
Search(root,15);
Search(root,100);
Search(root,240);
std::cout<<"MINIMUM :"<<Min(root)<<std::endl;
std::cout<<"MAXIMUM :"<<Max(root)<<std::endl;
std::cout<<"HEIGHT :"<<Height(root)<<std::endl;
levelOrder(root);
std::cout<<std::endl;
preOrder(root);
std::cout<<std::endl;
inOrder(root);
std::cout<<std::endl;
postOrder(root);
std::cout<<std::endl;
std::vector<int> v;
isBst(root, v);
for(const int& a:v)
std::cout<<a<<" ";
std::cout<<std::endl;
return 5;
}
vector<vector<int>> levelOrderBottom(TreeNode* root) {
int d = depth(root);
vector<vector<int>> ans(d,vector<int> {});
levelOrder(ans,root,d-1);
return ans;
}
vector<vector<int>> levelOrder(TreeNode* root) {
VVI result;
levelOrder(root, 0, result);
return result;
}
void BST::levelOrder()
{
levelOrder(root); // does it need a helper? No
}
void BST::levelOrder()
{
levelOrder(root);
}
