Question

In Java Language

Please use: (do not change this part)

public int kSmallest(Node root, int k){

Only need this method done worry about creating a main method assume it is already done.

(6) Given the root of a valid BST, return the kth smallest number without using more than 0(1) space. You can assume the Node class has a left child, a right child, and an int value. public int kSmallest(Node root, int k){

Answer 1

The function that returns the integer required will be as following:

The recursive and using stack method uses extra space. But with no extra space we can think of one thing storing the Inorder predecessor which will help us loop back incase of leaf nodes. This procedure is analogous to having two pointers in c or c++. This is a modification known as Morrison In Order Traversal where we store link to inorder successor of the current node.

Procedure following below are :

1) Start traversing tree in order till the count becomes k

2) return the node's key on which the count becomes k.

Key: In order traversal , Space Complexity O(1)

First Left , Then Root, Then Right.

/******************************************************************************

Online Java Compiler.
Code, Compile, Run and Debug java program online.
Write your code in this editor and press "Run" button to execute it.

*******************************************************************************/

public int kSmallest(Node root,int k){

int count = 0; // to count the minimum digits.

Node temp = root; // this will give us a temporary pointer to go through in order traversal of the tree

Node prev;

if (temp == null)

System.out.println("Root Empty!");

else{

while(temp! = null){

if (temp.left == null){// if the left node of temp is null that means it has 0 left child and next smallest is root turn so count will be

// incremented by 1 as we have reached the most minimum value from the BST

count++;

if ( count == k)
return temp.key ; // return the value of temp if the count equals k i.e. kth smallest node.

temp = temp.right; // we move to the right subtree after recording the root and incrementing count for it.
}
else {
// if the left child is present then we have to store the inorder successor which Means the inorder node which would occur after traversing more down
// the tree.
  
prev = temp.left ;
while (prev.right != null && prev.right != temp) // here we make links to inorder successor and use links to count our kth smallest.
prev = prev.right; // here prev will reach till the node where the backlink needs to be created.
  
if(prev.right == null){ // if we have no nodes to right.
prev.right = temp; // here see when we reach end of .right attribute a link is created backwards to the current node.
temp = temp.left; // and now temp is free to go and traverse the remaining left subtree of the BST.
}
else {
// now that we have taken the care of inorder successor backlinks we can now unlink them one by one
// and while we unlink we will keep our count to reach (k) as per requirement.
prev.right = null; // link broken
count++; // as we reached the next successor of inorder traversal. and count is incremented.
if (count == k) // return the value if count == k else continue breaking links.
return temp.key;
temp = temp.right; // update the current variable to the right subtree where it has to search next after root.
}
}

}