# Convert a Binary Search Tree into a Skewed tree in increasing or decreasing order

• Difficulty Level : Expert
• Last Updated : 16 Jun, 2021

Given a Binary Search Tree and a binary integer K, the task is to convert Binary search tree into a Skewed Tree in increasing order if K = 0 or in decreasing order if K = 1. Examples:

```Input: K = 0,
5
/ \
3   6
Output:
3
\
5
\
6

Input: K = 1,
2
/ \
1   3
Output:
3
\
2
\
1```

Approach:

• The key observation in the problem is that the first node of the skewed tree will be the extreme left or extreme right node of the BST for increasing order and decreasing order respectively.
• For Increasing Order we need to do the Inorder Traversal, as the inorder traversal of a BST provides us the increasing sequence of the node values. Hence, the order of traversal at every node will be:
1. Left node: Recurse to its left node if it exists, to get smaller value.
2. Root node: After the complete traversal of its left node/subtree, connect the previous node of the skewed tree to the root node.
3. Right node: Recurse to the right node if it exists, for larger values.
• For Decreasing Order, the order of traversal at every node will be:
1. Right node: Recurse to its right node if it exists, to get larger values.
2. Root node: After the complete traversal of its right node/subtree, connect the previous node of the skewed tree to the root node.
3. Left node: Recurse to the left node/subtree for smaller values.
• Similarly, by keeping track of the previous node we can traverse the Binary search tree according to the order needed and form the skewed tree.

Below is the implementation of the above approach:

## C++14

 `// C++ implementation to flatten the``// binary search tree into a skewed``// tree in increasing / decreasing order``#include``using` `namespace` `std;` `// Class of the node``struct` `Node``{``    ``int` `val;``    ``Node *left, *right;` `    ``Node(``int` `x)``    ``{``        ``val = x;``        ``left = right = NULL;``    ``}``};` `Node *prevNode = NULL;``Node *headNode = NULL;` `// Function to to flatten the binary``// search tree into a skewed tree in``// increasing / decreasing order``void` `flattenBTToSkewed(Node *root, ``int` `order)``{``    ` `    ``// Base Case``    ``if` `(!root)``        ``return``;` `    ``// Condition to check the order``    ``// in which the skewed tree to``    ``// maintained``    ``if` `(order)``        ``flattenBTToSkewed(root->right, order);``    ``else``        ``flattenBTToSkewed(root->left, order);` `    ``Node *rightNode = root->right;``    ``Node *leftNode = root->left;` `    ``// Condition to check if the root Node``    ``// of the skewed tree is not defined``    ``if` `(!headNode)``    ``{``        ``headNode = root;``        ``root->left = NULL;``        ``prevNode = root;``    ``}``    ``else``    ``{``        ``prevNode->right = root;``        ``root->left = NULL;``        ``prevNode = root;``    ``}` `    ``// Similarly recurse for the left / right``    ``// subtree on the basis of the order required``    ``if` `(order)``        ``flattenBTToSkewed(leftNode, order);``    ``else``        ``flattenBTToSkewed(rightNode, order);``}` `// Function to traverse the right``// skewed tree using recursion``void` `traverseRightSkewed(Node *root)``{``    ``if` `(!root)``        ``return``;``        ` `    ``cout << root->val << ``" "``;``    ``traverseRightSkewed(root->right);``}` `// Driver Code``int` `main()``{``    ` `    ``//    5``    ``//     / \``    ``//  3   6``    ``Node *root =``new` `Node(5);``    ``root->left = ``new` `Node(3);``    ``root->right = ``new` `Node(6);` `    ``// Order of the Skewed tree can``    ``// be defined as follows -``    ``// For Increasing order - 0``    ``// For Decreasing order - 1``    ``int` `order = 0;` `    ``flattenBTToSkewed(root, order);` `    ``traverseRightSkewed(headNode);``}` `// This code is contributed by mohit kumar 29`

