# Check whether given binary is skewed binary tree

Here given code implementation process.

``````// C program for
// Check whether given binary is skewed binary tree
#include <stdio.h>

#include <stdlib.h>

// Tree Node
struct TreeNode
{
int data;
struct TreeNode *left;
struct TreeNode *right;
};
// Binary Tree
struct BinaryTree
{
struct TreeNode *root;
};
// Create new tree
struct BinaryTree *new_tree()
{
// Create dynamic node
struct BinaryTree *tree = (struct BinaryTree *) malloc(sizeof(struct BinaryTree));
if (tree != NULL)
{
tree->root = NULL;
}
else
{
printf("Memory Overflow to Create tree Tree\n");
}
//return new tree
return tree;
}
// This is creates and returns the new binary tree node
struct TreeNode *get_node(int data)
{
// Create dynamic node
struct TreeNode *node = (struct TreeNode *) malloc(sizeof(struct TreeNode));
if (node != NULL)
{
//Set data and pointer values
node->data = data;
node->left = NULL;
node->right = NULL;
}
else
{
//This is indicates, segmentation fault or memory overflow problem
printf("Memory Overflow\n");
}
//return new node
return node;
}
// Recursive inorder traversal of binary tree
void inorder(struct TreeNode *node)
{
if (node != NULL)
{
inorder(node->left);
printf("  %d", node->data);
inorder(node->right);
}
}
// Determine that tree is skewed tree or not
int skewedTree(struct TreeNode *node)
{
if (node == NULL)
{
return 1;
}
if (node->left != NULL && node->right != NULL)
{
// When node contains both child
return 0;
}
// Recursively check skewed tree
return skewedTree(node->left) && skewedTree(node->right);
}
void isSkewedBinaryTree(struct TreeNode *root)
{
if (root == NULL)
{
// When tree is empty
printf("\n Empty Tree");
}
else
{
// Display given tree node
printf("\n Inorder Traversal \n");
inorder(root);
if (skewedTree(root) == 1)
{
printf("\n Is Skewed Binary Tree \n");
}
else
{
printf("\n Is Not Skewed Binary Tree \n");
}
}
}
int main()
{
struct BinaryTree *tree1 = new_tree();
struct BinaryTree *tree2 = new_tree();
/*
Create First Binary Tree

4
/
8
\
6
/
9
\
7
\
1
*/
tree1->root = get_node(4);
tree1->root->left = get_node(8);
tree1->root->left->right = get_node(6);
tree1->root->left->right->left = get_node(9);
tree1->root->left->right->left->right = get_node(7);
tree1->root->left->right->left->right->right = get_node(1);
/*
Create Second Binary Tree

4
/
8
\
6
/ \
9   3
\
7
\
1
*/
tree2->root = get_node(4);
tree2->root->left = get_node(8);
tree2->root->left->right = get_node(6);
tree2->root->left->right->right = get_node(3);
tree2->root->left->right->left = get_node(9);
tree2->root->left->right->left->right = get_node(7);
tree2->root->left->right->left->right->right = get_node(1);
// Test
isSkewedBinaryTree(tree1->root);
isSkewedBinaryTree(tree2->root);
return 0;
}``````

#### input

`````` Inorder Traversal
8  9  7  1  6  4
Is Skewed Binary Tree

