# Remove all leaf nodes from the binary search tree

We have given a binary search tree and we want to delete the leaf nodes from the binary search tree.

Examples:

```Input : 20 10 5 15 30 25 35
Output : Inorder before Deleting the leaf node
5 10 15 20 25 30 35
Inorder after Deleting the leaf node
10 20 30

This is the binary search tree where we
want to delete the leaf node.
20
/     \
10      30
/  \    /  \
5     15 25   35

After deleting the leaf node the binary
search tree looks like
20
/     \
10      30

```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

We traverse given Binary Search Tree in preorder way. During traversal we check if current node is leaf, if yes, we delete it. Else we recur for left and right children. An important thing to remember is, we must assign new left and right children if there is any modification in roots of subtrees.

```// C++ program to delete leaf Node from
// binary search tree.
#include <bits/stdc++.h>
using namespace std;

struct Node {
int data;
struct Node* left,
struct Node* right;
};

// Create a newNode in binary search tree.
struct Node* newNode(int data)
{
struct Node* temp = new Node;
temp->data = data;
temp->left = temp->right = NULL;
return temp;
}

// Insert a Node in binary search tree.
struct Node* insert(struct Node* root, int data)
{
if (root == NULL)
return newNode(data);
if (data < root->data)
root->left = insert(root->left, data);
else if (data > root->data)
root->right = insert(root->right, data);
return root;
}

// Function for inorder traversal in a BST.
void inorder(struct Node* root)
{
if (root != NULL) {
inorder(root->left);
cout << root->data << " ";
inorder(root->right);
}
}

// Delete leaf nodes from binary search tree.
struct Node* leafDelete(struct Node* root)
{
if (root->left == NULL && root->right == NULL) {
free(root);
return NULL;
}

// Else recursively delete in left and right
// subtrees.
root->left = leafDelete(root->left);
root->right = leafDelete(root->right);

return root;
}

// Driver code
int main()
{
struct Node* root = NULL;
root = insert(root, 20);
insert(root, 10);
insert(root, 5);
insert(root, 15);
insert(root, 30);
insert(root, 25);
insert(root, 35);
cout << "Inorder before Deleting the leaf Node." << endl;
inorder(root);
cout << endl;
leafDelete(root);
cout << "INorder after Deleting the leaf Node." << endl;
inorder(root);
return 0;
}
```

Output:

```Inorder before Deleting the leaf node.
5 10 15 20 25 30 35
INorder after Deleting the leaf node.
10 20 30
```

This article is contributed by Dharmendra kumar. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
2 Average Difficulty : 2/5.0
Based on 3 vote(s)