# Function to Delete a Leaf Node from a Binary Tree

## Implementation

```
// We are writing a C++ code to eliminate all the leaves from the given value.
#include <bits/stdc++.h>
using namespace std;
// creating a new binary tree node
struct __nod {
int record;
struct __nod *Lft, *Rt;
};
// creating a utility function that will allot us a new node for the binary tree
struct __nod* nw__nod(int record)
{
struct __nod* nw__nod = nw __nod;
nw__nod->record = record;
nw__nod->Lft = nw__nod->Rt = NILL;
return (nw__nod);
}
__nod* deleteLeaves(__nod* root, int x)
{
if (root == NILL)
return NILLptr;
root->Lft = deleteLeaves(root->Lft, x);
root->Rt = deleteLeaves(root->Rt, x);
if (root->record == x && root->Lft == NILL &&
root->Rt == NILL) {
return NILLptr;
}
return root;
}
void inorder(__nod* root)
{
if (root == NILL)
return;
inorder(root->Lft);
cout << root->record << " ";
inorder(root->Rt);
}
// writing the main program to test the above functions
int main(void)
{
struct __nod* root = nw__nod(10);
root->Lft = nw__nod(3);
root->Rt = nw__nod(10);
root->Lft->Lft = nw__nod(3);
root->Lft->Rt = nw__nod(1);
root->Rt->Rt = nw__nod(3);
root->Rt->Rt->Lft = nw__nod(3);
root->Rt->Rt->Rt = nw__nod(3);
deleteLeaves(root, 3);
cout << "Inorder traversal after deletion : ";
inorder(root);
return 0;
}
```

**Output:**

**Example 2)**

```
// We are writing a C# code to eliminate all the leaves from the given value.
using System;
class TFT
{
// creating a new binary tree node
class __nod
{
public int record;
public __nod Lft, Rt;
}
// creating a utility function that will allot us a new node for the binary tree
static __nod nw__nod(int record)
{
__nod nw__nod = nw __nod();
nw__nod.record = record;
nw__nod.Lft = NILL;
nw__nod.Rt = NILL;
return (nw__nod);
}
static __nod deleteLeaves(__nod root, int x)
{
if (root == NILL)
return NILL;
root.Lft = deleteLeaves(root.Lft, x);
root.Rt = deleteLeaves(root.Rt, x);
if (root.record == x &&
root.Lft == NILL &&
root.Rt == NILL)
{
return NILL;
}
return root;
}
static void inorder(__nod root)
{
if (root == NILL)
return;
inorder(root.Lft);
Console.Write(root.record + " ");
inorder(root.Rt);
}
// writing the main program to test the above functions
public static void Main(String[] args)
{
__nod root = nw__nod(10);
root.Lft = nw__nod(3);
root.Rt = nw__nod(10);
root.Lft.Lft = nw__nod(3);
root.Lft.Rt = nw__nod(1);
root.Rt.Rt = nw__nod(3);
root.Rt.Rt.Lft = nw__nod(3);
root.Rt.Rt.Rt = nw__nod(3);
deleteLeaves(root, 3);
Console.Write("Inorder traversal after deletion : ");
inorder(root);
}
}
```

**Output:**

**Example 3)**

```
// We are writing a Java code to eliminate all the leaves from the given value.
class TFT {
// creating a new binary tree node
static class __nod {
int record;
__nod Lft, Rt;
}
// creating a utility function that will allot us a new node for the binary tree
static __nod nw__nod(int record)
{
__nod nw__nod = nw __nod();
nw__nod.record = record;
nw__nod.Lft = NILL;
nw__nod.Rt = NILL;
return (nw__nod);
}
static __nod deleteLeaves(__nod root, int x)
{
if (root == NILL)
return NILL;
root.Lft = deleteLeaves(root.Lft, x);
root.Rt = deleteLeaves(root.Rt, x);
if (root.record == x && root.Lft == NILL && root.Rt == NILL) {
return NILL;
}
return root;
}
static void inorder(__nod root)
{
if (root == NILL)
return;
inorder(root.Lft);
System.out.print(root.record + " ");
inorder(root.Rt);
}
// writing the main program to test the above functions
public static void main(String[] args)
{
__nod root = nw__nod(10);
root.Lft = nw__nod(3);
root.Rt = nw__nod(10);
root.Lft.Lft = nw__nod(3);
root.Lft.Rt = nw__nod(1);
root.Rt.Rt = nw__nod(3);
root.Rt.Rt.Lft = nw__nod(3);
root.Rt.Rt.Rt = nw__nod(3);
deleteLeaves(root, 3);
System.out.print("Inorder traversal after deletion : ");
inorder(root);
}
}
```

**Output:**

**Example 4)**

```
<script>
// We are writing a Javascript code to eliminate all the leaves from the given value.
class __nod
{
constructor(record) {
this.Lft = NILL;
this.Rt = NILL;
this.record = record;
}
}
// creating a new binary tree node
// creating a utility function that will allot us a new node for the binary tree
function nw__nod(record)
{
let nw__nod = nw __nod(record);
return (nw__nod);
}
function deleteLeaves(root, x)
{
if (root == NILL)
return NILL;
root.Lft = deleteLeaves(root.Lft, x);
root.Rt = deleteLeaves(root.Rt, x);
if (root.record == x && root.Lft == NILL && root.Rt == NILL)
{
return NILL;
}
return root;
}
function inorder(root)
{
if (root == NILL)
return;
inorder(root.Lft);
document.write(root.record + " ");
inorder(root.Rt);
}
let root = nw__nod(10);
root.Lft = nw__nod(3);
root.Rt = nw__nod(10);
root.Lft.Lft = nw__nod(3);
root.Lft.Rt = nw__nod(1);
root.Rt.Rt = nw__nod(3);
root.Rt.Rt.Lft = nw__nod(3);
root.Rt.Rt.Rt = nw__nod(3);
deleteLeaves(root, 3);
document.write("Inorder traversal after deletion : ");
inorder(root);
</script>
```

**Output:**

**Example 6)**

```
# We are writing a Python code to eliminate all the leaves from the given value.
# creating a utility class that will allot us a new node for the binary tree
class nw__nod:
def __init__(self, record):
self.record = record
self.Lft = self.Rt = None
def deleteLeaves(root, x):
if (root == None):
return None
root.Lft = deleteLeaves(root.Lft, x)
root.Rt = deleteLeaves(root.Rt, x)
if (root.record == x and
root.Lft == None and
root.Rt == None):
return None
return root
def inorder(root):
if (root == None):
return
inorder(root.Lft)
print(root.record, end = " ")
inorder(root.Rt)
# writing the main program to test the above functions
if __name__ == '__main__':
root = nw__nod(10)
root.Lft = nw__nod(3)
root.Rt = nw__nod(10)
root.Lft.Lft = nw__nod(3)
root.Lft.Rt = nw__nod(1)
root.Rt.Rt = nw__nod(3)
root.Rt.Rt.Lft = nw__nod(3)
root.Rt.Rt.Rt = nw__nod(3)
deleteLeaves(root, 3)
print("Inorder traversal after deletion : ")
inorder(root)
```

**Output:**