Inorder Traversal
8  9  7  1  6  3  4
Is Not Skewed Binary Tree``````
``````/*
Java Program
Check whether given binary is skewed binary tree
*/
//Binary Tree node
class TreeNode
{
public int data;
public TreeNode left;
public TreeNode right;
public TreeNode(int data)
{
// Set node value
this.data = data;
this.left = null;
this.right = null;
}
}
public class BinaryTree
{
public TreeNode root;
public BinaryTree()
{
// Set initial tree root to null
this.root = null;
}
// Recursive inorder traversal of binary tree
public void inorder(TreeNode node)
{
if (node != null)
{
inorder(node.left);
System.out.print("  " + node.data);
inorder(node.right);
}
}
// Determine that tree is skewed tree or not
public boolean skewedTree(TreeNode node)
{
if (node == null)
{
return true;
}
if (node.left != null && node.right != null)
{
// When node contains both child
return false;
}
// Recursively check skewed tree
return skewedTree(node.left) && skewedTree(node.right);
}
public void isSkewedBinaryTree()
{
if (this.root == null)
{
// When tree is empty
System.out.print("\n Empty Tree");
}
else
{
// Display given tree node
System.out.println("\n Inorder Traversal ");
inorder(this.root);
if (skewedTree(root) == true)
{
System.out.println("\n Is Skewed Binary Tree ");
}
else
{
System.out.println("\n Is Not Skewed Binary Tree ");
}
}
}
public static void main(String[] args)
{
// Create new binary trees
BinaryTree tree1 = new BinaryTree();
BinaryTree tree2 = new BinaryTree();
/*
Create First Binary Tree

4
/
8
\
6
/
9
\
7
\
1
*/
tree1.root = new TreeNode(4);
tree1.root.left = new TreeNode(8);
tree1.root.left.right = new TreeNode(6);
tree1.root.left.right.left = new TreeNode(9);
tree1.root.left.right.left.right = new TreeNode(7);
tree1.root.left.right.left.right.right = new TreeNode(1);
/*
Create Second Binary Tree

4
/
8
\
6
/ \
9   3
\
7
\
1
*/
tree2.root = new TreeNode(4);
tree2.root.left = new TreeNode(8);
tree2.root.left.right = new TreeNode(6);
tree2.root.left.right.right = new TreeNode(3);
tree2.root.left.right.left = new TreeNode(9);
tree2.root.left.right.left.right = new TreeNode(7);
tree2.root.left.right.left.right.right = new TreeNode(1);
// Test
tree1.isSkewedBinaryTree();
tree2.isSkewedBinaryTree();
}
}``````

#### input

`````` Inorder Traversal
8  9  7  1  6  4
Is Skewed Binary Tree

Inorder Traversal
8  9  7  1  6  3  4
Is Not Skewed Binary Tree``````
``````// Include header file
#include <iostream>
using namespace std;

/*
C++ Program
Check whether given binary is skewed binary tree
*/

//Binary Tree node
class TreeNode
{
public: int data;
TreeNode *left;
TreeNode *right;
TreeNode(int data)
{
// Set node value
this->data = data;
this->left = NULL;
this->right = NULL;
}
};
class BinaryTree
{
public: TreeNode *root;
BinaryTree()
{
this->root = NULL;
}
// Recursive inorder traversal of binary tree
void inorder(TreeNode *node)
{
if (node != NULL)
{
this->inorder(node->left);
cout << "  " << node->data;
this->inorder(node->right);
}
}
// Determine that tree is skewed tree or not
bool skewedTree(TreeNode *node)
{
if (node == NULL)
{
return true;
}
if (node->left != NULL && node->right != NULL)
{
// When node contains both child
return false;
}
// Recursively check skewed tree
return this->skewedTree(node->left) && this->skewedTree(node->right);
}
void isSkewedBinaryTree()
{
if (this->root == NULL)
{
// When tree is empty
cout << "\n Empty Tree";
}
else
{
// Display given tree node
cout << "\n Inorder Traversal " << endl;
this->inorder(this->root);
if (this->skewedTree(this->root) == true)
{
cout << "\n Is Skewed Binary Tree " << endl;
}
else
{
cout << "\n Is Not Skewed Binary Tree " << endl;
}
}
}
};
int main()
{
// Create new binary trees
BinaryTree *tree1 = new BinaryTree();
BinaryTree *tree2 = new BinaryTree();
/*
Create First Binary Tree
4
/
8
\
6
/
9
\
7
\
1
*/
tree1->root = new TreeNode(4);
tree1->root->left = new TreeNode(8);
tree1->root->left->right = new TreeNode(6);
tree1->root->left->right->left = new TreeNode(9);
tree1->root->left->right->left->right = new TreeNode(7);
tree1->root->left->right->left->right->right = new TreeNode(1);
/*
Create Second Binary Tree
4
/
8
\
6
/ \
9   3
\
7
\
1
*/
tree2->root = new TreeNode(4);
tree2->root->left = new TreeNode(8);
tree2->root->left->right = new TreeNode(6);
tree2->root->left->right->right = new TreeNode(3);
tree2->root->left->right->left = new TreeNode(9);
tree2->root->left->right->left->right = new TreeNode(7);
tree2->root->left->right->left->right->right = new TreeNode(1);
// Test
tree1->isSkewedBinaryTree();
tree2->isSkewedBinaryTree();
return 0;
}``````

#### input

`````` Inorder Traversal
8  9  7  1  6  4
Is Skewed Binary Tree

