# Delete leaf nodes with value k in C++?

C++Server Side ProgrammingProgramming

Let us first define the struct that would represent a tree node that contains the data and its left and right node child. If this is the first node to be created then it’s a root node otherwise a child node.

struct Node {
int data;
struct Node *leftChild, *rightChild;
};

Next we create our newNode(int data) function that takes an int value and assign it to the data member of the node. The function returns the pointer to the created struct Node. Also, the left and right child of the newly created node are set to null.

struct Node* newNode(int data) {
struct Node* newNode = new Node;
newNode->data = data;
newNode->leftChild = newNode->rightChild = NULL;
return (newNode);
}

Now we create our deleteNode(Node* root, int k) function which takes the root node and the data value of the node to be deleted. If the given node is a parent node then it also deletes its left and right child. The function returns the modified root node after deletion of the given node.

Node* deleteLeafNode(Node* root, int k) {
if (root == NULL)
return nullptr;
root->leftChild = deleteLeafNode(root->leftChild, k);
root->rightChild = deleteLeafNode(root->rightChild, k);
if (root->data == k && root->leftChild == NULL &&
root->rightChild == NULL)
return nullptr;
return root;
}

Finally for dispaying the tree after deletion we have a function inorder(Node* root) which traverses the tree in inorder function.

void inorder(Node* root){
if (root != NULL){
inorder(root->leftChild);
inorder(root->rightChild);
cout << root->data << " ";
}
}

## Example

Let us see the following implementation of deleting leaf nodes that have value k.

Live Demo

#include <iostream>
using namespace std;
struct Node {
int data;
struct Node *leftChild, *rightChild;
};
struct Node* newNode(int data){
struct Node* newNode = new Node;
newNode->data = data;
newNode->leftChild = newNode->rightChild = NULL;
return (newNode);
}
Node* deleteLeafNode(Node* root, int k){
if (root == NULL)
return nullptr;
root->leftChild = deleteLeafNode(root->leftChild, k);
root->rightChild = deleteLeafNode(root->rightChild, k);
if (root->data == k && root->leftChild == NULL &&
root->rightChild == NULL)
return nullptr;
return root;
}
void inorder(Node* root){
if (root != NULL){
inorder(root->leftChild);
inorder(root->rightChild);
cout << root->data << " ";
}
}
int main(void){
struct Node* root = newNode(6);
root->leftChild = newNode(7);
root->rightChild = newNode(7);
root->leftChild->leftChild = newNode(5);
root->leftChild->rightChild = newNode(3);
root->rightChild->rightChild = newNode(7);
deleteLeafNode(root, 7);
cout << "Inorder traversal after deleting given leaf node: ";
inorder(root);
return 0;
}

## Output

The above code will produce the following output −

Inorder traversal after deleting given leaf node: 5 3 7 6