why can't equate pointer to nullptr - while-loop

Question

In the follwing program I was searching of lowest comman ancesstor in a BST.
The main problem here is that !root doesn't works like root!=nullptr.
Here line 1 works perfect. But line 2 gives wrong answer.
Please tell why line 2 desn't works but line 1 does.
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
int small=min(p->val, q->val);
int big=max(p->val, q->val);
while(root!=nullptr){ // line 1
// while(!root){ // line 2
int x=(root->val);
if(x>big){
root=root->left;
}
else if(x<small){
root=root->right;
}
else{
return root;
}
}
return nullptr;
}
};

Answer 1

Short of defining nullptr to be something weird (like 7), there should be no difference between x != nullptr and ! x, for any given pointer x.
It may be worthwhile printing out nullptr and root just inside the loop as well as the comparison results (and pointers, just in case your tree is corrupt), to see if something weird is happening, something like:
while (!root) {
std::cout
<< static_cast<void*>(root) << ' '
<< static_cast<void*>(root->left) << ' '
<< static_cast<void*>(root->right) << ' '
<< static_cast<void*>(nullptr) << ' '
<< (! root) << ' '
<< (root != nullptr) << std::endl;
int x=(root->val);
// ... and so on
The output of that may go a great deal toward showing what's wrong with your situation(a).
(a) One of my favourite mantras is "when in doubt, print it out", right up there with:
Get it working first, then get it working fast.
You can't get any less optimised than "wrong".
:-)