Inorder Traversal
8  9  7  1  6  3  4
Is Not Skewed Binary Tree``````
``````// Include namespace system
using System;
/*
Csharp Program
Check whether given binary is skewed binary tree
*/

//Binary Tree node
public class TreeNode
{
public int data;
public TreeNode left;
public TreeNode right;
public TreeNode(int data)
{
// Set node value
this.data = data;
this.left = null;
this.right = null;
}
}
public class BinaryTree
{
public TreeNode root;
public BinaryTree()
{
// Set initial tree root to null
this.root = null;
}
// Recursive inorder traversal of binary tree
public void inorder(TreeNode node)
{
if (node != null)
{
this.inorder(node.left);
Console.Write("  " + node.data);
this.inorder(node.right);
}
}
// Determine that tree is skewed tree or not
public Boolean skewedTree(TreeNode node)
{
if (node == null)
{
return true;
}
if (node.left != null && node.right != null)
{
// When node contains both child
return false;
}
// Recursively check skewed tree
return this.skewedTree(node.left) && this.skewedTree(node.right);
}
public void isSkewedBinaryTree()
{
if (this.root == null)
{
// When tree is empty
Console.Write("\n Empty Tree");
}
else
{
// Display given tree node
Console.WriteLine("\n Inorder Traversal ");
this.inorder(this.root);
if (this.skewedTree(this.root) == true)
{
Console.WriteLine("\n Is Skewed Binary Tree ");
}
else
{
Console.WriteLine("\n Is Not Skewed Binary Tree ");
}
}
}
public static void Main(String[] args)
{
// Create new binary trees
BinaryTree tree1 = new BinaryTree();
BinaryTree tree2 = new BinaryTree();
/*
Create First Binary Tree
4
/
8
\
6
/
9
\
7
\
1
*/
tree1.root = new TreeNode(4);
tree1.root.left = new TreeNode(8);
tree1.root.left.right = new TreeNode(6);
tree1.root.left.right.left = new TreeNode(9);
tree1.root.left.right.left.right = new TreeNode(7);
tree1.root.left.right.left.right.right = new TreeNode(1);
/*
Create Second Binary Tree
4
/
8
\
6
/ \
9   3
\
7
\
1
*/
tree2.root = new TreeNode(4);
tree2.root.left = new TreeNode(8);
tree2.root.left.right = new TreeNode(6);
tree2.root.left.right.right = new TreeNode(3);
tree2.root.left.right.left = new TreeNode(9);
tree2.root.left.right.left.right = new TreeNode(7);
tree2.root.left.right.left.right.right = new TreeNode(1);
// Test
tree1.isSkewedBinaryTree();
tree2.isSkewedBinaryTree();
}
}``````

#### input

`````` Inorder Traversal
8  9  7  1  6  4
Is Skewed Binary Tree

Inorder Traversal
8  9  7  1  6  3  4
Is Not Skewed Binary Tree``````
``````<?php
/*
Php Program
Check whether given binary is skewed binary tree
*/

//Binary Tree node
class TreeNode
{
public \$data;
public \$left;
public \$right;
public	function __construct(\$data)
{
// Set node value
\$this->data = \$data;
\$this->left = NULL;
\$this->right = NULL;
}
}
class BinaryTree
{
public \$root;
public	function __construct()
{
\$this->root = NULL;
}
// Recursive inorder traversal of binary tree
public	function inorder(\$node)
{
if (\$node != NULL)
{
\$this->inorder(\$node->left);
echo("  ".\$node->data);
\$this->inorder(\$node->right);
}
}
// Determine that tree is skewed tree or not
public	function skewedTree(\$node)
{
if (\$node == NULL)
{
return true;
}
if (\$node->left != NULL && \$node->right != NULL)
{
// When node contains both child
return false;
}
// Recursively check skewed tree
return \$this->skewedTree(\$node->left) &&
\$this->skewedTree(\$node->right);
}
public	function isSkewedBinaryTree()
{
if (\$this->root == NULL)
{
// When tree is empty
echo("\n Empty Tree");
}
else
{
// Display given tree node
echo("\n Inorder Traversal ".
"\n");
\$this->inorder(\$this->root);
if (\$this->skewedTree(\$this->root) == true)
{
echo("\n Is Skewed Binary Tree ".
"\n");
}
else
{
echo("\n Is Not Skewed Binary Tree ".
"\n");
}
}
}
}

