void printLeaves(TreeNode* root){
if(root){
printLeaves(root->left);
if(!root->left && !root->right)
cout<<root->data<<" ";
printLeaves(root->right);
}
}
void printLeaves(struct BSTNode* root)
{
if (root)
{
printLeaves(root->left);
if ( !(root->left) && !(root->right))
printf("%d ", root->data);
printLeaves(root->right);
}
}
void printBoundary(struct BSTNode* root)
{
if (root)
{
printf("%d ", root->data);
printBoundaryLeft(root->left);
printLeaves(root->left);
printLeaves(root->right);
printBoundaryRight(root->right);
}
}
void printBoundary(TreeNode* root){
if(root){
cout<<root->data<<" ";
//Print all left boundary in top down manner.
printBoundaryLeft(root->left);
//Print all leaf node
printLeaves(root->left);
printLeaves(root->right);
//Print all right boundary nodes in bottom up manner.
printBoundaryRight(root->right);
}
}
// Pretty formatting of a binary tree to the output stream
// @ param
// level Control how wide you want the tree to sparse (eg, level 1 has the minimum space between nodes, while level 2 has a larger space between nodes)
// indentSpace Change this to add some indent space to the left (eg, indentSpace of 0 means the lowest level of the left node will stick to the left margin)
void printPretty(BinaryTree *root, int level, int indentSpace, ostream& out) {
int h = maxHeight(root);
int nodesInThisLevel = 1;
int branchLen = 2 * ((int)pow(2.0, h) - 1) - (3 - level)*(int)pow(2.0, h - 1); // eq of the length of branch for each node of each level
int nodeSpaceLen = 2 + (level + 1)*(int)pow(2.0, h); // distance between left neighbor node's right arm and right neighbor node's left arm
int startLen = branchLen + (3 - level) + indentSpace; // starting space to the first node to print of each level (for the left most node of each level only)
deque<BinaryTree*> nodesQueue;
nodesQueue.push_back(root);
for (int r = 1; r < h; r++) {
printBranches(branchLen, nodeSpaceLen, startLen, nodesInThisLevel, nodesQueue, out);
branchLen = branchLen / 2 - 1;
nodeSpaceLen = nodeSpaceLen / 2 + 1;
startLen = branchLen + (3 - level) + indentSpace;
printNodes(branchLen, nodeSpaceLen, startLen, nodesInThisLevel, nodesQueue, out);
for (int i = 0; i < nodesInThisLevel; i++) {
BinaryTree *currNode = nodesQueue.front();
nodesQueue.pop_front();
if (currNode) {
nodesQueue.push_back(currNode->left);
nodesQueue.push_back(currNode->right);
}
else {
nodesQueue.push_back(NULL);
nodesQueue.push_back(NULL);
}
}
nodesInThisLevel *= 2;
}
printBranches(branchLen, nodeSpaceLen, startLen, nodesInThisLevel, nodesQueue, out);
printLeaves(indentSpace, level, nodesInThisLevel, nodesQueue, out);
}
/* Print data for leaves on single line,
* separated with spaces, ending with newline.*/
void printLeaves(struct TreeNode* root)
{
if(root == NULL)
{
printf("");
}
else if(root->left == NULL && root->right == NULL)
{
printf("%d ", root->data);
}
else
{
if(root->left != NULL)
{
printLeaves(root->left);
}
if(root->right != NULL)
{
printLeaves(root->right);
}
}
}
int main(int argc, char** argv)
{
int i, n;
struct TreeNode* bst = NULL;
struct TreeNode* tree = makeTestTree(5,1);
printf("test tree: ");
printTree(tree);
printf("tree leaves: ");
printLeaves(tree);
printf("tree depth = %d\n", maxDepth(tree));
printf("tree balanced = %d\n", isBalanced(tree));
printf("tree isBST = %d\n", isBST(tree));
freeTree(tree);
tree = NULL;
tree = makeTestTree(6,2);
printf("another test tree: ");
printTree(tree);
printf("tree leaves: ");
printLeaves(tree);
printf("tree depth = %d\n", maxDepth(tree));
printf("tree balanced = %d\n", isBalanced(tree));
printf("tree isBST = %d\n", isBST(tree));
freeTree(tree);
tree = NULL;
tree = makeNotBST();
printf("notBST: ");
printTree(tree);
printf("notBST leaves: ");
printLeaves(tree);
printf("notBST depth = %d\n", maxDepth(tree));
printf("notBST balanced = %d\n", isBalanced(tree));
printf("notBST isBST = %d\n", isBST(tree));
printf("empty tree: ");
printTree(bst);
for(i = 0; i < 23; ++i)
{
n = (i*17+11) % 23;
bst = insertBST(bst, n);
}
printf("filled BST: ");
printTree(bst);
printf("BST leaves: ");
printLeaves(bst);
printf("BST depth = %d\n", maxDepth(bst));
printf("BST minimum value = %d\n", minValueBST(bst));
printf("BST balanced = %d\n", isBalanced(bst));
printf("BST isBST = %d\n", isBST(bst));
for(i = -4; i < 25; i+=4)
{
n = removeBST(&bst, i);
if(!n) printf("remove did not find %d\n", i);
}
printf("BST after removes: ");
printTree(bst);
printf("BST leaves: ");
printLeaves(bst);
printf("BST depth = %d\n", maxDepth(bst));
printf("BST minimum value = %d\n", minValueBST(bst));
printf("BST balanced = %d\n", isBalanced(bst));
printf("BST isBST = %d\n", isBST(bst));
freeTree(bst);
bst = NULL;
freeTree(tree);
tree = NULL;
return 0;
}