## Java

 `// Java implementation to flatten the``// binary search tree into a skewed``// tree in increasing / decreasing order``import` `java.io.*;` `// Class of the node``class` `Node``{``    ``int` `val;``    ``Node left, right;``   ` `    ``// Helper function that allocates a new node``    ``// with the given data and NULL left and right``    ``// pointers.``    ``Node(``int` `item)``    ``{``        ``val = item;``        ``left = right = ``null``;``    ``}``}``class` `GFG``{``    ``public` `static` `Node node;``    ``static` `Node prevNode = ``null``;``    ``static` `Node headNode = ``null``;``  ` `    ``// Function to to flatten the binary``    ``// search tree into a skewed tree in``    ``// increasing / decreasing order``    ``static` `void` `flattenBTToSkewed(Node root,``                                  ``int` `order)``    ``{``      ` `        ``// Base Case``        ``if``(root == ``null``)``        ``{``            ``return``;``        ``}``      ` `        ``// Condition to check the order``        ``// in which the skewed tree to``        ``// maintained``        ``if``(order > ``0``)``        ``{``            ``flattenBTToSkewed(root.right, order);``        ``}``        ``else``        ``{``            ``flattenBTToSkewed(root.left, order);``        ``}``        ``Node rightNode = root.right;``        ``Node leftNode = root.left;``      ` `        ``// Condition to check if the root Node``        ``// of the skewed tree is not defined``        ``if``(headNode == ``null``)``        ``{``            ``headNode = root;``            ``root.left = ``null``;``            ``prevNode = root;``        ``}``        ``else``        ``{``            ``prevNode.right = root;``            ``root.left = ``null``;``            ``prevNode = root;``        ``}``      ` `        ``// Similarly recurse for the left / right``        ``// subtree on the basis of the order required``        ``if` `(order > ``0``)``        ``{``            ``flattenBTToSkewed(leftNode, order);``        ``}``        ``else``        ``{``            ``flattenBTToSkewed(rightNode, order);``        ``}``    ``}``  ` `    ``// Function to traverse the right``    ``// skewed tree using recursion``    ``static` `void` `traverseRightSkewed(Node root)``    ``{``        ``if``(root == ``null``)``        ``{``            ``return``;``        ``}``        ``System.out.print(root.val + ``" "``);``        ``traverseRightSkewed(root.right);       ``    ``}``  ` `    ``// Driver Code``    ``public` `static` `void` `main (String[] args)``    ``{``       ``//    5``       ``//     / \``       ``//  3   6``        ``GFG tree = ``new` `GFG();``        ``tree.node = ``new` `Node(``5``);``        ``tree.node.left = ``new` `Node(``3``);``        ``tree.node.right = ``new` `Node(``6``);``      ` `        ``// Order of the Skewed tree can``        ``// be defined as follows -``        ``// For Increasing order - 0``        ``// For Decreasing order - 1``        ``int` `order = ``0``;``        ``flattenBTToSkewed(node, order);``        ``traverseRightSkewed(headNode);``    ``}``}` `// This code is contributed by avanitrachhadiya2155`

## Python3

 `# Python3 implementation to flatten``# the binary search tree into a skewed``# tree in increasing / decreasing order` `# Class of the node``class` `Node:``    ` `    ``# Constructor of node``    ``def` `__init__(``self``, val):``        ``self``.val ``=` `val``        ``self``.left ``=` `None``        ``self``.right ``=` `None``        ` `prevNode ``=` `None``headNode ``=` `None` `# Function to to flatten``# the binary search tree into a skewed``# tree in increasing / decreasing order``def` `flattenBTToSkewed(root, order):``    ` `    ``# Base Case``    ``if` `not` `root:``        ``return``    ` `    ``# Condition to check the order``    ``# in which the skewed tree to maintained``    ``if` `order:``        ``flattenBTToSkewed(root.right, order)``    ``else``:``        ``flattenBTToSkewed(root.left, order)``        ` `    ``global` `headNode; ``global` `prevNode``    ``rightNode ``=` `root.right``    ``leftNode ``=` `root.left``    ` `    ``# Condition to check if the root Node``    ``# of the skewed tree is not defined``    ``if` `not` `headNode:``        ``headNode ``=` `root``        ``root.left ``=` `None``        ``prevNode ``=` `root``    ``else``:``        ``prevNode.right ``=` `root``        ``root.left ``=` `None``        ``prevNode ``=` `root``    ` `    ``# Similarly recurse for the left / right``    ``# subtree on the basis of the order required``    ``if` `order:``        ``flattenBTToSkewed(leftNode, order)``    ``else``:``        ``flattenBTToSkewed(rightNode, order)` `# Function to traverse the right``# skewed tree using recursion``def` `traverseRightSkewed(root):``    ``if` `not` `root:``        ``return``    ``print``(root.val, end ``=` `" "``)``    ``traverseRightSkewed(root.right)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ``# 5``    ``#      / \``    ``# 3   6``    ``root ``=` `Node(``5``)``    ``root.left ``=` `Node(``3``)``    ``root.right ``=` `Node(``6``)``    ` `    ``prevNode ``=` `None``    ``headNode ``=` `None``    ` `    ``# Order of the Skewed tree can``    ``# be defined as follows -``    ``# For Increasing order - 0``    ``# For Decreasing order - 1``    ``order ``=` `0``    ` `    ``flattenBTToSkewed(root, order)``    ` `    ``traverseRightSkewed(headNode)`

