#include <stdio.h>
#include <stdlib.h>
#define ARRAY_SIZE(arr) sizeof(arr)/sizeof(arr[0])
/* just add elements to test */
/* NOTE: A sorted array results in skewed tree */
int ele[] = { 20, 8, 22, 4, 12, 10, 14 };
/* same alias */
typedef struct node_t node_t;
/* Binary tree node */
struct node_t
{
int data;
node_t* left;
node_t* right;
};
/* simple stack that stores node addresses */
typedef struct stack_t stack_t;
/* initial element always NULL, uses as sentinal */
struct stack_t
{
node_t* base[ARRAY_SIZE(ele) + 1];
int stackIndex;
};
/* pop operation of stack */
node_t *pop(stack_t *st)
{
node_t *ret = NULL;
if( st && st->stackIndex > 0 )
{
ret = st->base[st->stackIndex];
st->stackIndex--;
}
return ret;
}
/* push operation of stack */
void push(stack_t *st, node_t *node)
{
if( st )
{
st->stackIndex++;
st->base[st->stackIndex] = node;
}
}
/* Iterative insertion
Recursion is least preferred unless we gain something
*/
node_t *insert_node(node_t *root, node_t* node)
{
/* A crawling pointer */
node_t *pTraverse = root;
node_t *currentParent = root;
// Traverse till appropriate node
while(pTraverse)
{
currentParent = pTraverse;
if( node->data < pTraverse->data )
{
/* left subtree */
pTraverse = pTraverse->left;
}
else
{
/* right subtree */
pTraverse = pTraverse->right;
}
}
/* If the tree is empty, make it as root node */
if( !root )
{
root = node;
}
else if( node->data < currentParent->data )
{
/* Insert on left side */
currentParent->left = node;
}
else
{
/* Insert on right side */
currentParent->right = node;
}
return root;
}
/* Elements are in an array. The function builds binary tree */
node_t* binary_search_tree(node_t *root, int keys[], int const size)
{
int iterator;
node_t *new_node = NULL;
for(iterator = 0; iterator < size; iterator++)
{
new_node = (node_t *)malloc( sizeof(node_t) );
/* initialize */
new_node->data = keys[iterator];
new_node->left = NULL;
new_node->right = NULL;
/* insert into BST */
root = insert_node(root, new_node);
}
return root;
}
void *k_smallest( node_t *root, int k,int& p)
{
if(!root)
return ;
k_smallest(root->left,k,p);
if(p==k-1)
{
cout<<p<<endl;
p++;
return;
}
p++;
k_smallest(root->right,k,p);
}
/* Driver program to test above functions */
int main(void)
{
node_t* root = NULL;
stack_t stack = { {0}, 0 };
node_t *kNode = NULL;
int k = 5;
/* Creating the tree given in the above diagram */
root = binary_search_tree(root, ele, ARRAY_SIZE(ele));
int pre=0;
k_smallest(root, k,pre);
getchar();
return 0;
}