function main()
{
// Create new binary trees
\$tree1 = new BinaryTree();
\$tree2 = new BinaryTree();
/*
Create First Binary Tree
4
/
8
\
6
/
9
\
7
\
1
*/
\$tree1->root = new TreeNode(4);
\$tree1->root->left = new TreeNode(8);
\$tree1->root->left->right = new TreeNode(6);
\$tree1->root->left->right->left = new TreeNode(9);
\$tree1->root->left->right->left->right = new TreeNode(7);
\$tree1->root->left->right->left->right->right = new TreeNode(1);
/*
Create Second Binary Tree
4
/
8
\
6
/ \
9   3
\
7
\
1
*/
\$tree2->root = new TreeNode(4);
\$tree2->root->left = new TreeNode(8);
\$tree2->root->left->right = new TreeNode(6);
\$tree2->root->left->right->right = new TreeNode(3);
\$tree2->root->left->right->left = new TreeNode(9);
\$tree2->root->left->right->left->right = new TreeNode(7);
\$tree2->root->left->right->left->right->right = new TreeNode(1);
// Test
\$tree1->isSkewedBinaryTree();
\$tree2->isSkewedBinaryTree();
}
main();``````

#### input

`````` Inorder Traversal
8  9  7  1  6  4
Is Skewed Binary Tree

Inorder Traversal
8  9  7  1  6  3  4
Is Not Skewed Binary Tree``````
``````/*
Node JS Program
Check whether given binary is skewed binary tree
*/
// Binary Tree node
class TreeNode
{
constructor(data)
{
// Set node value
this.data = data;
this.left = null;
this.right = null;
}
}
class BinaryTree
{
constructor()
{
this.root = null;
}
// Recursive inorder traversal of binary tree
inorder(node)
{
if (node != null)
{
this.inorder(node.left);
process.stdout.write("  " + node.data);
this.inorder(node.right);
}
}
// Determine that tree is skewed tree or not
skewedTree(node)
{
if (node == null)
{
return true;
}
if (node.left != null && node.right != null)
{
// When node contains both child
return false;
}
// Recursively check skewed tree
return this.skewedTree(node.left) &&
this.skewedTree(node.right);
}
isSkewedBinaryTree()
{
if (this.root == null)
{
// When tree is empty
process.stdout.write("\n Empty Tree");
}
else
{
// Display given tree node
console.log("\n Inorder Traversal ");
this.inorder(this.root);
if (this.skewedTree(this.root) == true)
{
console.log("\n Is Skewed Binary Tree ");
}
else
{
console.log("\n Is Not Skewed Binary Tree ");
}
}
}
}

function main()
{
// Create new binary trees
var tree1 = new BinaryTree();
var tree2 = new BinaryTree();
/*
Create First Binary Tree
4
/
8
\
6
/
9
\
7
\
1
*/
tree1.root = new TreeNode(4);
tree1.root.left = new TreeNode(8);
tree1.root.left.right = new TreeNode(6);
tree1.root.left.right.left = new TreeNode(9);
tree1.root.left.right.left.right = new TreeNode(7);
tree1.root.left.right.left.right.right = new TreeNode(1);
/*
Create Second Binary Tree
4
/
8
\
6
/ \
9   3
\
7
\
1
*/
tree2.root = new TreeNode(4);
tree2.root.left = new TreeNode(8);
tree2.root.left.right = new TreeNode(6);
tree2.root.left.right.right = new TreeNode(3);
tree2.root.left.right.left = new TreeNode(9);
tree2.root.left.right.left.right = new TreeNode(7);
tree2.root.left.right.left.right.right = new TreeNode(1);
// Test
tree1.isSkewedBinaryTree();
tree2.isSkewedBinaryTree();
}
main();``````

#### input

`````` Inorder Traversal
8  9  7  1  6  4
Is Skewed Binary Tree

Inorder Traversal
8  9  7  1  6  3  4
Is Not Skewed Binary Tree``````
``````#    Python 3 Program
#    Check whether given binary is skewed binary tree

# Binary Tree node
class TreeNode :
def __init__(self, data) :
#  Set node value
self.data = data
self.left = None
self.right = None

class BinaryTree :
def __init__(self) :
self.root = None

#  Recursive inorder traversal of binary tree
def inorder(self, node) :
if (node != None) :
self.inorder(node.left)
print("  ", node.data, end = "")
self.inorder(node.right)

