I did the same

I did this as well!

I used the same method like you, but I passed all solutons. However, I have no idea why my recusive method can't pass all.

no need for a traversal. Take the node->data of each node directly from the vector values given in private. Rest logic is spot on. Did the same :)

I did a similar thing (except that the list was in descending order). My recursive algorithm had a flaw that appeared to be too difficult to waste time fixing.

Note that I am more used to C so I didn't bother with the C++ libraries.

    struct List {
        int data;
        List *next;
    };

    List *makeDescendingList(Node *head, List *list) {
        List *newListNode;
        if (head == NULL) {
            return list;
        } else {
            list = makeDescendingList(head->left, list);
            newListNode = new(List);
            newListNode->data = head->data;
            newListNode->next = list;
            return makeDescendingList(head->right, newListNode);
        } 
    }

    bool isDescendingList (List *list) {
        while (list != NULL) {
            if (list->next != NULL && list->data <= list->next->data) {
                return false;
            }
            list = list->next;
        }
        return true;
    }
    
	bool checkBST(Node* root) {
		return isDescendingList(makeDescendingList(root, NULL));
	}

Inorder traversal of BST is always sorted. So you don't have to put elements into list. Store maximum element so far in a variable (say maxSoFar) and then just check if currentNode.data <= maxSoFar. It'll save you from iterating list.

i tried same thing but many test cases fails... help me to come out plz.

I also did the same but some test cases are not working .Here my code- bool func(vector v) { int count=0; for(int i=0;i v; if(root==NULL) return true; if(root!=NULL) { checkBST(root->left); v.push_back(root->data); checkBST(root->right); } return func(v);

}

did the same dude !!!!!! 2 cases failed in recursion,didn't know the reason and sample input was also confusing and accidentally i reached this solution while understanding the sample input ... ;)

You don't need to create list or array while doing inorder traversal. The whole point is to compare current and last element, if last elment is greater or equal to current return false. Just use one wrapper int, or Integer static variable to keep track of last visited.

I think you can improve your space complexity only using a variable and comparing current node with his prev node.

Was able to solve it because of your comment. thanks a lot. Here's my code.

static ArrayList<Integer> list = new ArrayList<Integer>();
    boolean checkBST(Node root) {
        
        inOrder(root);
        
        for(int i = 1; i< list.size(); i++){
            if(list.get(i)<=list.get(i-1))
                return false;
        }
        return true;
         
    }
    
    void inOrder(Node root){
        if(root == null)
            return;
        inOrder(root.left);
        list.add(root.data);
        inOrder(root.right);
    }

Did the same thing.

I did the same. But it's not working.

Here is my code. Can you review it please?

vector <int> inorder_nodes;

void Traverse_Inorder(Node *root)
{
    if(root->left != NULL)
        Traverse_Inorder(root->left);

    inorder_nodes.push_back(root->data);

    if(root->right != NULL)
        Traverse_Inorder(root->right);        
}

bool checkBST(Node* root) {

    bool result=true;

    Traverse_Inorder(root);

    for (int i = 0; i < inorder_nodes.size(); i++)
    {
        if(inorder_nodes[i] > inorder_nodes[i+1])
        {
            result = false;
            break;
        }            
    }

    return result;

}

Isn't necessary to store the values in a list, just keep track of the previous visited value (inorder sequence), and if your current visiting value is less than it means that isn't a BST

Thanks for your insight! My code worked!