## C#

 `// C# implementation to flatten the``// binary search tree into a skewed``// tree in increasing / decreasing order``using` `System;` `// Class of the node``class` `Node``{``    ``public` `int` `val;``    ``public` `Node left, right;``    ` `    ``// Helper function that allocates a new``    ``// node with the given data and NULL``    ``// left and right pointers.``    ``public` `Node(``int` `item)``    ``{``        ``val = item;``        ``left = right = ``null``;``    ``}``}` `class` `GFG{``    ` `public` `static` `Node node;``static` `Node prevNode = ``null``;``static` `Node headNode = ``null``;` `// Function to to flatten the binary``// search tree into a skewed tree in``// increasing / decreasing order``static` `void` `flattenBTToSkewed(Node root, ``int` `order)``{``    ` `    ``// Base Case``    ``if` `(root == ``null``)``    ``{``        ``return``;``    ``}``    ` `    ``// Condition to check the order``    ``// in which the skewed tree to``    ``// maintained``    ``if` `(order > 0)``    ``{``        ``flattenBTToSkewed(root.right, order);``    ``}``    ``else``    ``{``        ``flattenBTToSkewed(root.left, order);``    ``}``    ``Node rightNode = root.right;``    ``Node leftNode = root.left;``   ` `    ``// Condition to check if the root Node``    ``// of the skewed tree is not defined``    ``if` `(headNode == ``null``)``    ``{``        ``headNode = root;``        ``root.left = ``null``;``        ``prevNode = root;``    ``}``    ``else``    ``{``        ``prevNode.right = root;``        ``root.left = ``null``;``        ``prevNode = root;``    ``}``   ` `    ``// Similarly recurse for the left / right``    ``// subtree on the basis of the order required``    ``if` `(order > 0)``    ``{``        ``flattenBTToSkewed(leftNode, order);``    ``}``    ``else``    ``{``        ``flattenBTToSkewed(rightNode, order);``    ``}``}` `// Function to traverse the right``// skewed tree using recursion``static` `void` `traverseRightSkewed(Node root)``{``    ``if` `(root == ``null``)``    ``{``        ``return``;``    ``}``    ``Console.Write(root.val + ``" "``);``    ``traverseRightSkewed(root.right);``}` `// Driver Code``static` `public` `void` `Main()``{``    ` `    ``//      5``    ``//     / \``    ``//    3   6``    ``GFG.node = ``new` `Node(5);``    ``GFG.node.left = ``new` `Node(3);``    ``GFG.node.right = ``new` `Node(6);``    ` `    ``// Order of the Skewed tree can``    ``// be defined as follows -``    ``// For Increasing order - 0``    ``// For Decreasing order - 1``    ``int` `order = 0;``    ` `    ``flattenBTToSkewed(node, order);``    ``traverseRightSkewed(headNode);``}``}` `// This code is contributed by rag2127`

## Javascript

 ``

Output:

`3 5 6`

My Personal Notes arrow_drop_up