#  Determine that tree is skewed tree or not
def skewedTree(self, node) :
if (node == None) :
return True

if (node.left != None and node.right != None) :
#  When node contains both child
return False

#  Recursively check skewed tree
return self.skewedTree(node.left) and self.skewedTree(node.right)

def isSkewedBinaryTree(self) :
if (self.root == None) :
#  When tree is empty
print("\n Empty Tree", end = "")
else :
#  Display given tree node
print("\n Inorder Traversal ")
self.inorder(self.root)
if (self.skewedTree(self.root) == True) :
print("\n Is Skewed Binary Tree ")
else :
print("\n Is Not Skewed Binary Tree ")

def main() :
tree1 = BinaryTree()
tree2 = BinaryTree()
#    Create First Binary Tree
#    4
#   /
#  8
#   \
#    6
#   /
#  9
#   \
#    7
#     \
#      1
tree1.root = TreeNode(4)
tree1.root.left = TreeNode(8)
tree1.root.left.right = TreeNode(6)
tree1.root.left.right.left = TreeNode(9)
tree1.root.left.right.left.right = TreeNode(7)
tree1.root.left.right.left.right.right = TreeNode(1)
#    Create Second Binary Tree
#    4
#   /
#  8
#   \
#    6
#   / \
#  9   3
#   \
#    7
#     \
#      1
tree2.root = TreeNode(4)
tree2.root.left = TreeNode(8)
tree2.root.left.right = TreeNode(6)
tree2.root.left.right.right = TreeNode(3)
tree2.root.left.right.left = TreeNode(9)
tree2.root.left.right.left.right = TreeNode(7)
tree2.root.left.right.left.right.right = TreeNode(1)
#  Test
tree1.isSkewedBinaryTree()
tree2.isSkewedBinaryTree()

if __name__ == "__main__": main()``````

#### input

`````` Inorder Traversal
8   9   7   1   6   4
Is Skewed Binary Tree

Inorder Traversal
8   9   7   1   6   3   4
Is Not Skewed Binary Tree``````
``````#    Ruby Program
#    Check whether given binary is skewed binary tree

# Binary Tree node
class TreeNode
# Define the accessor and reader of class TreeNode
attr_accessor :data, :left, :right
def initialize(data)
#  Set node value
self.data = data
self.left = nil
self.right = nil
end

end

class BinaryTree
# Define the accessor and reader of class BinaryTree
attr_accessor :root
def initialize()
self.root = nil
end

#  Recursive inorder traversal of binary tree
def inorder(node)
if (node != nil)
self.inorder(node.left)
print("  ", node.data)
self.inorder(node.right)
end

end

#  Determine that tree is skewed tree or not
def skewedTree(node)
if (node == nil)
return true
end

if (node.left != nil && node.right != nil)
#  When node contains both child
return false
end

#  Recursively check skewed tree
return self.skewedTree(node.left) && self.skewedTree(node.right)
end

def isSkewedBinaryTree()
if (self.root == nil)
#  When tree is empty
print("\n Empty Tree")
else
#  Display given tree node
print("\n Inorder Traversal ", "\n")
self.inorder(self.root)
if (self.skewedTree(self.root) == true)
print("\n Is Skewed Binary Tree ", "\n")
else
print("\n Is Not Skewed Binary Tree ", "\n")
end

end

end

end

def main()
#  Create new binary trees
tree1 = BinaryTree.new()
tree2 = BinaryTree.new()
#    Create First Binary Tree
#    4
#   /
#  8
#   \
#    6
#   /
#  9
#   \
#    7
#     \
#      1
tree1.root = TreeNode.new(4)
tree1.root.left = TreeNode.new(8)
tree1.root.left.right = TreeNode.new(6)
tree1.root.left.right.left = TreeNode.new(9)
tree1.root.left.right.left.right = TreeNode.new(7)
tree1.root.left.right.left.right.right = TreeNode.new(1)
#    Create Second Binary Tree
#    4
#   /
#  8
#   \
#    6
#   / \
#  9   3
#   \
#    7
#     \
#      1
tree2.root = TreeNode.new(4)
tree2.root.left = TreeNode.new(8)
tree2.root.left.right = TreeNode.new(6)
tree2.root.left.right.right = TreeNode.new(3)
tree2.root.left.right.left = TreeNode.new(9)
tree2.root.left.right.left.right = TreeNode.new(7)
tree2.root.left.right.left.right.right = TreeNode.new(1)
#  Test
tree1.isSkewedBinaryTree()
tree2.isSkewedBinaryTree()
end

