a. Program plan: 1.The variables used are: An int type variable datato store the value in the tree. An object Tree_node of the structure that is used to create the tree. 2.The functions used are: CreateNode()that creates a node for the given “data” value and returns the created node. printTree_BinarySearchto print the nodes in a threaded binary tree rotated to left along with the successor node. Program description: To write the functions that print each binary tree rotated to the left. /&********************************************************* * Program to print each binary tree rotated to left * ***********************************************************/ // Include the header files #include**lt;iostream> using namespace std; //Define a structure “Tree_node” for node in binary tree that contain variable “data” and two pointers “left” and “right”. // Define a structure for binary tree node struct Tree_node { // Declare elements in binary tree node int data; struct Tree_node* left; struct Tree_node* right; }; //Function “CreateNode()” that creates a node for given “data” value and return the created node. // Function to create node for binary tree struct Tree_node* CreateNode(int data) { // Create new node for binary tree struct Tree_node* Tree_node = (struct Tree_node*) malloc(sizeof(struct Tree_node)); // Set data for node Tree_node->data = data; // Set left pointer of node of binary tree as NULL Tree_node-> left = NULL; // Set right pointer of node of binary tree as NULL Tree_node-> right = NULL; // Return created node return(Tree_node); } //Function “printTree_BinarySearch()” to print the nodes in a threaded binary tree rotated to left along with the successor node, if there, in the bracket. // Function to print nodes in binary search tree void printTree_BinarySearch(struct Tree_node* Tree_node, int depth) { //If the tree is not empty then print the nodes in the tree. // If tree is not empty if ( Tree_node!= 0) { //Call recursive function “printTree_BinarySearch()” with right sub tree as parameter. /* Call recursive function printTree_BinarySearch() with right subtree as parameter */ printTree_BinarySearch(Tree_node->right,depth+1); //Loop to provide spaces for correct indentation. // Loop untill depth of tree for (int i = 1; i<= depth; i++) { cout<< " "; } // Output the data in the node cout<<Tree_node->data <<endl; // Call recursive function printTee_BinarySearch() with left sub tree as parameter printTree_BinarySearch(Tree_node->left,depth+1); } } //Main function “main()” that create threaded binary search tree and print the nodes in threaded binary search tree along with successor. // Main Function int main() { // Create binary tree struct Tree_node *root = CreateNode(10); root-> left = CreateNode(5); root-> right = CreateNode(20); root-> left-> left = CreateNode(2); root-> left-> right = CreateNode(7); root-> left-> right->left = CreateNode(6); // Call the function printTree_BinarySearch printTree_BinarySearch(root,0); return 0; } Explanation: A structure is used to store the value of the node, left node and right node. After that, a method is used to create the tree. Another method printTree_BinarySearch() is used to perform left rotations. After that, all functions is called in main(). Output: b. Program plan: 1.The variables used are: An int type variable datato store the value in the tree. An object Tree_node of the structure that is used to create the tree. 2.The functions used are: CreateNode()that creates a node for the given “data” value and returns the created node. insert() to insert nodes into a threaded binary search tree. printTree_Threaded()to print the nodes in a threaded binary tree rotated to left along with the successor node. Program description: To write a program that prints a threaded tree. Program: /&********************************************************* * Program to print threaded binary search tree rotated to * * the left. * ***********************************************************/ // Include the header files #include**lt;iostream> using namespace std; //Define a structure “Tree_node” for node in the binary tree that contains variable “data” and two pointers “left” and “right”. // Define a structure for binary tree node struct Tree_node { // Declare elements in binary tree node int data; struct Tree_node* left; struct Tree_node* right; unsigned int successor : 1; }; //Function “CreateNode()” that creates a node for given “data” value and return the created node. // Function to create node for binary tree struct Tree_node* CreateNode(int data) { // Create new node for binary tree struct Tree_node* Tree_node = (struct Tree_node*) malloc(sizeof(struct Tree_node)); // Set data for node Tree_node->data = data; // Set left pointer of node of binary tree as NULL Tree_node-> left = NULL; // Set right pointer of node of binary tree as NULL Tree_node-> right = NULL; // set successor value as 0 Tree_node->successor=0; // Return created node return(Tree_node); } //Function “insert()” to insert nodes into threaded binary search tree. // Function to insert nodes into threaded binary search tree void insert(struct Tree_node* root, int id){ // Create new node with given data value struct Tree_node* Tree_node = CreateNode(id); // Create a new node and assign root to it struct Tree_node* current = root; // Create a new node and assign null to it struct Tree_node* parent = NULL; //Loop until getting correct position to insert the node and then based on the “data” value and set the “successor” value. // Loop until the new node is placed in the tree while(true) { // Assign to parent node the current node parent = current; //If the “data” value of new node is less than “current” node “data” value ,then insert the new node to the “parent” node left. /* If data value of new node is less than data value of current node */ if(id<data){ /* Assign current as left child of current node */ current = current->left; //If “current” node is null assign new node as left of parent and set the value of “successor” as “1”. // If current is null if(current==NULL){ // Assign the new node to parent left parent->left = Tree_node; /* Assign parent node to right of new node */ Tree_node->right = parent; /* Set the successor value of new node as 1 */ Tree_node->successor = 1; return; } } //If the “data” value of a new node is equal or greater than “current” node “data” value then insert the node to “parent” node right. /* If data value of a new node is equal or greater than data value of current node*/ else { //If the “successor” value of current node is “0”, then find the correct position to insert the node. /* If the successor value of current node is 0 */ if(current->successor==0){ /* Assign current as right child of current node */ current = current->right; //If “current” node is null assign new node as right of parent. // If current is null if(current==NULL) { // Assign the new node to parent node right parent->right = Tree_node; return; } } //If the “successor” value of the current node is “0”, then make the new node as “current” node right child and right child of the new node as “current” node right child, after that set the “successor” value of “current” node as “0” and new node as “1”. /* If the successor value of the current node is 1*/ else { /* Create a new node temp and assign right child of current to it */ struct Tree_node* temp = current->right; /* Assign the new node to current node right */ current->right = Tree_node; // Assign temp to new node right Tree_node->right = temp; /* Set the successor value of current node as 0 */ current->successor=0; /* Set the successor value of new node as 1 */ Tree_node->successor=1; return; } } } } //Function “printTree_Threaded()” to print the nodes in a threaded binary tree rotated to left along with the successor node. // Function to print the nodes in threaded binary tree void printTree_Threaded(struct Tree_node* Tree_node, int depth) { //If the tree is not empty then print the nodes in the tree. // If node is not null if (Tree_node != 0) { //If the “successor” value of the node is “0”, then call the recursive function “printTree_Threaded()” with right sub tree as parameter. // If the value of successor of node is 0 if (Tree_node->successor == 0) /* Call recursive function printTree_Threaded() with right subtree as parameter */ printTree_Threaded(Tree_node->right,depth+1); //Loop to provide spaces for correct indentation. // Loop untill depth of tree for (int i = 1; i<= depth; i++) // print spaces cout<< " "; //If the “successor” value of the node is “1”, then print the node value and successor node value. // If the value of successor of node is 1 if (Tree_node->successor == 1) // Display node with successor node cout<<Tree_node->data << "("<right->data <<")"<<endl; //Otherwise if the “successor” value of the node is “0”, then print the node value. // If the value of successor of node is "0" else // Display the node cout<<Tree_node->data <<endl; //Call the recursive function “printTree_Threaded()” with left sub tree as parameter. /* Call recursive function printTree_Threaded() with left subtree as parameter */ printTree_Threaded(Tree_node->left,depth+1); } } //Main function “main()” that creates threaded binary search tree and prints the nodes in threaded binary search tree along with successor. // Main Function int main() { // Create binary tree struct Tree_node *root = CreateNode(10); insert(root,5); insert(root,20); insert(root,2); insert(root,7); insert(root,6); // Call the function printTree_Threaded printTree_Threaded(root,0); return 0; } Explanation: First of all, define a structure “Tree_node” for node in the binary tree that contains variable “data” and two pointers “left” and “right”. Then a function “CreateNode()”creates a node for the given “data” value and returns the created node. Another function “insert()” to insert nodes into a threaded binary search tree. Now, loop until getting the correct position to insert the node and then based on the “data” value and set the “successor” value. If the “data” value of the new node is less than “current” node “data” value,then insert the new node to the “parent” node left. If “current” node is null assign new node as left of parent and set the value of “successor” as “1”. If the “data” value of new node is equal or greater than “current” node “data” value then insert the node to “parent” node right. If the “successor” value of current node is “0”, then find the correct position to insert the node. If the “successor” value of current node is “0”, then make the new node as “current” node right child and right child of the new node as “current” node right child, after that set the “successor” value of “current” node as “0” and new node as “1”. Function “printTree_Threaded()” to print the nodes in a threaded binary tree rotated to left along with the successor node.Main function “main()”createsa threaded binary search tree and prints the nodes in a threaded binary search tree along with a successor. Sample Output: 20 10 7(10) 6(7) 5 2(5)

EBK DATA STRUCTURES AND ALGORITHMS IN C

4th Edition

ISBN: 9781285415017

Author: DROZDEK

Publisher: YUZU

See similar textbooks

Expert Solution & Answer

Want to see the full answer?

Check out a sample textbook solution

See solution

Chapter 6, Problem 12E

Chapter 6, Problem 14E

Students have asked these similar questions

7. Draw an AVL tree of height 3 with the smallest possible number of nodes. Then draw an AVL tree of height 4 with the smallest possible number of nodes. In pseudocode, write a function that returns the number of nodes in the smallest possible AVL tree of height h. You may assume that only valid heights from -1 up to 25 will be supplied. Write your solution below. function minAvlSize (int height)

Create a binary linked tree, and traverse the tree by using the recursive function. The structure of the tree is as follow: //PICTURE// You should input the nodes in pre-order sequence. If a child of a node is NULL, input a space. Write the function of create binary tree, pre-order to print the nodes, in-order to print the nodes and post-order to print the nodes. Also Count the height of the tree. PLEASE USE C LANGUAGE

Knowledge Booster

Solution Summary: The author describes how to write the functions that print each binary tree rotated to the left along with the successor node.

Want to see the full answer?

Chapter 6 Solutions