main()``````

#### input

`````` Inorder Traversal
8  9  7  1  6  4
Is Skewed Binary Tree

Inorder Traversal
8  9  7  1  6  3  4
Is Not Skewed Binary Tree
``````
``````/*
Scala Program
Check whether given binary is skewed binary tree
*/

// Binary Tree node
class TreeNode(var data: Int , var left: TreeNode , var right: TreeNode)
{
def this(data: Int)
{
// Set node value
this(data,null,null);
}
}
class BinaryTree(var root: TreeNode)
{
def this()
{
this(null);
}
// Recursive inorder traversal of binary tree
def inorder(node: TreeNode): Unit = {
if (node != null)
{
inorder(node.left);
print("  " + node.data);
inorder(node.right);
}
}
// Determine that tree is skewed tree or not
def skewedTree(node: TreeNode): Boolean = {
if (node == null)
{
return true;
}
if (node.left != null && node.right != null)
{
// When node contains both child
return false;
}
// Recursively check skewed tree
return skewedTree(node.left) && skewedTree(node.right);
}
def isSkewedBinaryTree(): Unit = {
if (this.root == null)
{
// When tree is empty
print("\n Empty Tree");
}
else
{
// Display given tree node
println("\n Inorder Traversal ");
inorder(this.root);
if (skewedTree(root) == true)
{
println("\n Is Skewed Binary Tree ");
}
else
{
println("\n Is Not Skewed Binary Tree ");
}
}
}
}
object Main
{
def main(args: Array[String]): Unit = {
// Create new binary trees
var tree1: BinaryTree = new BinaryTree();
var tree2: BinaryTree = new BinaryTree();
/*
Create First Binary Tree
4
/
8
\
6
/
9
\
7
\
1
*/
tree1.root = new TreeNode(4);
tree1.root.left = new TreeNode(8);
tree1.root.left.right = new TreeNode(6);
tree1.root.left.right.left = new TreeNode(9);
tree1.root.left.right.left.right = new TreeNode(7);
tree1.root.left.right.left.right.right = new TreeNode(1);
/*
Create Second Binary Tree
4
/
8
\
6
/ \
9   3
\
7
\
1
*/
tree2.root = new TreeNode(4);
tree2.root.left = new TreeNode(8);
tree2.root.left.right = new TreeNode(6);
tree2.root.left.right.right = new TreeNode(3);
tree2.root.left.right.left = new TreeNode(9);
tree2.root.left.right.left.right = new TreeNode(7);
tree2.root.left.right.left.right.right = new TreeNode(1);
// Test
tree1.isSkewedBinaryTree();
tree2.isSkewedBinaryTree();
}
}``````

#### input

`````` Inorder Traversal
8  9  7  1  6  4
Is Skewed Binary Tree

Inorder Traversal
8  9  7  1  6  3  4
Is Not Skewed Binary Tree``````
``````/*
Swift 4 Program
Check whether given binary is skewed binary tree
*/
//Binary Tree node
class TreeNode
{
var data: Int;
var left: TreeNode? ;
var right: TreeNode? ;
init(_ data: Int)
{
// Set node value
self.data = data;
self.left = nil;
self.right = nil;
}
}
class BinaryTree
{
var root: TreeNode? ;
init()
{
self.root = nil;
}
// Recursive inorder traversal of binary tree
func inorder(_ node: TreeNode? )
{
if (node  != nil)
{
self.inorder(node!.left);
print("  ", node!.data, terminator: "");
self.inorder(node!.right);
}
}
// Determine that tree is skewed tree or not
func skewedTree(_ node: TreeNode? )->Bool
{
if (node == nil)
{
return true;
}
if (node!.left  != nil && node!.right  != nil)
{
// When node contains both child
return false;
}
// Recursively check skewed tree
return self.skewedTree(node!.left) && self.skewedTree(node!.right);
}
func isSkewedBinaryTree()
{
if (self.root == nil)
{
// When tree is empty
print("\n Empty Tree", terminator: "");
}
else
{
// Display given tree node
print("\n Inorder Traversal ");
self.inorder(self.root);
if (self.skewedTree(self.root) == true)
{
print("\n Is Skewed Binary Tree ");
}
else
{
print("\n Is Not Skewed Binary Tree ");
}
}
}
}
func main()
{
// Create new binary trees
let tree1: BinaryTree = BinaryTree();
let tree2: BinaryTree = BinaryTree();
/*
Create First Binary Tree
4
/
8
\
6
/
9
\
7
\
1
*/
tree1.root = TreeNode(4);
tree1.root!.left = TreeNode(8);
tree1.root!.left!.right = TreeNode(6);
tree1.root!.left!.right!.left = TreeNode(9);
tree1.root!.left!.right!.left!.right = TreeNode(7);
tree1.root!.left!.right!.left!.right!.right = TreeNode(1);
/*
Create Second Binary Tree
4
/
8
\
6
/ \
9   3
\
7
\
1
*/
tree2.root = TreeNode(4);
tree2.root!.left = TreeNode(8);
tree2.root!.left!.right = TreeNode(6);
tree2.root!.left!.right!.right = TreeNode(3);
tree2.root!.left!.right!.left = TreeNode(9);
tree2.root!.left!.right!.left!.right = TreeNode(7);
tree2.root!.left!.right!.left!.right!.right = TreeNode(1);
// Test
tree1.isSkewedBinaryTree();
tree2.isSkewedBinaryTree();
}
main();``````

#### input

`````` Inorder Traversal
8   9   7   1   6   4
Is Skewed Binary Tree

Inorder Traversal
8   9   7   1   6   3   4
Is Not Skewed Binary Tree``````
``````/*
Kotlin Program
Check whether given binary is skewed binary tree
*/

//Binary Tree node
class TreeNode
{
var data: Int;
var left: TreeNode ? ;
var right: TreeNode ? ;
constructor(data: Int)
{
// Set node value
this.data = data;
this.left = null;
this.right = null;
}
}
class BinaryTree
{
var root: TreeNode ? ;
constructor()
{
this.root = null;
}
// Recursive inorder traversal of binary tree
fun inorder(node: TreeNode ? ): Unit
{
if (node != null)
{
this.inorder(node.left);
print("  " + node.data);
this.inorder(node.right);
}
}
// Determine that tree is skewed tree or not
fun skewedTree(node: TreeNode ? ): Boolean
{
if (node == null)
{
return true;
}
if (node.left != null && node.right != null)
{
// When node contains both child
return false;
}
// Recursively check skewed tree
return this.skewedTree(node.left) && this.skewedTree(node.right);
}
fun isSkewedBinaryTree(): Unit
{
if (this.root == null)
{
// When tree is empty
print("\n Empty Tree");
}
else
{
// Display given tree node
println("\n Inorder Traversal ");
this.inorder(this.root);
if (this.skewedTree(this.root) == true)
{
println("\n Is Skewed Binary Tree ");
}
else
{
println("\n Is Not Skewed Binary Tree ");
}
}
}
}
fun main(args: Array < String > ): Unit
{
// Create new binary trees
val tree1: BinaryTree = BinaryTree();
val tree2: BinaryTree = BinaryTree();
/*
Create First Binary Tree
4
/
8
\
6
/
9
\
7
\
1
*/
tree1.root = TreeNode(4);
tree1.root?.left = TreeNode(8);
tree1.root?.left?.right = TreeNode(6);
tree1.root?.left?.right?.left = TreeNode(9);
tree1.root?.left?.right?.left?.right = TreeNode(7);
tree1.root?.left?.right?.left?.right?.right = TreeNode(1);
/*
Create Second Binary Tree
4
/
8
\
6
/ \
9   3
\
7
\
1
*/
tree2.root = TreeNode(4);
tree2.root?.left = TreeNode(8);
tree2.root?.left?.right = TreeNode(6);
tree2.root?.left?.right?.right = TreeNode(3);
tree2.root?.left?.right?.left = TreeNode(9);
tree2.root?.left?.right?.left?.right = TreeNode(7);
tree2.root?.left?.right?.left?.right?.right = TreeNode(1);
// Test
tree1.isSkewedBinaryTree();
tree2.isSkewedBinaryTree();
}``````

#### input

`````` Inorder Traversal
8  9  7  1  6  4
Is Skewed Binary Tree

Inorder Traversal
8  9  7  1  6  3  4
Is Not Skewed Binary Tree``````

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

### New Comment 