Elfsong/Venus_CCG · Datasets at Hugging Face

id int64 1 3.58k	problem_description stringlengths 516 21.8k	instruction int64 0 3	solution_c dict
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n string original (ListNode head){\n string str1=\"\";\n while(head!=nullptr){\n str1+=head->val;\n head=head->next;\n }\n return str1;\n }\n string reversed (ListNodeprev){\n string str2=\"\";\n while(prev!=nullptr){\n str2+=prev->val;\n prev=prev->next;\n }\n return str2;\n\n \n }\n ListNode reversedlinked(ListNode head){\n ListNode prev=nullptr,next;\n ListNodecurr=head;\n\n while(curr!=nullptr){\n next=curr->next;\n curr->next=prev;\n prev=curr;\n curr=next;\n }\n return prev; \n }\n\n bool isPalindrome(ListNode* head) {\n string str1= original (head);\n ListNode*prev = reversedlinked(head);\n string str2= reversed (prev);\n if (str1==str2) return true;\n else return false;\n\n }\n};", "memory": "74085" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\n\nclass Solution {\npublic:\n ListNode reverseList(ListNode* &head) {\n if(head == NULL \|\| head->next == NULL)\n return head;\n ListNode* newhead = reverseList(head->next);\n head->next->next = head;\n head->next = NULL;\n return newhead;\n }\n bool isPalindrome(ListNode* head) {\n ListNode* slow=head;\n ListNode* fast=head;\n\n while(fast && fast->next)\n {\n fast=fast->next->next;\n slow=slow->next;\n }\n\n \n ListNode* tmp1=reverseList(slow);\n ListNode* tmp2=head;\n\n while(tmp2!=slow)\n {\n if(tmp2->val!=tmp1->val)\n return 0;\n tmp2=tmp2->next;\n tmp1=tmp1->next;\n }\n return 1;\n\n\n }\n};", "memory": "75675" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n ListNode reverse(ListNode* &head){\n if(head==NULL\|\|head->next==NULL) return head;\n ListNode* newHead=reverse(head->next);\n ListNode* front=head->next;\n front->next=head;\n head->next=NULL;\n return newHead;\n\n }\n ListNode* mid(ListNode* &head){\n ListNode* slow=head;\n ListNode* fast=head;\n while(fast!=NULL&&fast->next!=NULL){\n slow=slow->next;\n fast=fast->next->next;\n }\n return slow;\n }\n bool isPalindrome(ListNode* head) {\n ListNode* start=head;\n if(head==NULL) return 0;\n ListNode* mid1=mid(head);\n \n ListNode* p=reverse(mid1);\n \n while(p!=NULL){\n cout<<p->val<<\" \"<<start->val;\n if(p->val!=start->val) {\n return 0;\n break;\n }\n start=start->next;\n p=p->next;\n }\n return 1;\n \n }\n};", "memory": "77265" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n ListNode reverseL(ListNode* temp)\n {\n if(!temp \|\| !temp->next)\n return temp;\n \n ListNode* newH=reverseL(temp->next);\n ListNode* ttp=temp->next;\n ttp->next=temp;\n temp->next=nullptr;\n return newH;\n }\n bool isPalindrome(ListNode* head) {\n ListNode* slow=head,fast=head,tp=head;\n while(fast->next && fast->next->next)\n {\n fast=fast->next->next;\n slow=slow->next;\n }\n ListNode* tps=reverseL(slow->next);\n while(tps)\n {\n if(tps->val != tp->val)\n return false;\n tps=tps->next;\n tp=tp->next;\n }\n return true;\n }\n};", "memory": "78855" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "class Solution {\npublic:\nListNode* middle(ListNode* head){\nif(head->next!=nullptr){\n ListNode* slow=head->next;\n ListNode* fast=slow->next; \n while(fast!=nullptr && fast->next != nullptr){\n slow=slow->next;\n fast=fast->next;\n if(fast!=nullptr) fast=fast->next;\n }\n return slow;\n }\n else return head;\n}\nListNode* reverseList(ListNode* head){\nif(head==nullptr\|\|head->next == nullptr)\nreturn head;\nListNode* n=reverseList(head->next);\nhead->next->next=head;\nhead->next=nullptr;\nreturn n;\n}\nbool isPalindrome(ListNode* head){\n ListNode* m=middle(head);\n ListNode* temp=reverseList(m);\n while(head!=m){\n if(head->val!=temp->val)\n return false;\n else{\n head=head->next; \n temp=temp->next;\n }\n }\n return true;\n }\n};", "memory": "80445" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "class Solution {\npublic:\n ListNode* reverselist(ListNode* head){\n if(head == NULL \|\| head->next == NULL) return head;\n ListNode* newHead = reverselist(head->next);\n head->next->next = head;\n head->next = NULL;\n return newHead;\n }\n bool isPalindrome(ListNode* head) {\n ListNode* slow = head;\n ListNode* fast = head;\n while(fast->next != NULL && fast->next->next != NULL){\n slow = slow->next;\n fast = fast->next->next;\n }\n ListNode* NewHead = reverselist(slow->next);\n ListNode* A = head;\n ListNode* B = NewHead;\n while(B){\n if(A->val != B->val) return false;\n A = A->next;\n B = B->next;\n }\n return true;\n }\n};", "memory": "82035" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\nListNode reverse(ListNodehead){\n if(head==NULL \|\| head->next==NULL){\n return head;\n }\n ListNode newHead=reverse(head->next);\n head->next->next=head;\n head->next=NULL;\n return newHead;\n}\n bool isPalindrome(ListNode* head) {\n if (head == NULL \|\| head->next == NULL) {\n \n // It's a palindrome by definition\n return true; \n }\n //find the middle of the ll\n ListNode* slow = head;\n ListNode* fast = head;\n while (fast != nullptr && fast->next != nullptr) {\n slow = slow->next;\n fast = fast->next->next;\n }\n ListNode* rev = reverse(slow);\n while (rev != nullptr) {\n if (head->val != rev->val) {\n return false;\n }\n head = head->next;\n rev = rev->next;\n }\n return true;\n }\n};", "memory": "82035" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n ListNode rec(ListNode* head){\n if(head==nullptr \|\| head->next==nullptr) return head;\n \n ListNode* newhead=rec(head->next);\n head->next->next=head;\n head->next=nullptr;\n return newhead;\n }\n bool isPalindrome(ListNode* head) {\n if(head->next==nullptr) return true;\n ListNode* slow=head;\n ListNode* fast=head;\n while(fast != nullptr && fast->next != nullptr){\n fast=fast->next->next;\n slow=slow->next;\n }\n \n ListNode* newhead=rec(slow);\n ListNode* curr=head;\n while(newhead!=nullptr){\n if(curr->val!=newhead->val) return false;\n newhead=newhead->next;\n curr=curr->next;\n }\n return true;\n }\n};", "memory": "83625" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\nListNode reverse(ListNode* head) {\n if(head== NULL or head->next==NULL ) return head;\n ListNode* shead = reverse(head->next);\n\n head->next->next = head;\n\n head->next = NULL;\n\n return shead;\n\n\n\n }\n bool isPalindrome(ListNode* head) {\n if(head==NULL or head->next == NULL) return true;\n ListNode* slow = head;\n ListNode* fast = head;\n\n while(fast->next and fast->next->next ){\n fast = fast->next->next;\n slow = slow->next;\n }\n\n ListNode* newHead = reverse(slow->next);\n ListNode* t1 = head;\n ListNode* t2 = newHead;\n\n while(t2){\n if(t1->val != t2->val) {\n reverse(slow->next);\n return false;\n }\n t1 = t1->next;\n t2 = t2->next;\n\n\n }\n reverse(slow->next);\n return true;\n }\n};", "memory": "83625" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n ListNode reverse(ListNode head){\n if(head == NULL \|\| head->next == NULL){\n return head;\n }\n ListNode newHead = reverse(head->next);\n ListNode front = head->next;\n front->next = head;\n head->next = NULL;\n return newHead;\n }\n bool isPalindrome(ListNode head) {\n if(head == NULL \|\| head->next == NULL){\n return true;\n }\n ListNode slow = head;\n ListNode fast = head;\n while(fast != NULL && fast->next!= NULL){\n slow = slow->next;\n fast = fast->next->next;\n }\n ListNode newHead = reverse(slow);\n ListNode first = head;\n ListNode *second = newHead;\n while(second != NULL){\n if(first->val != second->val){\n // reverse(newHead);\n return false;\n }\n first = first->next;\n second = second->next;\n }\n // reverse(newHead);\n return true;\n }\n};", "memory": "85215" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\nListNode reverse(ListNode* head) {\n if(head== NULL or head->next==NULL) return head;\n ListNode* shead = reverse(head->next);\n\n head->next->next = head;\n\n head->next = NULL;\n\n return shead;\n\n\n\n }\n bool isPalindrome(ListNode* head) {\n ListNode* slow = head;\n ListNode* fast = head;\n\n while(fast and fast->next){\n fast = fast->next->next;\n slow = slow->next;\n }\n\n ListNode* newHead = reverse(slow);\n ListNode* t1 = head;\n ListNode* t2 = newHead;\n\n while(t1 and t2){\n if(t1->val != t2->val) return false;\n\n t1 = t1->next;\n t2 = t2->next;\n\n\n }\n return true;\n }\n};", "memory": "85215" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n\n ListNode revers(ListNode* head)\n {\n if(head == NULL \|\| head->next == NULL)\n return head;\n\n ListNode* temp = revers(head->next);\n ListNode* front = head->next;\n front->next = head;\n head->next = NULL;\n\n return temp;\n\n }\n\n bool isPalindrome(ListNode* head) {\n ListNode* slow = head,fast = head;\n while(fast!=NULL && fast->next != NULL)\n {\n fast = fast->next->next;\n slow = slow->next;\n }\n\n ListNode head2 = revers(slow);\n ListNode* head1 = head;\n\n while(head2 != NULL)\n {\n if(head1->val != head2->val)\n {\n return false;\n }\n head1=head1->next;\n head2=head2->next;\n }\n return true;\n }\n};", "memory": "86805" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n ListNode reverseLL(ListNode* head){\n if(!head \|\| !head->next) return head;\n ListNode* newHead = reverseLL(head->next);\n ListNode* front = head->next;\n front->next = head;\n head->next = nullptr;\n return newHead;\n }\n bool isPalindrome(ListNode* head) {\n if(!head \|\| !head->next) return true;\n ListNode* slow = head;\n ListNode* fast = head->next;\n while(fast && fast->next){\n slow = slow->next;\n fast = fast->next->next;\n }\n ListNode* reversedHead = reverseLL(slow);\n ListNode* temp = head;\n\n while(temp){\n if(temp->val != reversedHead->val) return false;\n temp = temp->next;\n reversedHead = reversedHead->next;\n }\n return true;\n }\n};", "memory": "86805" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "#pragma GCC optimize(\"Ofast\")\n#pragma GCC target(\"avx2,bmi,bmi2,popcnt,lzcnt\")\n\nstatic const int FAST__ = [](){\n std::ios_base::sync_with_stdio(false);\n std::cin.tie(nullptr);\n std::cout.tie(nullptr);\n return 0;\n}();\n\n/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\n ListNode reverseLinkedList(ListNode* head) {\n if (head == NULL \|\| head->next == NULL) {\n return head; \n }\n\n ListNode* newHead = reverseLinkedList(head->next);\n ListNode* front = head->next;\n\n front->next = head;\n head->next = NULL;\n return newHead;\n }\n\npublic:\n bool isPalindrome(ListNode* head) {\n if (head == NULL \|\| head->next == NULL) {\n return true; \n }\n\n ListNode* slow = head;\n ListNode* fast = head;\n while(fast->next != NULL && fast->next->next != NULL) {\n slow = slow->next;\n fast = fast->next->next;\n }\n\n ListNode* newHead = reverseLinkedList(slow->next);\n ListNode* first = head; \n ListNode* second = newHead;\n\n while (second != NULL) {\n if (first->val != second->val) {\n return false;\n }\n first = first->next; \n second = second->next; \n }\n\n return true;\n }\n};", "memory": "88395" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n ListNode reverseList(ListNode* head) {\n ListNode* temp=head;\n ListNode* prev=NULL;\n while(head!=NULL && head->next!=NULL){\n temp=head->next;\n head->next=prev;\n prev=head;\n head=temp;\n\n }\n if(head!=NULL && head->next==NULL && prev!=NULL){\n head->next=prev;\n }\n\n return head;\n }\n bool isPalindrome(ListNode* head) {\n \n\n //optimal approach\n if (head == NULL \|\| head->next == NULL) {\n return true;\n }\n\n ListNode* slow = head;\n ListNode* fast = head;\n stack<int> firstHalf;\n\n // Move fast pointer twice as fast as slow pointer\n // and push the first half values onto the stack\n while (fast != NULL && fast->next != NULL) {\n firstHalf.push(slow->val);\n slow = slow->next;\n fast = fast->next->next;\n }\n\n // If the list has an odd number of elements, skip the middle element\n if (fast != NULL) {\n slow = slow->next;\n }\n\n ListNode* head2=reverseList(slow);\n \n while(head && head2){\n if(head->val!=head2->val){\n return false;\n }\n head=head->next;\n head2=head2->next;\n }\n\n return true;\n\n }\n};", "memory": "89985" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n ListNode findMiddle(ListNode* head) {\n if(!head \|\| !head->next) return head;\n \n ListNode slow = head, fast = head;\n \n stack<int> firstHalf;\n \n while(fast && fast->next) {\n firstHalf.push(slow->val);\n \n slow = slow->next;\n fast = fast->next->next;\n }\n \n return slow;\n }\n \n ListNode* reverseList(ListNode* head) {\n if(!head \|\| !head->next) return head;\n \n ListNode* newHead = nullptr;\n \n while(head) {\n ListNode* next = head->next;\n head->next = newHead;\n newHead = head;\n head = next;\n }\n \n return newHead;\n }\n \n bool isPalindrome(ListNode* head) {\n if(!head \|\| !head->next) return true;\n \n ListNode middle = findMiddle(head);\n ListNode secondHalf = reverseList(middle);\n \n ListNode *firstHalf = head;\n \n while(secondHalf) {\n if(secondHalf->val != firstHalf->val) {\n return false;\n }\n \n secondHalf = secondHalf->next;\n firstHalf = firstHalf->next;\n }\n \n return true;\n }\n};", "memory": "91575" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n ListNode reverse(ListNode* head) {\n ListNode* prev = NULL;\n ListNode* temp = head;\n \n while(temp){\n ListNode* front = temp->next;\n temp->next = prev;\n prev = temp;\n temp = front;\n\n }\n return prev;\n }\n bool isPalindrome(ListNode* head) {\n ListNode slow = head, fast = head, first = head;\n while (fast->next && fast->next->next) {\n slow = slow->next;\n fast = fast->next->next;\n }\n ListNode newHead = reverse(slow->next);\n ListNode* second = newHead;\n while(second){\n if(first->val != second->val){\n reverse(newHead);\n return false;\n }\n first = first->next;\n second = second->next;\n }\n return true;\n }\n};", "memory": "93165" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\nprivate:\n ListNode findMid(ListNode* head){\n if(!head){\n return head;\n }\n ListNode* slow=head;\n ListNode* fast=head;\n while(fast!=NULL && fast->next!=NULL && fast->next->next!=NULL){\n fast=fast->next->next;\n slow=slow->next;\n }\n return slow;\n }\n\n\n ListNode* rev(ListNode* head){\n if(!head){\n return head;\n }\n ListNode* prev=NULL;\n ListNode* curr=head;\n ListNode* front=head->next;\n while(curr!=NULL && front!=NULL){\n curr->next=prev;\n prev=curr;\n curr=front;\n front=front->next;\n }\n curr->next=prev;\n return curr;\n }\n\n\npublic:\n bool isPalindrome(ListNode* head) {\n if(!head \|\| !head->next){\n return true;\n }\n ListNode* start=head;\n ListNode* mid=findMid(head);\n ListNode* revHead=rev(mid->next);\n while(revHead!=NULL){\n if(revHead->val!=start->val){\n rev(revHead);\n return false;\n }\n start=start->next;\n revHead=revHead->next;\n } \n rev(revHead);\n return true;\n }\n};", "memory": "94755" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "// /*\n// Definition for singly-linked list.\n// * struct ListNode {\n// * int val;\n// * ListNode next;\n// ListNode() : val(0), next(nullptr) {}\n// * ListNode(int x) : val(x), next(nullptr) {}\n// * ListNode(int x, ListNode next) : val(x), next(next) {}\n// };\n// /\n// class Solution {\n// public:\n\n\n// bool isPalindrome(ListNode head) {\n// // vector<int> ls ;\n// // ListNode* temp = head;\n// // while(temp!= NULL){\n// // ls.push_back(temp->val);\n// // temp = temp->next;\n// // }\n// // int left = 0;\n// // int right = ls.size()-1;\n// // while(left< right && ls[left] == ls[right] ){\n// // left++;\n// // right --;\n// // }\n// // return left>= right;\n\n \n// // }\n// };\nclass Solution {\npublic:\n ListNode* reverse(ListNode* head) {\n ListNode* prev = nullptr;\n ListNode* curr = head;\n while (curr != nullptr) {\n ListNode* next = curr->next;\n curr->next = prev;\n prev = curr;\n curr = next;\n }\n return prev;\n }\n \n bool isPalindrome(ListNode* head) {\n ListNode* slow = head;\n ListNode* fast = head;\n if(head== NULL \|\| head->next == NULL){\n return true;\n }\n while (fast->next!= nullptr && fast->next->next != nullptr) {\n slow = slow->next;\n fast = fast->next->next;\n }\n ListNode* rev = reverse(slow->next);\n while (rev != nullptr) {\n if (head->val != rev->val) {\n reverse(rev);\n return false;\n }\n head = head->next;\n rev = rev->next;\n }\n reverse(rev);\n return true;\n }\n};", "memory": "94755" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n bool isPalindrome(ListNode head) {\n if (head == nullptr)\n return false;\n\n ListNode* revHead = reverse(middleNode(head));\n\n bool palindrome = true;\n while(head != nullptr && revHead != nullptr) {\n if (head->val != revHead->val){\n palindrome = false;\n break;\n } \n\n head = head->next;\n revHead = revHead->next;\n }\n\n reverse(revHead);\n return palindrome;\n }\n\nprivate:\n ListNode* middleNode(ListNode* head) {\n if (head == nullptr)\n return nullptr;\n\n ListNode* slow = head;\n ListNode* fast = head;\n\n while (fast != nullptr && fast->next != nullptr) {\n slow = slow->next;\n fast = fast->next->next;\n }\n\n return slow;\n }\n\n ListNode* reverse(ListNode* head) {\n if (head == nullptr)\n return nullptr;\n\n ListNode* prev = nullptr;\n ListNode* curr = head;\n\n while (curr != nullptr) {\n ListNode* next = curr->next;\n curr->next = prev;\n prev = curr;\n curr = next;\n }\n\n return prev;\n }\n};\n", "memory": "96345" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n ListNodereversell(ListNodehead){\n if(head==NULL \|\| head->next==nullptr){\n return head;\n }\n ListNode newhead = reversell(head->next);\n ListNodefront = head->next;\n front->next=head;\n head->next =NULL;\n return newhead;\n }\n bool isPalindrome(ListNode head) {\n if(head==NULL \|\| head->next==nullptr){\n return true;\n }\n ListNodeslow = head;\n ListNodefast = head;\n ListNodeprev = head;\n while(fast->next != NULL && fast->next->next != NULL){\n slow=slow->next;\n prev=slow;\n fast=fast->next->next;\n } \n ListNodenewhead = reversell(prev->next);\n prev->next=newhead;\n ListNodefirst = head;\n ListNodesecond = newhead;\n while(second!=NULL){\n if(first->val!=second->val){\n reversell(newhead);\n return false;\n \n }\n second=second->next;\n first=first->next;\n \n \n }return true;\n reversell(newhead);\n }\n};", "memory": "97935" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n ListNodereversell(ListNodehead){\n if(head==NULL \|\| head->next==nullptr){\n return head;\n }\n ListNode newhead = reversell(head->next);\n ListNodefront = head->next;\n front->next=head;\n head->next =NULL;\n return newhead;\n }\n bool isPalindrome(ListNode head) {\n if(head==NULL \|\| head->next==nullptr){\n return true;\n }\n ListNodeslow = head;\n ListNodefast = head;\n ListNodeprev = head;\n while(fast->next != nullptr && fast->next->next != nullptr){\n slow=slow->next;\n prev=slow;\n fast=fast->next->next;\n } \n ListNodenewhead = reversell(prev->next);\n prev->next=newhead;\n ListNodefirst = head;\n ListNodesecond = newhead;\n while(second!=NULL){\n if(first->val!=second->val){\n reversell(newhead);\n return false;\n \n }\n second=second->next;\n first=first->next;\n \n \n }return true;\n reversell(newhead);\n }\n};", "memory": "99525" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n ListNode reverseLL(ListNode* head){\n if (head==NULL \|\| head->next==NULL)\n return head;\n ListNode newhead = reverseLL(head->next);\n ListNode temp = head->next;\n temp->next = head;\n head->next = NULL;\n return newhead;\n }\n bool isPalindrome(ListNode* head) {\n ios::sync_with_stdio(false);\n ListNode slow = head;\n ListNode fast = head;\n \n //finding mid of LL\n while(fast->next && fast->next->next){\n slow = slow->next;\n fast = fast->next->next;\n }\n //reverse the 2nd half of LL\n ListNode *newhead = reverseLL(slow->next);\n slow = head;\n fast = newhead;\n //match both halves\n while(fast){\n if (slow->val != fast->val)\n return false;\n slow = slow->next;\n fast = fast->next;\n }\n newhead = reverseLL(newhead);\n return true;\n }\n};", "memory": "101115" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n bool isPalindrome(ListNode head) {\n string s, t;\n ListNode* temp = head;\n while (temp != nullptr) {\n s+=to_string(temp->val);\n temp = temp->next;\n }\n // cout << s;\n ListNode* prev = nullptr;\n ListNode* next = nullptr;\n ListNode* curr = head;\n while (curr != nullptr) {\n next = curr->next;\n curr->next = prev;\n prev = curr;\n curr = next;\n }\n head = prev;\n ListNode* temp2 = head;\n while (temp2 != nullptr) {\n t += to_string(temp2->val);\n temp2 = temp2->next;\n }\n if (s == t) {\n return true;\n }\n return false;\n }\n};", "memory": "102705" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n ListNode reverseLL(ListNode* temp){\n ListNode* prev=NULL;\n ListNode* curr=temp;\n while(curr!=NULL){\n ListNode* front=curr->next;\n curr->next=prev;\n prev=curr;\n curr=front;\n }return prev;\n }\n bool isPalindrome(ListNode* head) {\n ListNode* slow=head;\n ListNode* fast=head;\n while(fast->next!=NULL && fast->next->next!=NULL){\n slow=slow->next;\n fast=fast->next->next;\n }ListNode* newHead=reverseLL(slow->next);\n ListNode* temp1=head;\n ListNode* temp2=newHead;\n bool flag=true;\n while(temp2){\n if(temp1->val != temp2->val){\n flag=false;\n break;\n }temp1=temp1->next;\n temp2=temp2->next;\n }ListNode* tail=reverseLL(newHead);\n return flag;\n }\n};", "memory": "104295" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n ListNode midEle(ListNodehead)\n {\n ListNodes=head;\n ListNodef=head;\n while(f->next!=NULL && f->next->next!=NULL)\n {\n s=s->next;\n f=f->next->next;\n }\n return s;\n }\n ListNode reverse(ListNode* head)\n {\n ListNodecurr=head;\n ListNodeprev=NULL;\n ListNode* next;\n while(curr!=NULL)\n {\n next=curr->next;\n curr->next=prev;\n prev=curr;\n curr=next;\n }\n return prev;\n }\n bool isPalindrome(ListNode* head) {\n ListNode* mid=midEle(head);\n ListNode* nh=reverse(mid->next);\n ListNodep=head;\n ListNodeq=nh;\n while(q!=NULL)\n {\n if(p->val!=q->val)\n {\n mid->next=reverse(nh);\n return false;\n }\n p=p->next;\n q=q->next;\n }\n mid->next=reverse(nh);\n return true;\n\n }\n};", "memory": "105885" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	1	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n ListNode findMiddle(ListNode* head)\n {\n ListNodefast=head->next;\n ListNodeslow=head;\n while(fast!=NULL&& fast->next!=NULL)\n {\n slow=slow->next;\n fast=fast->next->next;\n }\n return slow;\n }\n ListNode* reverse(ListNodehead)\n {\n ListNodecurr=head;\n ListNodeprev=NULL;\n ListNodeforward=NULL;\n while(curr!=NULL)\n {\n forward=curr->next;\n curr->next=prev;\n prev=curr;\n curr=forward;\n }\n return prev;\n }\n bool isPalindrome(ListNode* head) {\n if(head->next==NULL)return true;\n ListNodemiddle=findMiddle(head);\n ListNode temp=middle->next;\n middle->next= reverse(temp);\n ListNodehead1=head;\n ListNodehead2=middle->next;\n while(head2!=NULL)\n {\n if(head1->val!=head2->val)\n {\n return false;\n }\n head1=head1->next;\n head2=head2->next;\n }\n return true;\n\n }\n};", "memory": "105885" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	2	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n int length(ListNode head){\n int cnt=0;\n ListNode* temp=head ;\n while(temp!=NULL){\n temp=temp->next;\n cnt++;\n }\n return cnt;\n }\n bool isPalindrome(ListNode* head) {\n //step 1 - array banao\n // strep2 LL ko array me copy karo \n // setp3 array agr palindrome hai to LL bhi hai\n int n= length(head);\n int arr[n];\n ListNode* temp=head ;\n for(int i=0;i<n;i++){\n arr[i]=temp->val;\n temp=temp->next;\n }\n\n // arr ban gaya ab bas array palindrome hai ki nhi vo check karlo\n int s=0;\n int e= n-1;\n while(s<e){\n if(arr[s]!=arr[e]) return false;\n s++;\n e--;\n }\n return true;\n\n }\n};", "memory": "113835" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	2	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n bool isPalindrome(ListNode head) {\n int length = 0;\n ListNode *temp = head;\n while (temp != nullptr)\n {\n length++;\n temp = temp->next;\n }\n temp = head;\n int arr[length];\n for (int i = 0; i < length; i++)\n {\n arr[i] = temp->val;\n temp = temp -> next; \n }\n if (length == 0)\n {\n return true;\n }\n for (int i = 0; i < (int) length/2; i++)\n {\n if (arr[i] == arr[length - i - 1])\n {\n continue;\n }\n else\n {\n return false;\n }\n }\n return true;\n }\n};", "memory": "115425" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	2	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n bool isPalindrome(ListNode head) {\n ListNode* temp = head;\n int count = 0;\n while(temp != NULL)\n {\n count++;\n temp = temp->next;\n }\n int arr[count];\n temp = head;\n for(int i = 0; i < count; i++)\n {\n arr[i] = temp->val;\n temp = temp->next;\n }\n for(int i = 0; i < count/2 ; i++)\n {\n if(arr[i] != arr[count - i - 1])\n {\n return false;\n }\n }\n return true;\n // ListNode* current, prev, next;\n // current = head;\n // prev = NULL;\n // while(current != NULL)\n // {\n // current = current->next;\n // current->next = prev;\n // current = next;\n // }\n // head = prev;\n\n }\n};", "memory": "117015" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	2	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n bool isPalindrome(ListNode head) {\n int arr[100000];\n int k=0;\n ListNode* temp=head;\n while(temp!=NULL){\n arr[k++]=temp->val;\n temp=temp->next;\n }\n int flag=0;\n for(int i=0;i<k/2;i++){\n if(arr[i]!=arr[k-1-i]){\n flag=1;\n break;\n }\n }\n if(flag==0){\n return true;\n }else{\n return false;\n }\n }\n};", "memory": "117015" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	2	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n bool isPalindrome(ListNode head) {\n ListNode first=head;\n ListNode last=head;\n int count=1;\n if(head==NULL){\n return false;\n }\n while (last->next!=NULL){\n last=last->next;\n count++;\n } \n int arr[count];\n ListNode *curr=head;\n int i=0;\n while(curr!=NULL){\n arr[i]= curr->val;\n i++;\n curr=curr->next;\n } \n for(int j=0,co=count-1;j<co;co--,j++){\n if(arr[j]!=arr[co]){\n return false;\n }\n }\n return true;\n \n }\n};", "memory": "118605" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	2	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n bool isPalindrome(ListNode head) {\n if ( head == NULL \|\| head -> next == NULL ) {\n return true;\n }\n ListNode* temp = head;\n int count = 0;\n int arr[1000000] ;\n while ( temp != NULL ) {\n arr[count] = temp -> val;\n count++;\n temp = temp -> next;\n }\n\n int s = 0 , e = count-1;\n while ( s <= e ) {\n if ( arr[s] != arr[e] ) {\n return false;\n }\n s++ , e-- ;\n }\n return true;\n }\n};", "memory": "120195" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	2	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n bool isPalindrome(ListNode head) {\n ListNode* temp = head;\n \n // Calculate the length of the linked list\n int count = 0;\n while (temp) {\n count++;\n temp = temp->next;\n }\n \n // Reset temp to head and declare arrays\n temp = head;\n int arr[count]; \n int reverse[count];\n \n // Traverse the list and store the values in the array\n int i = 0;\n while (temp) {\n arr[i] = temp->val;\n i++;\n temp = temp->next;\n }\n \n // Traverse again from the end and store the values in reverse array\n temp = head;\n i = count - 1;\n while (temp) {\n reverse[i] = temp->val;\n i--;\n temp = temp->next;\n }\n \n // Compare the arrays to check if the linked list is a palindrome\n for (int i = 0; i < count; i++) {\n if (arr[i] != reverse[i])\n return false;\n }\n \n return true;\n }\n};", "memory": "121785" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	2	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n bool isPalindrome(ListNode head) {\n ListNode* temp=head;\n int arr[1000000];\n int i=0;\n while(temp){\n arr[i]=temp->val;\n i++;\n temp=temp->next;\n }\n int t=0,k=--i;\n while(t<=k){\n if(arr[t]!=arr[k])return false;\n t++;k--;\n } \n return true;\n }\n\n};", "memory": "121785" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	2	{ "code": "/*\n Definition for singly-linked list.\n * struct ListListListNode {\n * int val;\n * ListListListNode next;\n ListListNode() : val(0), next(nullptr) {}\n * ListListNode(int x) : val(x), next(nullptr) {}\n * ListListNode(int x, ListListNode next) : val(x), next(next) {}\n };\n /\n \n\nclass Solution {\npublic:\nListNode reverseLinkedList(ListNode* head) {\n if (head == NULL \|\| head->next == NULL) return head; \n ListNode* newHead = reverseLinkedList(head->next);\n head->next->next = head;\n head->next = NULL;\n return newHead;\n}\n bool isPalindrome(ListNode* head) {\n if (head == NULL \|\| head->next == NULL) return true;\n\n ListNode* slow = head;\n ListNode* fast = head;\n\n // Move slow to the middle and fast to the end\n while (fast->next != NULL && fast->next->next != NULL) {\n slow = slow->next;\n fast = fast->next->next;\n }\n\n // Reverse the second half of the list\n ListNode* newHead = reverseLinkedList(slow->next);\n ListNode* first = head;\n ListNode* second = newHead;\n\n // Compare the two halves\n while (second != NULL) {\n if (first->val != second->val) {\n reverseLinkedList(newHead); // Reverse back the second half\n return false;\n }\n first = first->next;\n second = second->next;\n }\n\n // Restore the list to its original form\n reverseLinkedList(newHead);\n\n return true;\n }\n};", "memory": "123375" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	2	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n\nListNode reverseList(ListNode* head) {\n if(head==NULL \|\| head->next==NULL)return head;\n ListNode* newHead = reverseList(head->next);\n ListNode* front = head->next;\n front->next = head;\n head->next = NULL;\n return newHead;\n }\n bool isPalindrome(ListNode* head) {\n ListNode* slow = head;\n ListNode* fast = head;\n while(fast->next != NULL && fast->next->next != NULL){\n slow = slow->next;\n fast = fast->next->next;\n }\n\n ListNode* newHead = reverseList(slow->next);\n ListNode* first = head;\n ListNode* second = newHead;\n while(second != NULL ){\n if(first->val != second->val){\n reverseList(newHead);\n return false;\n }first = first->next;\n second = second->next;\n }\n reverseList(newHead);\n return true;\n }\n};", "memory": "123375" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	2	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n bool isPalindrome(ListNode head) {\n ListNode* slow = head;\n ListNode* fast = head;\n int count = 0;\n bool answer = true;\n bool check = false;\n std::string palindrome = \"\";\n while (fast != nullptr) {\n palindrome.append(std::to_string(slow->val));\n slow = slow->next;\n if (fast->next != nullptr) {\n fast = fast->next;\n fast = fast->next;\n } else {\n check = true;\n fast = fast->next;\n }\n }\n if (check) {\n palindrome.pop_back(); \n }\n count = palindrome.length();\n \n \n \n cout << palindrome;\n while (slow != nullptr) {\n //cout << palindrome[count - 1] << endl;\n //std::string char_as_str(1, palindrome[count - 1]); \n if (slow->val != std::stoi(std::string(1, palindrome[count - 1]))) {\n\n answer = false;\n }\n \n slow = slow->next;\n count -= 1;\n }\n \n return answer;\n }\n};", "memory": "124965" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	2	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n bool isPalindromestring(string s)\n {\n int i=0,j=s.length()-1;\n while(i<=j)\n {\n if(s[i]!=s[j])\n return false;\n i++;j--;\n }\n return true;\n\n }\n bool isPalindrome(ListNode head) {\n ListNode* curr=head;\n string s;\n while(curr)\n {\n s.push_back(curr->val);\n curr=curr->next;\n }\n return isPalindromestring(s);\n }\n};", "memory": "124965" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	2	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n bool isPalindrome(ListNode head) {\n stack<int>st; \n ListNode* curr = head; \n while(curr!= NULL){\n st.push(curr->val);\n curr = curr->next;\n }\n curr = head; \n while(curr!=NULL && curr->val == st.top()){\n st.pop(); \n curr = curr->next;\n }\n return curr == NULL;\n }\n};", "memory": "126555" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	2	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n bool isPalindrome(ListNode head) {\n stack<int> stack;\n ListNode *current =head;\n\n while(current)\n {\n stack.push(current->val);\n current= current->next;\n\n }\n current=head;\n while(current&& current->val == stack.top())\n {\n stack.pop();\n current=current->next;\n }\nreturn current == nullptr;\n }\n};", "memory": "126555" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	3	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n int len(ListNode head){\n if(!head) return 0;\n\n return 1 + len(head->next);\n }\n\n bool isPalindrome(ListNode* head) {\n int t = len(head);\n\n if(t==1){\n return true;\n }\n\n vector<int>temp;\n\n int i;\n\n for(i=0;i<t/2;i++){\n temp.push_back(head->val);\n head = head->next;\n }\n\n if(t%2){\n head = head->next;\n i++;\n }\n\n int j = temp.size();\n\n while(i<t){\n if(head->val == temp[j-1]){\n head = head->next;\n j--;\n i++;\n }\n else{\n return false;\n }\n }\n\n return true;\n }\n};", "memory": "128145" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	3	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n bool isPalindrome(ListNode head) {\n string check = \"\";\n while(head!=nullptr){\n check += to_string(head->val);\n head=head->next;\n }\n\n string first = check;\n reverse(check.begin(),check.end());\n string second = check;\n\n if (first == second) return true;\n return false;\n }\n};", "memory": "128145" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	3	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n\tstring normal, reverse;\n bool isPalindrome(ListNode head) {\n goNormal(head);\n goReverse(head);\n return (normal == reverse);\n }\n \n void goNormal(ListNode* current) {\n \tif(!current) return;\n \tnormal.push_back(current->val);\n \tgoNormal(current->next);\n\t}\n \n void goReverse(ListNode* current) {\n \tif(!current) return;\n \tgoReverse(current->next);\n \treverse.push_back(current->val);\n\t}\n};", "memory": "129735" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	3	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n int length(ListNode head){\n ListNode* temp = head;\n int len = 0;\n while(temp != NULL){\n len++;\n temp = temp->next;\n }\n return len;\n }\n\n bool isReverse(vector<int> arr,int n){\n int s = 0;\n int e = n-1;\n\n while(s<e){\n if(arr[s]==arr[e]){\n s++;\n e--;\n }\n else{\n return false;\n }\n }\n return true;\n }\n bool isPalindrome(ListNode* head) {\n int n = length(head);\n\n vector<int> arr(n,0);\n\n ListNode* curr = head;\n int i = 0;\n while(curr != NULL){\n arr[i] = curr->val;\n i++;\n curr = curr->next;\n }\n\n return isReverse(arr,n);\n }\n};", "memory": "129735" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	3	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n bool isPalindrome(ListNode head) {\n vector<int>arr;\n ListNode*temp=head;\n bool p=1;\n while(temp!=nullptr){\n arr.push_back(temp->val);\n temp=temp->next;\n }\n int n=arr.size();\n int fast=n-1;\n for(int i=0;i<=n/2;i++){\n if(arr[i]==arr[fast]){\n fast--;\n }\n else{\n p=0;\n break;\n }\n }\n return p;\n }\n};", "memory": "131325" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	3	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n bool isPalindrome(ListNode head) {\n vector<int> num;\n auto current = head;\n while(current !=nullptr) {\n num.push_back(current->val);\n current = current->next;\n }\n int size = num.size() - 1;\n for(int i = 0 ; i < num.size()/2 ; ++i) {\n if(num[i] != num[size-i]) {\n return false;\n }\n }\n return true;\n \n }\n};", "memory": "131325" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	3	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\nprivate:\n bool _isPalindrome(ListNode h, queue<int>& storage) {\n if (h->next == nullptr) {\n storage.push(h->val);\n if ((storage.front() == h->val)) {\n storage.pop();\n return true;\n } else {\n storage.pop();\n return false;\n }\n }\n storage.push(h->val);\n auto future_ans =\n _isPalindrome(h->next, storage); // with storage filled\n bool status = future_ans && (storage.front() == h->val);\n storage.pop();\n return status;\n }\n\npublic:\n bool isPalindrome(ListNode* head) {\n queue<int> q;\n return _isPalindrome(head, q);\n }\n};", "memory": "132915" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	3	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\n void recursion(ListNodehead,string &start,string &end){\n if(head==nullptr){\n return ;\n }\n start+=head->val;\n recursion(head->next,start,end);\n end+=head->val;\n }\n bool isPalindrome(ListNode* head) {\n string start=\"\",end=\"\";\n recursion(head,start,end);\n return start==end;\n }\n};", "memory": "132915" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	3	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\npublic:\nvector<int>c;\nint f=0;\nvoid shit(ListNode start){\n if(start==NULL){\n return;\n }\n c.push_back(start->val);\n \n shit(start->next);\n if(c[f]==start->val){\n f++;\n }\n\n}\n bool isPalindrome(ListNode* head) {\n shit(head);\n \n return f==c.size();\n }\n};", "memory": "134505" }
234	<p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2,2,1] <strong>Output:</strong> true </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> <strong>Input:</strong> head = [1,2] <strong>Output:</strong> false </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul> <p> </p> <strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?	3	{ "code": "/*\n Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode next;\n ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode next) : val(x), next(next) {}\n };\n /\nclass Solution {\nprivate:\n void reverse(vector<int>& rev, ListNode head){\n if(head==NULL){\n return;\n }\n reverse(rev, head-> next);\n rev.push_back(head -> val);\n }\n\n \npublic:\n bool isPalindrome(ListNode* head) {\n vector<int> rev; \n reverse(rev, head);\n int size = rev.size();\n int index = 0;\n while(head!=NULL && index < size){\n if(rev[index] != head -> val){\n return false;\n }\n index++;\n head = head -> next;\n }\n return true;\n }\n};", "memory": "134505" }
235	<p>Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <strong>a node to be a descendant of itself</strong>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> The LCA of nodes 2 and 8 is 6. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 <strong>Output:</strong> 2 <strong>Explanation:</strong> The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [2,1], p = 2, q = 1 <strong>Output:</strong> 2 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == NULL) return NULL;\n root->left = lowestCommonAncestor(root->left, p, q);\n root->right = lowestCommonAncestor(root->right, p, q);\n if(root->val == p->val \|\| root->val == q->val) return root;\n if(root->left && root->right) return root;\n return root->left == NULL ? root -> right : root -> left;\n }\n};", "memory": "14200" }
235	<p>Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <strong>a node to be a descendant of itself</strong>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> The LCA of nodes 2 and 8 is 6. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 <strong>Output:</strong> 2 <strong>Explanation:</strong> The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [2,1], p = 2, q = 1 <strong>Output:</strong> 2 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\n\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if (root == NULL \|\| root == p \|\| root == q)\n return root;\n root->left = lowestCommonAncestor(root->left, p, q);\n root->right = lowestCommonAncestor(root->right, p, q);\n\n if (root->left != NULL && root->right != NULL)\n return root;\n else if (root->left != NULL)\n return root->left;\n else\n return root->right;\n }\n};", "memory": "14300" }
235	<p>Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <strong>a node to be a descendant of itself</strong>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> The LCA of nodes 2 and 8 is 6. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 <strong>Output:</strong> 2 <strong>Explanation:</strong> The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [2,1], p = 2, q = 1 <strong>Output:</strong> 2 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\n\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n vector<TreeNode> cur_path;\n TreeNode ancestor = nullptr;\n\n stack<TreeNode> dfs;\n dfs.push(root);\n while (!dfs.empty()) {\n TreeNode cur_node = dfs.top();\n\n if (!cur_node) {\n dfs.pop();\n continue;\n }\n if (!cur_path.empty() && (cur_node == cur_path.back())) {\n cur_path.pop_back();\n dfs.pop();\n if (cur_node == ancestor) {\n ancestor = cur_path.back();\n }\n continue;\n }\n\n cur_path.push_back(cur_node);\n\n if ((cur_node == p) \|\| (cur_node == q)) {\n if (ancestor) {\n break;\n }\n ancestor = cur_node;\n }\n\n dfs.push(cur_node->left);\n dfs.push(cur_node->right);\n cur_node->left = cur_node->right = nullptr;\n }\n\n return ancestor;\n }\n};", "memory": "14400" }
235	<p>Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <strong>a node to be a descendant of itself</strong>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> The LCA of nodes 2 and 8 is 6. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 <strong>Output:</strong> 2 <strong>Explanation:</strong> The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [2,1], p = 2, q = 1 <strong>Output:</strong> 2 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\n\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root==NULL){\n return NULL;\n }\n if(root==p \|\| root==q){\n return root;\n }\n root->left=lowestCommonAncestor(root->left,p,q);\n root->right=lowestCommonAncestor(root->right,p,q);\n\n if(root->right!=NULL && root->left!=NULL){\n return root;\n }\n else if(root->right!=NULL && root->left==NULL){\n return root->right;\n }\n else if(root->right==NULL && root->left!=NULL){\n return root->left;\n }\n else{\n return NULL;\n }\n }\n};", "memory": "14500" }
235	<p>Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <strong>a node to be a descendant of itself</strong>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> The LCA of nodes 2 and 8 is 6. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 <strong>Output:</strong> 2 <strong>Explanation:</strong> The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [2,1], p = 2, q = 1 <strong>Output:</strong> 2 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\n\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n return solve(root,p,q);\n \n }\n TreeNode* solve(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root==NULL) return NULL;\n if(root->val ==p->val \|\| root->val ==q->val) return root;\n root->right=solve(root->right,p,q);\n root->left=solve(root->left,p,q);\n if(root->left!=NULL && root->right!=NULL) return root;\n if(root->left==NULL) return root->right;\n return root->left;\n \n }\n};", "memory": "14600" }
235	<p>Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <strong>a node to be a descendant of itself</strong>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> The LCA of nodes 2 and 8 is 6. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 <strong>Output:</strong> 2 <strong>Explanation:</strong> The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [2,1], p = 2, q = 1 <strong>Output:</strong> 2 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\n\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n TreeNode * temp = root;\n while(temp){\n if(temp->val > p->val && temp->val > q->val) temp = temp->left;\n if(temp->val < p->val && temp->val < q->val) temp = temp->right;\n\n if((temp->val > p->val && temp->val < q->val) \|\| (temp->val < p->val && temp->val > q->val)){\n temp->left = NULL;\n temp->right = NULL;\n return temp;\n }\n if(temp->val == p->val \|\| temp->val == q->val){\n temp->left = NULL;\n temp->right = NULL;\n return temp;\n }\n }\n return NULL;\n }\n};", "memory": "19300" }
235	<p>Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <strong>a node to be a descendant of itself</strong>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> The LCA of nodes 2 and 8 is 6. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 <strong>Output:</strong> 2 <strong>Explanation:</strong> The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [2,1], p = 2, q = 1 <strong>Output:</strong> 2 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\n\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == p \|\| q == root)\n return root;\n \n if(root==NULL){\n return NULL;\n }\n if ((root -> val > p -> val) && (root -> val > q -> val)) {\n return lowestCommonAncestor(root -> left, p, q);\n }\n else if ((root -> val < p -> val) && (root -> val < q -> val)) {\n return lowestCommonAncestor(root -> right, p, q);\n }\n root->left = root->right = nullptr;\n return root;\n }\n};", "memory": "19400" }
235	<p>Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <strong>a node to be a descendant of itself</strong>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> The LCA of nodes 2 and 8 is 6. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 <strong>Output:</strong> 2 <strong>Explanation:</strong> The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [2,1], p = 2, q = 1 <strong>Output:</strong> 2 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\n\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root==NULL){ \n return root;\n }\n root->left=lowestCommonAncestor(root->left, p,q); \n root->right=lowestCommonAncestor(root->right, p,q);\n\n if(p->val < root->val && q->val < root->val){\n return root->left;\n }\n if(p->val > root->val && q->val > root->val){\n return root->right;\n }\n return root;\n\n \n }\n};", "memory": "20700" }
235	<p>Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <strong>a node to be a descendant of itself</strong>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> The LCA of nodes 2 and 8 is 6. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 <strong>Output:</strong> 2 <strong>Explanation:</strong> The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [2,1], p = 2, q = 1 <strong>Output:</strong> 2 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\n\nclass Solution {\npublic:\n TreeNode val(TreeNode r,TreeNode p,TreeNode q)\n { \n if (r)\n {\n if (r->val==p->val) return r;\n if (r->val==q->val) return r;\n if (!r->left && !r->right) return NULL;\n TreeNode l=val(r->left,p,q);\n TreeNode t=val(r->right,p,q);\n if (l && t) return r;\n if (!l && t) return t;\n if (l && !t) return l;\n }\n return NULL;\n }\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n return val(root,p,q);\n }\n};", "memory": "21700" }
235	<p>Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <strong>a node to be a descendant of itself</strong>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> The LCA of nodes 2 and 8 is 6. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 <strong>Output:</strong> 2 <strong>Explanation:</strong> The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [2,1], p = 2, q = 1 <strong>Output:</strong> 2 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\n\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root==nullptr)return root;\n if(root->val < p->val && root->val < q->val) return lowestCommonAncestor(root->right,p,q);\n if(root->val > p->val && root->val > q->val) return lowestCommonAncestor(root->left,p,q);\n return root;\n }\n};", "memory": "21800" }
235	<p>Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <strong>a node to be a descendant of itself</strong>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> The LCA of nodes 2 and 8 is 6. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 <strong>Output:</strong> 2 <strong>Explanation:</strong> The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [2,1], p = 2, q = 1 <strong>Output:</strong> 2 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\n\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n //if the current root is greater than both\n if(root -> val > p -> val && root -> val > q->val)\n return lowestCommonAncestor(root -> left, p, q);\n \n if(root -> val < p -> val && root -> val < q->val)\n return lowestCommonAncestor(root -> right, p,q);\n \n return root;\n }\n};", "memory": "21800" }
235	<p>Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <strong>a node to be a descendant of itself</strong>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> The LCA of nodes 2 and 8 is 6. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 <strong>Output:</strong> 2 <strong>Explanation:</strong> The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [2,1], p = 2, q = 1 <strong>Output:</strong> 2 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\n\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == NULL){\n return root;\n }\n else if((p->val > root->val && q->val < root->val) \|\| (p->val < root-> val && q->val > root->val)){\n return root;\n }else if(p->val > root->val && q->val > root->val){\n return lowestCommonAncestor(root->right, p, q);\n }else if(p->val < root->val && q->val < root->val){\n return lowestCommonAncestor(root->left, p, q);\n }else if(p->val == root->val){\n return p;\n }else{\n return q;\n }\n }\n};", "memory": "21900" }
235	<p>Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <strong>a node to be a descendant of itself</strong>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> The LCA of nodes 2 and 8 is 6. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 <strong>Output:</strong> 2 <strong>Explanation:</strong> The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [2,1], p = 2, q = 1 <strong>Output:</strong> 2 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\n\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if (root == NULL) return root;\n else if (p->val < root->val && q->val < root->val) return lowestCommonAncestor(root->left, p,q);\n else if (p->val > root->val && q->val > root->val) return lowestCommonAncestor(root->right, p,q);\n return root;\n }\n};", "memory": "21900" }
235	<p>Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <strong>a node to be a descendant of itself</strong>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> The LCA of nodes 2 and 8 is 6. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 <strong>Output:</strong> 2 <strong>Explanation:</strong> The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [2,1], p = 2, q = 1 <strong>Output:</strong> 2 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\n\nclass Solution {\npublic:\n TreeNode f(TreeNode* root, TreeNode* p, TreeNode* q){\n\n if(root==p \|\| root==q)return root;\n\n int cur= root->val;\n if(cur >p->val && cur >q->val)return f(root->left,p,q); \n if(cur <p->val && cur <q->val)return f(root->right,p,q);\n \n return root;\n }\n\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q){\n return f(root,p,q);\n }\n};", "memory": "22000" }
235	<p>Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <strong>a node to be a descendant of itself</strong>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> The LCA of nodes 2 and 8 is 6. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 <strong>Output:</strong> 2 <strong>Explanation:</strong> The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [2,1], p = 2, q = 1 <strong>Output:</strong> 2 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\n\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n\n if(!root) return NULL;\n\n if(root->val > p->val && root->val > q->val)\n return lowestCommonAncestor(root->left, p, q);\n\n else if(root->val < p->val && root->val < q->val)\n return lowestCommonAncestor(root->right, p, q);\n\n return root; \n }\n};", "memory": "22000" }
235	<p>Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <strong>a node to be a descendant of itself</strong>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> The LCA of nodes 2 and 8 is 6. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 <strong>Output:</strong> 2 <strong>Explanation:</strong> The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [2,1], p = 2, q = 1 <strong>Output:</strong> 2 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>	1	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\n\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(!root)\n return nullptr;\n if(root == p \|\| root == q)\n {\n return root;\n }\n bool r = find(root->right, p, q);\n bool l = find(root->left, p, q);\n if(r && l)\n return root;\n if (r)\n return lowestCommonAncestor(root->right, p, q);\n return lowestCommonAncestor(root->left, p, q);\n \n }\n bool find(TreeNode* root, TreeNode* p, TreeNode* q){\n if(!root)\n return false;\n if(root == p \|\| root == q)\n return true;\n else\n return find(root->right, p, q) \|\| find(root->left, p, q);\n }\n};", "memory": "22100" }
235	<p>Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <strong>a node to be a descendant of itself</strong>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> The LCA of nodes 2 and 8 is 6. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 <strong>Output:</strong> 2 <strong>Explanation:</strong> The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [2,1], p = 2, q = 1 <strong>Output:</strong> 2 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>	1	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\n\nclass Solution {\npublic:\n\nTreeNode findLCA(TreeNode * root , TreeNode * p , TreeNode * q)\n{\n if(root == NULL) return NULL;\n if(root->val == p->val \|\| root->val == q->val) return root;\n\n if(p->val < root->val && q->val < root->val )\n return findLCA(root->left , p ,q);\n else if ( p ->val > root->val && q->val > root->val)\n return findLCA(root->right , p ,q);\n else\n return root;\n\n}\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n \n if(root == NULL) return nullptr;\n\n return findLCA(root , p , q);\n\n }\n};", "memory": "22100" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == p \|\| root == q){\n return root;\n }\n if(root->left){\n root->left = lowestCommonAncestor(root->left, p, q);\n }\n if(root->right){\n root->right = lowestCommonAncestor(root->right, p, q);\n }\n if(root->left){\n if(root->right){\n return root;\n }\n else{\n return root->left;\n }\n }\n else{\n return root->right;\n }\n }\n};", "memory": "13200" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == p \|\| root == q){\n return root;\n }\n if(root->left){\n root->left = lowestCommonAncestor(root->left, p, q);\n }\n if(root->right){\n root->right = lowestCommonAncestor(root->right, p, q);\n }\n if(root->left && root->right){\n return root;\n }\n else if(!root->left){\n return root->right;\n }\n else{\n return root->left;\n }\n }\n};", "memory": "13300" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\n class Solution {\n public:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root==NULL)\n return NULL;\n root->left = lowestCommonAncestor(root->left,p,q);\n root->right = lowestCommonAncestor(root->right,p,q);\n if(root->val==p->val \|\| root->val==q->val)\n return root;\n if(root->left && root->right)\n return root;\n return root->left==NULL ? root->right : root->left;\n }\n };", "memory": "13300" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == p \|\| root == q){\n return root;\n }\n if(root->left){\n root->left = lowestCommonAncestor(root->left, p, q);\n }\n if(root->right){\n root->right = lowestCommonAncestor(root->right, p, q);\n }\n if(root->left && root->right){\n return root;\n }\n else if(!root->left){\n return root->right;\n }\n else{\n return root->left;\n }\n }\n};", "memory": "13400" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == p \|\| root == q){\n return root;\n }\n if(root->left){\n root->left = lowestCommonAncestor(root->left, p, q);\n }\n if(root->right){\n root->right = lowestCommonAncestor(root->right, p, q);\n }\n if(root->left){\n if(root->right){\n return root;\n }\n else{\n return root->left;\n }\n }\n else{\n return root->right;\n }\n }\n};", "memory": "13400" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == p \|\| root == q){\n return root;\n }\n if(root->left){\n root->left = lowestCommonAncestor(root->left, p, q);\n }\n if(root->right){\n root->right = lowestCommonAncestor(root->right, p, q);\n }\n if(root->left){\n if(root->right){\n return root;\n }\n else{\n return root->left;\n }\n }\n else{\n return root->right;\n }\n }\n};", "memory": "13500" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == p \|\| root == q){\n return root;\n }\n if(root->left){\n root->left = lowestCommonAncestor(root->left, p, q);\n }\n if(root->right){\n root->right = lowestCommonAncestor(root->right, p, q);\n }\n if(root->left){\n if(root->right){\n return root;\n }\n else{\n return root->left;\n }\n }\n else{\n return root->right;\n }\n }\n};", "memory": "13500" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == p \|\| root == q){\n return root;\n }\n if(root->left){\n root->left = lowestCommonAncestor(root->left, p, q);\n }\n if(root->right){\n root->right = lowestCommonAncestor(root->right, p, q);\n }\n if(root->left && root->right){\n return root;\n }\n else if(!root->left){\n return root->right;\n }\n else{\n return root->left;\n }\n }\n};", "memory": "13600" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == p \|\| root == q){\n return root;\n }\n if(root->left){\n root->left = lowestCommonAncestor(root->left, p, q);\n }\n else{\n root->left = nullptr;\n }\n if(root->right){\n root->right = lowestCommonAncestor(root->right, p, q);\n }\n else{\n root->right = nullptr;\n }\n\n if(root->left && root->right){\n return root;\n }\n else if(!root->left){\n return root->right;\n }\n else{\n return root->left;\n }\n }\n};", "memory": "13600" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == p \|\| root == q){\n return root;\n }\n if(root->left){\n root->left = lowestCommonAncestor(root->left, p, q);\n }\n else{\n root->left = nullptr;\n }\n if(root->right){\n root->right = lowestCommonAncestor(root->right, p, q);\n }\n else{\n root->right = nullptr;\n }\n\n if(root->left && root->right){\n return root;\n }\n else if(!root->left){\n return root->right;\n }\n else{\n return root->left;\n }\n }\n};", "memory": "13700" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == p \|\| root == q){\n return root;\n }\n if(root->left){\n root->left = lowestCommonAncestor(root->left, p, q);\n }\n else{\n root->left = nullptr;\n }\n if(root->right){\n root->right = lowestCommonAncestor(root->right, p, q);\n }\n else{\n root->right = nullptr;\n }\n\n if(root->left && root->right){\n return root;\n }\n else if(!root->left){\n return root->right;\n }\n else{\n return root->left;\n }\n }\n};", "memory": "13700" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root==NULL \|\| root==p \|\| root==q) return root;\n root->left=lowestCommonAncestor(root->left, p, q);\n root->right=lowestCommonAncestor(root->right, p ,q);\n if(root->left==NULL){\n return root->right;\n }\n if(root->right==NULL){\n return root->left;\n }\n\n return root;\n\n }\n};", "memory": "13800" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n vector<TreeNode> cur_path;\n TreeNode ancestor = nullptr;\n\n stack<TreeNode> dfs;\n dfs.push(root);\n while (!dfs.empty()) {\n TreeNode cur_node = dfs.top();\n\n if (!cur_node) {\n dfs.pop();\n continue;\n }\n if (!cur_path.empty() && (cur_node == cur_path.back())) {\n cur_path.pop_back();\n dfs.pop();\n if (cur_node == ancestor) {\n ancestor = cur_path.back();\n }\n continue;\n }\n\n cur_path.push_back(cur_node);\n\n if ((cur_node == p) \|\| (cur_node == q)) {\n if (ancestor) {\n break;\n }\n ancestor = cur_node;\n }\n\n dfs.push(cur_node->left);\n dfs.push(cur_node->right);\n cur_node->left = cur_node->right = nullptr;\n }\n\n return ancestor;\n }\n};", "memory": "13900" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n TreeNode lca(TreeNode * &root, TreeNode * p, TreeNode * q, TreeNode * &a){\n if(root == NULL \|\| a)\n return a;\n lca(root->left, p, q, a);\n lca(root->right, p, q, a);\n if(a != NULL)\n return a;\n if((root->left == p && root->right == q) \|\|( root->left == q && root->right == p))\n a = root;\n else if(root->left == p \|\| root->right == p){\n if(root == q){\n a = q;\n return a;}\n root = p;\n }\n else if(root->left == q \|\| root->right == q){\n if(root == p){\n a = p;\n return a;\n }\n root = q;\n }\n return a;\n }\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n TreeNode * a = NULL;\n return lca(root, p ,q, a);\n }\n};", "memory": "14300" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n bool lca1(TreeNode root, TreeNode* p){\n if(root==p) return true;\n if(root==NULL) return false;\n return lca1(root->left,p)\|\|lca1(root->right,p);\n }\n bool lca2(TreeNode* root,TreeNode* q){\n if(root==q) return true;\n if(root==NULL) return false;\n return lca2(root->left,q)\|\|lca2(root->right,q);\n }\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root==p \|\| root==q) return root;\n if(lca1(root->left,p) && lca2(root->left,q)){\n return lowestCommonAncestor(root->left,p,q);\n }\n else if(lca1(root->right,p) && lca2(root->right,q)){\n return lowestCommonAncestor(root->right,p,q);\n }\n else{\n return root;\n }\n }\n};", "memory": "15800" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n bool findNode(TreeNode root, TreeNode* cur){\n if(root == NULL) return false;\n if(root == cur) return true;\n return findNode(root->right, cur) \|\| findNode(root->left, cur);\n }\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(p == root \|\| q == root){\n return root;\n }\n if(root->left == NULL) return lowestCommonAncestor(root->right, p, q);\n if(root->right == NULL) return lowestCommonAncestor(root->left, p, q);\n if(findNode(root->left, p) && findNode(root->right,q)){\n return root;\n }\n if(findNode(root->left, p) && findNode(root->left, q)){\n return lowestCommonAncestor(root->left, p, q);\n }\n if(findNode(root->right, p) && findNode(root->right, q)){\n return lowestCommonAncestor(root->right, p, q);\n }\n return root;\n \n }\n};", "memory": "15900" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n\n TreeNode LCA_helper(TreeNode* root, TreeNode* p, TreeNode* q)\n {\n if(root==NULL \|\| root==p \|\| root==q)\n return root;\n \n TreeNode* lst_LCA = LCA_helper(root->left,p,q);\n TreeNode* rst_LCA = LCA_helper(root->right,p,q);\n\n if(lst_LCA==NULL)\n return rst_LCA;\n \n else if(rst_LCA==NULL)\n return lst_LCA;\n \n else // neither lst_LCA nor rst_LCA are NULL\n return root;\n }\n\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) { \n return LCA_helper(root,p,q);\n }\n};", "memory": "16000" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == NULL \|\| root == p \|\| root == q){\n return root;\n }\n TreeNode* l = lowestCommonAncestor(root->left,p,q);\n TreeNode* r = lowestCommonAncestor(root->right,p,q);\n if(l == NULL){\n return r;\n }\n else if(r == NULL){\n return l;\n }\n else{\n return root;\n }\n }\n};", "memory": "16000" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "class Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if (!root) return nullptr;\n\n // If either p or q is the root, then root is the LCA\n if (root == p \|\| root == q) {\n return root;\n }\n\n // Recur on the left and right subtrees\n TreeNode* left = lowestCommonAncestor(root->left, p, q);\n TreeNode* right = lowestCommonAncestor(root->right, p, q);\n\n // If p and q are found in left and right subtrees respectively, root is the LCA\n if (left && right) {\n return root;\n }\n\n // If either left or right subtree has both p and q, return that subtree's result\n return left ? left : right;\n }\n};\n", "memory": "16100" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(!root)\n return NULL;\n if(root==p \|\| root==q)\n return root;\n TreeNode* l=lowestCommonAncestor(root->left,p,q);\n TreeNode* r=lowestCommonAncestor(root->right,p,q);\n if(l && r)return root;\n if(l)return l;\n if(r)return r;\n return NULL;\n \n }\n};", "memory": "16100" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n bool existingInTree(TreeNode root, TreeNode* target){\n if(root==target) return true;\n if(root==NULL) return false;\n return existingInTree(root->left,target) \|\| existingInTree(root->right,target);\n }\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root==p \|\| root==q) return root;\n else if(existingInTree(root->left, p) && existingInTree(root->right,q)) return root;\n else if(!existingInTree(root->left,p) && !existingInTree(root->right,q)) return root;\n else if(existingInTree(root->left,p) && !existingInTree(root->right,q)) return lowestCommonAncestor(root->left,p,q);\n else return lowestCommonAncestor(root->right,p,q);\n }\n};", "memory": "16200" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n bool exists(TreeNode root,TreeNode* target){\n if(root== NULL) return false;\n if(root==target) return true;\n return exists(root->left,target) \|\| exists(root->right,target);\n }\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(p==root \|\| q==root) return root;\n else if(exists(root->left,p)&& exists(root->right ,q)) return root;\n else if(exists(root->right,p)&& exists(root->left ,q)) return root;\n else if(exists(root->left,p)&& exists(root->left ,q)) return lowestCommonAncestor(root->left ,p,q) ;\n else return lowestCommonAncestor(root->right,p,q);\n }\n};", "memory": "16200" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root==NULL\|\|root==p\|\|root==q) return root;\n\n TreeNode* left=lowestCommonAncestor(root->left,p,q);\n TreeNode* right=lowestCommonAncestor(root->right,p,q);\n\n if(left==NULL)\n return right;\n else if(right==NULL)\n return left;\n else\n return root;\n }\n};", "memory": "16300" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	0	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if (root == nullptr) {\n return nullptr;\n }\n if (root == p \|\| root == q) {\n return root;\n }\n TreeNode* foundInLeft = lowestCommonAncestor(root->left, p, q);\n TreeNode* foundInRight = lowestCommonAncestor(root->right, p, q);\n if (foundInLeft && foundInRight) {\n return root;\n } \n if (foundInLeft) {\n return foundInLeft;\n } else {\n return foundInRight;\n }\n }\n};", "memory": "16300" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	1	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root==NULL){\n return NULL;\n }\n if(root==p \|\| root==q){\n return root;\n }\n\n TreeNode* leftA=lowestCommonAncestor(root->left,p,q);\n TreeNode* rightA=lowestCommonAncestor(root->right,p,q);\n\n if(leftA!=NULL && rightA!=NULL){\n return root;\n }\n else if(leftA!=NULL && rightA==NULL){\n return leftA;\n }\n else if(leftA==NULL && rightA!=NULL){\n return rightA;\n }\n else{\n return NULL;\n }\n }\n};", "memory": "16400" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	1	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == nullptr) return root;\n if(root == p \|\| root == q) return root;\n TreeNode* left = lowestCommonAncestor(root->left, p,q);\n TreeNode* right = lowestCommonAncestor(root->right,p,q);\n\n if(left == nullptr){\n return right;\n }\n else if(right == nullptr){\n return left;\n }\n else {\n return root;\n }\n }\n};", "memory": "16400" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	3	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n\n if(root==NULL\|\| root==p\|\| q==root)\n {\n return root;\n }\n\n TreeNodelnode=lowestCommonAncestor(root->left,p,q);\n TreeNoderight=lowestCommonAncestor(root->right,p,q);\n\n\n if(lnode==NULL)\n {\n return right;\n }else if(right==NULL)\n {\n return lnode;\n }else{\n return root;\n }\n\n\n\n\n }\n};", "memory": "16500" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	3	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n //basic fundamenta l idea for this questuin is that ki \n\n if(!root)\n {\n return NULL;\n }\n if(root==p\|\|root==q)\n {\n return root;\n }\n\n TreeNodel=lowestCommonAncestor( root->left, p,q);\n TreeNoder=lowestCommonAncestor( root->right, p,q);\n\n if(l && r)\n {\n return root;\n }\n\n if(!l)\n {\n if(r)\n {\n return r;\n }\n else\n {\n return NULL;\n }\n }\n\n if(!r)\n {\n if(l)\n {\n return l;\n }\n else\n {\n return NULL;\n }\n }\n return NULL;\n }\n};", "memory": "16500" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	3	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n TreeNode* L=NULL;\n fn(root,p,q,L);\n return L;\n }\n bool fn(TreeNode* root, TreeNode* &p, TreeNode* &q,TreeNode* &L){\n if(!L){\n if(root){\n bool l,r,c;\n c = (root == p \|\| root == q);\n l = fn(root->left,p,q,L);\n r = fn(root->right,p,q,L);\n if(l && r){\n L = root;\n return false;\n }\n if(c && (l\|\|r)){\n L = root;\n return false;\n }\n if(l\|\|r\|\|c){\n return true;\n }\n }\n else{\n return false;\n }\n }\n return false;\n }\n};", "memory": "16600" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	3	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n TreeNode* L=NULL;\n fn(root,p,q,L);\n return L;\n }\n bool fn(TreeNode* root, TreeNode* &p, TreeNode* &q,TreeNode* &L){\n if(!L){\n if(root){\n bool l,r,c;\n c = (root == p \|\| root == q);\n l = fn(root->left,p,q,L);\n r = fn(root->right,p,q,L);\n if(l && r){\n L = root;\n return false;\n }\n if(c && (l\|\|r)){\n L = root;\n return false;\n }\n if(l\|\|r\|\|c){\n return true;\n }\n }\n else{\n return false;\n }\n }\n return false;\n }\n};", "memory": "16600" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	3	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n bool mylowestCommonAncestor(TreeNode& root, TreeNode& p, TreeNode& q,\n TreeNode& pLCA, bool& leftFound) {\n if (!root)\n return false;\n if (pLCA)\n return false;\n if (leftFound && (p == root \|\| q == root))\n return true;\n bool bLeftFound =\n mylowestCommonAncestor(root->left, p, q, pLCA, leftFound);\n if (bLeftFound && (p == root \|\| q == root)) {\n pLCA = root;\n return false;\n }\n if (bLeftFound)\n leftFound = bLeftFound;\n bool bRightFound =\n mylowestCommonAncestor(root->right, p, q, pLCA, leftFound);\n if ((bLeftFound && bRightFound) \|\|\n ((bLeftFound \|\| bRightFound) && (p == root \|\| q == root))) {\n pLCA = root;\n return false;\n }\n return bLeftFound \|\| bRightFound \|\| p == root \|\| q == root;\n }\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n auto init = []() {\n ios::sync_with_stdio(0);\n cin.tie(0);\n cout.tie(0);\n return 'c';\n }();\n if (!root)\n return NULL;\n TreeNode* LCA = NULL;\n bool b = false;\n mylowestCommonAncestor(root, p, q, LCA, b);\n return LCA;\n }\n};\n", "memory": "16700" }
236	<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p> <p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p> <p> </p> <p><strong class="example">Example 1:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 <strong>Output:</strong> 3 <strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3. </pre> <p><strong class="example">Example 2:</strong></p> <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> <strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 <strong>Output:</strong> 5 <strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> root = [1,2], p = 1, q = 2 <strong>Output:</strong> 1 </pre> <p> </p> <p><strong>Constraints:</strong></p> <ul> <li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li> <li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li> <li>All <code>Node.val</code> are <strong>unique</strong>.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>	3	{ "code": "/*\n Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode left;\n TreeNode right;\n TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n /\nclass Solution {\npublic:\n bool mylowestCommonAncestor(TreeNode& root, TreeNode& p, TreeNode& q,\n TreeNode& pLCA, bool& leftFound) {\n if (!root \|\| pLCA)\n return false;\n else if (leftFound && (p == root \|\| q == root))\n return true;\n bool bLeftFound =\n mylowestCommonAncestor(root->left, p, q, pLCA, leftFound);\n if (bLeftFound && (p == root \|\| q == root)) {\n pLCA = root;\n return false;\n }\n else if (bLeftFound)\n leftFound = bLeftFound;\n bool bRightFound =\n mylowestCommonAncestor(root->right, p, q, pLCA, leftFound);\n if ((bLeftFound && bRightFound) \|\|\n ((bLeftFound \|\| bRightFound) && (p == root \|\| q == root))) {\n pLCA = root;\n return false;\n }\n return bLeftFound \|\| bRightFound \|\| p == root \|\| q == root;\n }\n TreeNode lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n auto init = []() {\n ios::sync_with_stdio(0);\n cin.tie(0);\n cout.tie(0);\n return 'c';\n }();\n if (!root)\n return NULL;\n TreeNode* LCA = NULL;\n bool b = false;\n mylowestCommonAncestor(root, p, q, LCA, b);\n return LCA;\n }\n};\n", "memory": "16700" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n string original (ListNode* head){\n string str1=\"\";\n while(head!=nullptr){\n str1+=head->val;\n head=head->next;\n }\n return str1;\n }\n string reversed (ListNode*prev){\n string str2=\"\";\n while(prev!=nullptr){\n str2+=prev->val;\n prev=prev->next;\n }\n return str2;\n\n \n }\n ListNode *reversedlinked(ListNode *head){\n ListNode *prev=nullptr,*next;\n ListNode*curr=head;\n\n while(curr!=nullptr){\n next=curr->next;\n curr->next=prev;\n prev=curr;\n curr=next;\n }\n return prev; \n }\n\n bool isPalindrome(ListNode* head) {\n string str1= original (head);\n ListNode*prev = reversedlinked(head);\n string str2= reversed (prev);\n if (str1==str2) return true;\n else return false;\n\n }\n};", "memory": "74085" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\n\nclass Solution {\npublic:\n ListNode* reverseList(ListNode* &head) {\n if(head == NULL || head->next == NULL)\n return head;\n ListNode* newhead = reverseList(head->next);\n head->next->next = head;\n head->next = NULL;\n return newhead;\n }\n bool isPalindrome(ListNode* head) {\n ListNode* slow=head;\n ListNode* fast=head;\n\n while(fast && fast->next)\n {\n fast=fast->next->next;\n slow=slow->next;\n }\n\n \n ListNode* tmp1=reverseList(slow);\n ListNode* tmp2=head;\n\n while(tmp2!=slow)\n {\n if(tmp2->val!=tmp1->val)\n return 0;\n tmp2=tmp2->next;\n tmp1=tmp1->next;\n }\n return 1;\n\n\n }\n};", "memory": "75675" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n ListNode* reverse(ListNode* &head){\n if(head==NULL||head->next==NULL) return head;\n ListNode* newHead=reverse(head->next);\n ListNode* front=head->next;\n front->next=head;\n head->next=NULL;\n return newHead;\n\n }\n ListNode* mid(ListNode* &head){\n ListNode* slow=head;\n ListNode* fast=head;\n while(fast!=NULL&&fast->next!=NULL){\n slow=slow->next;\n fast=fast->next->next;\n }\n return slow;\n }\n bool isPalindrome(ListNode* head) {\n ListNode* start=head;\n if(head==NULL) return 0;\n ListNode* mid1=mid(head);\n \n ListNode* p=reverse(mid1);\n \n while(p!=NULL){\n cout<<p->val<<\" \"<<start->val;\n if(p->val!=start->val) {\n return 0;\n break;\n }\n start=start->next;\n p=p->next;\n }\n return 1;\n \n }\n};", "memory": "77265" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n ListNode* reverseL(ListNode* temp)\n {\n if(!temp || !temp->next)\n return temp;\n \n ListNode* newH=reverseL(temp->next);\n ListNode* ttp=temp->next;\n ttp->next=temp;\n temp->next=nullptr;\n return newH;\n }\n bool isPalindrome(ListNode* head) {\n ListNode* slow=head,*fast=head,*tp=head;\n while(fast->next && fast->next->next)\n {\n fast=fast->next->next;\n slow=slow->next;\n }\n ListNode* tps=reverseL(slow->next);\n while(tps)\n {\n if(tps->val != tp->val)\n return false;\n tps=tps->next;\n tp=tp->next;\n }\n return true;\n }\n};", "memory": "78855" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "class Solution {\npublic:\nListNode* middle(ListNode* head){\nif(head->next!=nullptr){\n ListNode* slow=head->next;\n ListNode* fast=slow->next; \n while(fast!=nullptr && fast->next != nullptr){\n slow=slow->next;\n fast=fast->next;\n if(fast!=nullptr) fast=fast->next;\n }\n return slow;\n }\n else return head;\n}\nListNode* reverseList(ListNode* head){\nif(head==nullptr||head->next == nullptr)\nreturn head;\nListNode* n=reverseList(head->next);\nhead->next->next=head;\nhead->next=nullptr;\nreturn n;\n}\nbool isPalindrome(ListNode* head){\n ListNode* m=middle(head);\n ListNode* temp=reverseList(m);\n while(head!=m){\n if(head->val!=temp->val)\n return false;\n else{\n head=head->next; \n temp=temp->next;\n }\n }\n return true;\n }\n};", "memory": "80445" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "class Solution {\npublic:\n ListNode* reverselist(ListNode* head){\n if(head == NULL || head->next == NULL) return head;\n ListNode* newHead = reverselist(head->next);\n head->next->next = head;\n head->next = NULL;\n return newHead;\n }\n bool isPalindrome(ListNode* head) {\n ListNode* slow = head;\n ListNode* fast = head;\n while(fast->next != NULL && fast->next->next != NULL){\n slow = slow->next;\n fast = fast->next->next;\n }\n ListNode* NewHead = reverselist(slow->next);\n ListNode* A = head;\n ListNode* B = NewHead;\n while(B){\n if(A->val != B->val) return false;\n A = A->next;\n B = B->next;\n }\n return true;\n }\n};", "memory": "82035" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\nListNode* reverse(ListNode*head){\n if(head==NULL || head->next==NULL){\n return head;\n }\n ListNode* newHead=reverse(head->next);\n head->next->next=head;\n head->next=NULL;\n return newHead;\n}\n bool isPalindrome(ListNode* head) {\n if (head == NULL || head->next == NULL) {\n \n // It's a palindrome by definition\n return true; \n }\n //find the middle of the ll\n ListNode* slow = head;\n ListNode* fast = head;\n while (fast != nullptr && fast->next != nullptr) {\n slow = slow->next;\n fast = fast->next->next;\n }\n ListNode* rev = reverse(slow);\n while (rev != nullptr) {\n if (head->val != rev->val) {\n return false;\n }\n head = head->next;\n rev = rev->next;\n }\n return true;\n }\n};", "memory": "82035" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n ListNode* rec(ListNode* head){\n if(head==nullptr || head->next==nullptr) return head;\n \n ListNode* newhead=rec(head->next);\n head->next->next=head;\n head->next=nullptr;\n return newhead;\n }\n bool isPalindrome(ListNode* head) {\n if(head->next==nullptr) return true;\n ListNode* slow=head;\n ListNode* fast=head;\n while(fast != nullptr && fast->next != nullptr){\n fast=fast->next->next;\n slow=slow->next;\n }\n \n ListNode* newhead=rec(slow);\n ListNode* curr=head;\n while(newhead!=nullptr){\n if(curr->val!=newhead->val) return false;\n newhead=newhead->next;\n curr=curr->next;\n }\n return true;\n }\n};", "memory": "83625" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\nListNode* reverse(ListNode* head) {\n if(head== NULL or head->next==NULL ) return head;\n ListNode* shead = reverse(head->next);\n\n head->next->next = head;\n\n head->next = NULL;\n\n return shead;\n\n\n\n }\n bool isPalindrome(ListNode* head) {\n if(head==NULL or head->next == NULL) return true;\n ListNode* slow = head;\n ListNode* fast = head;\n\n while(fast->next and fast->next->next ){\n fast = fast->next->next;\n slow = slow->next;\n }\n\n ListNode* newHead = reverse(slow->next);\n ListNode* t1 = head;\n ListNode* t2 = newHead;\n\n while(t2){\n if(t1->val != t2->val) {\n reverse(slow->next);\n return false;\n }\n t1 = t1->next;\n t2 = t2->next;\n\n\n }\n reverse(slow->next);\n return true;\n }\n};", "memory": "83625" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n ListNode *reverse(ListNode *head){\n if(head == NULL || head->next == NULL){\n return head;\n }\n ListNode *newHead = reverse(head->next);\n ListNode *front = head->next;\n front->next = head;\n head->next = NULL;\n return newHead;\n }\n bool isPalindrome(ListNode* head) {\n if(head == NULL || head->next == NULL){\n return true;\n }\n ListNode *slow = head;\n ListNode *fast = head;\n while(fast != NULL && fast->next!= NULL){\n slow = slow->next;\n fast = fast->next->next;\n }\n ListNode *newHead = reverse(slow);\n ListNode *first = head;\n ListNode *second = newHead;\n while(second != NULL){\n if(first->val != second->val){\n // reverse(newHead);\n return false;\n }\n first = first->next;\n second = second->next;\n }\n // reverse(newHead);\n return true;\n }\n};", "memory": "85215" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\nListNode* reverse(ListNode* head) {\n if(head== NULL or head->next==NULL) return head;\n ListNode* shead = reverse(head->next);\n\n head->next->next = head;\n\n head->next = NULL;\n\n return shead;\n\n\n\n }\n bool isPalindrome(ListNode* head) {\n ListNode* slow = head;\n ListNode* fast = head;\n\n while(fast and fast->next){\n fast = fast->next->next;\n slow = slow->next;\n }\n\n ListNode* newHead = reverse(slow);\n ListNode* t1 = head;\n ListNode* t2 = newHead;\n\n while(t1 and t2){\n if(t1->val != t2->val) return false;\n\n t1 = t1->next;\n t2 = t2->next;\n\n\n }\n return true;\n }\n};", "memory": "85215" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n\n ListNode* revers(ListNode* head)\n {\n if(head == NULL || head->next == NULL)\n return head;\n\n ListNode* temp = revers(head->next);\n ListNode* front = head->next;\n front->next = head;\n head->next = NULL;\n\n return temp;\n\n }\n\n bool isPalindrome(ListNode* head) {\n ListNode* slow = head,*fast = head;\n while(fast!=NULL && fast->next != NULL)\n {\n fast = fast->next->next;\n slow = slow->next;\n }\n\n ListNode* head2 = revers(slow);\n ListNode* head1 = head;\n\n while(head2 != NULL)\n {\n if(head1->val != head2->val)\n {\n return false;\n }\n head1=head1->next;\n head2=head2->next;\n }\n return true;\n }\n};", "memory": "86805" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n ListNode* reverseLL(ListNode* head){\n if(!head || !head->next) return head;\n ListNode* newHead = reverseLL(head->next);\n ListNode* front = head->next;\n front->next = head;\n head->next = nullptr;\n return newHead;\n }\n bool isPalindrome(ListNode* head) {\n if(!head || !head->next) return true;\n ListNode* slow = head;\n ListNode* fast = head->next;\n while(fast && fast->next){\n slow = slow->next;\n fast = fast->next->next;\n }\n ListNode* reversedHead = reverseLL(slow);\n ListNode* temp = head;\n\n while(temp){\n if(temp->val != reversedHead->val) return false;\n temp = temp->next;\n reversedHead = reversedHead->next;\n }\n return true;\n }\n};", "memory": "86805" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "#pragma GCC optimize(\"Ofast\")\n#pragma GCC target(\"avx2,bmi,bmi2,popcnt,lzcnt\")\n\nstatic const int FAST__ = [](){\n std::ios_base::sync_with_stdio(false);\n std::cin.tie(nullptr);\n std::cout.tie(nullptr);\n return 0;\n}();\n\n/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\n ListNode* reverseLinkedList(ListNode* head) {\n if (head == NULL || head->next == NULL) {\n return head; \n }\n\n ListNode* newHead = reverseLinkedList(head->next);\n ListNode* front = head->next;\n\n front->next = head;\n head->next = NULL;\n return newHead;\n }\n\npublic:\n bool isPalindrome(ListNode* head) {\n if (head == NULL || head->next == NULL) {\n return true; \n }\n\n ListNode* slow = head;\n ListNode* fast = head;\n while(fast->next != NULL && fast->next->next != NULL) {\n slow = slow->next;\n fast = fast->next->next;\n }\n\n ListNode* newHead = reverseLinkedList(slow->next);\n ListNode* first = head; \n ListNode* second = newHead;\n\n while (second != NULL) {\n if (first->val != second->val) {\n return false;\n }\n first = first->next; \n second = second->next; \n }\n\n return true;\n }\n};", "memory": "88395" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n ListNode* reverseList(ListNode* head) {\n ListNode* temp=head;\n ListNode* prev=NULL;\n while(head!=NULL && head->next!=NULL){\n temp=head->next;\n head->next=prev;\n prev=head;\n head=temp;\n\n }\n if(head!=NULL && head->next==NULL && prev!=NULL){\n head->next=prev;\n }\n\n return head;\n }\n bool isPalindrome(ListNode* head) {\n \n\n //optimal approach\n if (head == NULL || head->next == NULL) {\n return true;\n }\n\n ListNode* slow = head;\n ListNode* fast = head;\n stack<int> firstHalf;\n\n // Move fast pointer twice as fast as slow pointer\n // and push the first half values onto the stack\n while (fast != NULL && fast->next != NULL) {\n firstHalf.push(slow->val);\n slow = slow->next;\n fast = fast->next->next;\n }\n\n // If the list has an odd number of elements, skip the middle element\n if (fast != NULL) {\n slow = slow->next;\n }\n\n ListNode* head2=reverseList(slow);\n \n while(head && head2){\n if(head->val!=head2->val){\n return false;\n }\n head=head->next;\n head2=head2->next;\n }\n\n return true;\n\n }\n};", "memory": "89985" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n ListNode* findMiddle(ListNode* head) {\n if(!head || !head->next) return head;\n \n ListNode *slow = head, *fast = head;\n \n stack<int> firstHalf;\n \n while(fast && fast->next) {\n firstHalf.push(slow->val);\n \n slow = slow->next;\n fast = fast->next->next;\n }\n \n return slow;\n }\n \n ListNode* reverseList(ListNode* head) {\n if(!head || !head->next) return head;\n \n ListNode* newHead = nullptr;\n \n while(head) {\n ListNode* next = head->next;\n head->next = newHead;\n newHead = head;\n head = next;\n }\n \n return newHead;\n }\n \n bool isPalindrome(ListNode* head) {\n if(!head || !head->next) return true;\n \n ListNode *middle = findMiddle(head);\n ListNode *secondHalf = reverseList(middle);\n \n ListNode *firstHalf = head;\n \n while(secondHalf) {\n if(secondHalf->val != firstHalf->val) {\n return false;\n }\n \n secondHalf = secondHalf->next;\n firstHalf = firstHalf->next;\n }\n \n return true;\n }\n};", "memory": "91575" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n ListNode* reverse(ListNode* head) {\n ListNode* prev = NULL;\n ListNode* temp = head;\n \n while(temp){\n ListNode* front = temp->next;\n temp->next = prev;\n prev = temp;\n temp = front;\n\n }\n return prev;\n }\n bool isPalindrome(ListNode* head) {\n ListNode *slow = head, *fast = head, *first = head;\n while (fast->next && fast->next->next) {\n slow = slow->next;\n fast = fast->next->next;\n }\n ListNode* newHead = reverse(slow->next);\n ListNode* second = newHead;\n while(second){\n if(first->val != second->val){\n reverse(newHead);\n return false;\n }\n first = first->next;\n second = second->next;\n }\n return true;\n }\n};", "memory": "93165" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\nprivate:\n ListNode* findMid(ListNode* head){\n if(!head){\n return head;\n }\n ListNode* slow=head;\n ListNode* fast=head;\n while(fast!=NULL && fast->next!=NULL && fast->next->next!=NULL){\n fast=fast->next->next;\n slow=slow->next;\n }\n return slow;\n }\n\n\n ListNode* rev(ListNode* head){\n if(!head){\n return head;\n }\n ListNode* prev=NULL;\n ListNode* curr=head;\n ListNode* front=head->next;\n while(curr!=NULL && front!=NULL){\n curr->next=prev;\n prev=curr;\n curr=front;\n front=front->next;\n }\n curr->next=prev;\n return curr;\n }\n\n\npublic:\n bool isPalindrome(ListNode* head) {\n if(!head || !head->next){\n return true;\n }\n ListNode* start=head;\n ListNode* mid=findMid(head);\n ListNode* revHead=rev(mid->next);\n while(revHead!=NULL){\n if(revHead->val!=start->val){\n rev(revHead);\n return false;\n }\n start=start->next;\n revHead=revHead->next;\n } \n rev(revHead);\n return true;\n }\n};", "memory": "94755" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "// /**\n// * Definition for singly-linked list.\n// * struct ListNode {\n// * int val;\n// * ListNode *next;\n// * ListNode() : val(0), next(nullptr) {}\n// * ListNode(int x) : val(x), next(nullptr) {}\n// * ListNode(int x, ListNode *next) : val(x), next(next) {}\n// * };\n// */\n// class Solution {\n// public:\n\n\n// bool isPalindrome(ListNode* head) {\n// // vector<int> ls ;\n// // ListNode* temp = head;\n// // while(temp!= NULL){\n// // ls.push_back(temp->val);\n// // temp = temp->next;\n// // }\n// // int left = 0;\n// // int right = ls.size()-1;\n// // while(left< right && ls[left] == ls[right] ){\n// // left++;\n// // right --;\n// // }\n// // return left>= right;\n\n \n// // }\n// };\nclass Solution {\npublic:\n ListNode* reverse(ListNode* head) {\n ListNode* prev = nullptr;\n ListNode* curr = head;\n while (curr != nullptr) {\n ListNode* next = curr->next;\n curr->next = prev;\n prev = curr;\n curr = next;\n }\n return prev;\n }\n \n bool isPalindrome(ListNode* head) {\n ListNode* slow = head;\n ListNode* fast = head;\n if(head== NULL || head->next == NULL){\n return true;\n }\n while (fast->next!= nullptr && fast->next->next != nullptr) {\n slow = slow->next;\n fast = fast->next->next;\n }\n ListNode* rev = reverse(slow->next);\n while (rev != nullptr) {\n if (head->val != rev->val) {\n reverse(rev);\n return false;\n }\n head = head->next;\n rev = rev->next;\n }\n reverse(rev);\n return true;\n }\n};", "memory": "94755" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n bool isPalindrome(ListNode* head) {\n if (head == nullptr)\n return false;\n\n ListNode* revHead = reverse(middleNode(head));\n\n bool palindrome = true;\n while(head != nullptr && revHead != nullptr) {\n if (head->val != revHead->val){\n palindrome = false;\n break;\n } \n\n head = head->next;\n revHead = revHead->next;\n }\n\n reverse(revHead);\n return palindrome;\n }\n\nprivate:\n ListNode* middleNode(ListNode* head) {\n if (head == nullptr)\n return nullptr;\n\n ListNode* slow = head;\n ListNode* fast = head;\n\n while (fast != nullptr && fast->next != nullptr) {\n slow = slow->next;\n fast = fast->next->next;\n }\n\n return slow;\n }\n\n ListNode* reverse(ListNode* head) {\n if (head == nullptr)\n return nullptr;\n\n ListNode* prev = nullptr;\n ListNode* curr = head;\n\n while (curr != nullptr) {\n ListNode* next = curr->next;\n curr->next = prev;\n prev = curr;\n curr = next;\n }\n\n return prev;\n }\n};\n", "memory": "96345" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n ListNode*reversell(ListNode*head){\n if(head==NULL || head->next==nullptr){\n return head;\n }\n ListNode* newhead = reversell(head->next);\n ListNode*front = head->next;\n front->next=head;\n head->next =NULL;\n return newhead;\n }\n bool isPalindrome(ListNode* head) {\n if(head==NULL || head->next==nullptr){\n return true;\n }\n ListNode*slow = head;\n ListNode*fast = head;\n ListNode*prev = head;\n while(fast->next != NULL && fast->next->next != NULL){\n slow=slow->next;\n prev=slow;\n fast=fast->next->next;\n } \n ListNode*newhead = reversell(prev->next);\n prev->next=newhead;\n ListNode*first = head;\n ListNode*second = newhead;\n while(second!=NULL){\n if(first->val!=second->val){\n reversell(newhead);\n return false;\n \n }\n second=second->next;\n first=first->next;\n \n \n }return true;\n reversell(newhead);\n }\n};", "memory": "97935" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n ListNode*reversell(ListNode*head){\n if(head==NULL || head->next==nullptr){\n return head;\n }\n ListNode* newhead = reversell(head->next);\n ListNode*front = head->next;\n front->next=head;\n head->next =NULL;\n return newhead;\n }\n bool isPalindrome(ListNode* head) {\n if(head==NULL || head->next==nullptr){\n return true;\n }\n ListNode*slow = head;\n ListNode*fast = head;\n ListNode*prev = head;\n while(fast->next != nullptr && fast->next->next != nullptr){\n slow=slow->next;\n prev=slow;\n fast=fast->next->next;\n } \n ListNode*newhead = reversell(prev->next);\n prev->next=newhead;\n ListNode*first = head;\n ListNode*second = newhead;\n while(second!=NULL){\n if(first->val!=second->val){\n reversell(newhead);\n return false;\n \n }\n second=second->next;\n first=first->next;\n \n \n }return true;\n reversell(newhead);\n }\n};", "memory": "99525" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n ListNode* reverseLL(ListNode* head){\n if (head==NULL || head->next==NULL)\n return head;\n ListNode *newhead = reverseLL(head->next);\n ListNode *temp = head->next;\n temp->next = head;\n head->next = NULL;\n return newhead;\n }\n bool isPalindrome(ListNode* head) {\n ios::sync_with_stdio(false);\n ListNode *slow = head;\n ListNode *fast = head;\n \n //finding mid of LL\n while(fast->next && fast->next->next){\n slow = slow->next;\n fast = fast->next->next;\n }\n //reverse the 2nd half of LL\n ListNode *newhead = reverseLL(slow->next);\n slow = head;\n fast = newhead;\n //match both halves\n while(fast){\n if (slow->val != fast->val)\n return false;\n slow = slow->next;\n fast = fast->next;\n }\n newhead = reverseLL(newhead);\n return true;\n }\n};", "memory": "101115" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n bool isPalindrome(ListNode* head) {\n string s, t;\n ListNode* temp = head;\n while (temp != nullptr) {\n s+=to_string(temp->val);\n temp = temp->next;\n }\n // cout << s;\n ListNode* prev = nullptr;\n ListNode* next = nullptr;\n ListNode* curr = head;\n while (curr != nullptr) {\n next = curr->next;\n curr->next = prev;\n prev = curr;\n curr = next;\n }\n head = prev;\n ListNode* temp2 = head;\n while (temp2 != nullptr) {\n t += to_string(temp2->val);\n temp2 = temp2->next;\n }\n if (s == t) {\n return true;\n }\n return false;\n }\n};", "memory": "102705" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n ListNode* reverseLL(ListNode* temp){\n ListNode* prev=NULL;\n ListNode* curr=temp;\n while(curr!=NULL){\n ListNode* front=curr->next;\n curr->next=prev;\n prev=curr;\n curr=front;\n }return prev;\n }\n bool isPalindrome(ListNode* head) {\n ListNode* slow=head;\n ListNode* fast=head;\n while(fast->next!=NULL && fast->next->next!=NULL){\n slow=slow->next;\n fast=fast->next->next;\n }ListNode* newHead=reverseLL(slow->next);\n ListNode* temp1=head;\n ListNode* temp2=newHead;\n bool flag=true;\n while(temp2){\n if(temp1->val != temp2->val){\n flag=false;\n break;\n }temp1=temp1->next;\n temp2=temp2->next;\n }ListNode* tail=reverseLL(newHead);\n return flag;\n }\n};", "memory": "104295" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n ListNode* midEle(ListNode*head)\n {\n ListNode*s=head;\n ListNode*f=head;\n while(f->next!=NULL && f->next->next!=NULL)\n {\n s=s->next;\n f=f->next->next;\n }\n return s;\n }\n ListNode* reverse(ListNode* head)\n {\n ListNode*curr=head;\n ListNode*prev=NULL;\n ListNode* next;\n while(curr!=NULL)\n {\n next=curr->next;\n curr->next=prev;\n prev=curr;\n curr=next;\n }\n return prev;\n }\n bool isPalindrome(ListNode* head) {\n ListNode* mid=midEle(head);\n ListNode* nh=reverse(mid->next);\n ListNode*p=head;\n ListNode*q=nh;\n while(q!=NULL)\n {\n if(p->val!=q->val)\n {\n mid->next=reverse(nh);\n return false;\n }\n p=p->next;\n q=q->next;\n }\n mid->next=reverse(nh);\n return true;\n\n }\n};", "memory": "105885" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

1

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n ListNode* findMiddle(ListNode* head)\n {\n ListNode*fast=head->next;\n ListNode*slow=head;\n while(fast!=NULL&& fast->next!=NULL)\n {\n slow=slow->next;\n fast=fast->next->next;\n }\n return slow;\n }\n ListNode* reverse(ListNode*head)\n {\n ListNode*curr=head;\n ListNode*prev=NULL;\n ListNode*forward=NULL;\n while(curr!=NULL)\n {\n forward=curr->next;\n curr->next=prev;\n prev=curr;\n curr=forward;\n }\n return prev;\n }\n bool isPalindrome(ListNode* head) {\n if(head->next==NULL)return true;\n ListNode*middle=findMiddle(head);\n ListNode* temp=middle->next;\n middle->next= reverse(temp);\n ListNode*head1=head;\n ListNode*head2=middle->next;\n while(head2!=NULL)\n {\n if(head1->val!=head2->val)\n {\n return false;\n }\n head1=head1->next;\n head2=head2->next;\n }\n return true;\n\n }\n};", "memory": "105885" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

2

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n int length(ListNode* head){\n int cnt=0;\n ListNode* temp=head ;\n while(temp!=NULL){\n temp=temp->next;\n cnt++;\n }\n return cnt;\n }\n bool isPalindrome(ListNode* head) {\n //step 1 - array banao\n // strep2 LL ko array me copy karo \n // setp3 array agr palindrome hai to LL bhi hai\n int n= length(head);\n int arr[n];\n ListNode* temp=head ;\n for(int i=0;i<n;i++){\n arr[i]=temp->val;\n temp=temp->next;\n }\n\n // arr ban gaya ab bas array palindrome hai ki nhi vo check karlo\n int s=0;\n int e= n-1;\n while(s<e){\n if(arr[s]!=arr[e]) return false;\n s++;\n e--;\n }\n return true;\n\n }\n};", "memory": "113835" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

2

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n bool isPalindrome(ListNode* head) {\n int length = 0;\n ListNode *temp = head;\n while (temp != nullptr)\n {\n length++;\n temp = temp->next;\n }\n temp = head;\n int arr[length];\n for (int i = 0; i < length; i++)\n {\n arr[i] = temp->val;\n temp = temp -> next; \n }\n if (length == 0)\n {\n return true;\n }\n for (int i = 0; i < (int) length/2; i++)\n {\n if (arr[i] == arr[length - i - 1])\n {\n continue;\n }\n else\n {\n return false;\n }\n }\n return true;\n }\n};", "memory": "115425" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

2

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n bool isPalindrome(ListNode* head) {\n ListNode* temp = head;\n int count = 0;\n while(temp != NULL)\n {\n count++;\n temp = temp->next;\n }\n int arr[count];\n temp = head;\n for(int i = 0; i < count; i++)\n {\n arr[i] = temp->val;\n temp = temp->next;\n }\n for(int i = 0; i < count/2 ; i++)\n {\n if(arr[i] != arr[count - i - 1])\n {\n return false;\n }\n }\n return true;\n // ListNode* current, *prev, *next;\n // current = head;\n // prev = NULL;\n // while(current != NULL)\n // {\n // current = current->next;\n // current->next = prev;\n // current = next;\n // }\n // head = prev;\n\n }\n};", "memory": "117015" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

2

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n bool isPalindrome(ListNode* head) {\n int arr[100000];\n int k=0;\n ListNode* temp=head;\n while(temp!=NULL){\n arr[k++]=temp->val;\n temp=temp->next;\n }\n int flag=0;\n for(int i=0;i<k/2;i++){\n if(arr[i]!=arr[k-1-i]){\n flag=1;\n break;\n }\n }\n if(flag==0){\n return true;\n }else{\n return false;\n }\n }\n};", "memory": "117015" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

2

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n bool isPalindrome(ListNode* head) {\n ListNode *first=head;\n ListNode *last=head;\n int count=1;\n if(head==NULL){\n return false;\n }\n while (last->next!=NULL){\n last=last->next;\n count++;\n } \n int arr[count];\n ListNode *curr=head;\n int i=0;\n while(curr!=NULL){\n arr[i]= curr->val;\n i++;\n curr=curr->next;\n } \n for(int j=0,co=count-1;j<co;co--,j++){\n if(arr[j]!=arr[co]){\n return false;\n }\n }\n return true;\n \n }\n};", "memory": "118605" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

2

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n bool isPalindrome(ListNode* head) {\n if ( head == NULL || head -> next == NULL ) {\n return true;\n }\n ListNode* temp = head;\n int count = 0;\n int arr[1000000] ;\n while ( temp != NULL ) {\n arr[count] = temp -> val;\n count++;\n temp = temp -> next;\n }\n\n int s = 0 , e = count-1;\n while ( s <= e ) {\n if ( arr[s] != arr[e] ) {\n return false;\n }\n s++ , e-- ;\n }\n return true;\n }\n};", "memory": "120195" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

2

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n bool isPalindrome(ListNode* head) {\n ListNode* temp = head;\n \n // Calculate the length of the linked list\n int count = 0;\n while (temp) {\n count++;\n temp = temp->next;\n }\n \n // Reset temp to head and declare arrays\n temp = head;\n int arr[count]; \n int reverse[count];\n \n // Traverse the list and store the values in the array\n int i = 0;\n while (temp) {\n arr[i] = temp->val;\n i++;\n temp = temp->next;\n }\n \n // Traverse again from the end and store the values in reverse array\n temp = head;\n i = count - 1;\n while (temp) {\n reverse[i] = temp->val;\n i--;\n temp = temp->next;\n }\n \n // Compare the arrays to check if the linked list is a palindrome\n for (int i = 0; i < count; i++) {\n if (arr[i] != reverse[i])\n return false;\n }\n \n return true;\n }\n};", "memory": "121785" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

2

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n bool isPalindrome(ListNode* head) {\n ListNode* temp=head;\n int arr[1000000];\n int i=0;\n while(temp){\n arr[i]=temp->val;\n i++;\n temp=temp->next;\n }\n int t=0,k=--i;\n while(t<=k){\n if(arr[t]!=arr[k])return false;\n t++;k--;\n } \n return true;\n }\n\n};", "memory": "121785" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

2

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListListListNode {\n * int val;\n * ListListListNode *next;\n * ListListNode() : val(0), next(nullptr) {}\n * ListListNode(int x) : val(x), next(nullptr) {}\n * ListListNode(int x, ListListNode *next) : val(x), next(next) {}\n * };\n */\n \n\nclass Solution {\npublic:\nListNode* reverseLinkedList(ListNode* head) {\n if (head == NULL || head->next == NULL) return head; \n ListNode* newHead = reverseLinkedList(head->next);\n head->next->next = head;\n head->next = NULL;\n return newHead;\n}\n bool isPalindrome(ListNode* head) {\n if (head == NULL || head->next == NULL) return true;\n\n ListNode* slow = head;\n ListNode* fast = head;\n\n // Move slow to the middle and fast to the end\n while (fast->next != NULL && fast->next->next != NULL) {\n slow = slow->next;\n fast = fast->next->next;\n }\n\n // Reverse the second half of the list\n ListNode* newHead = reverseLinkedList(slow->next);\n ListNode* first = head;\n ListNode* second = newHead;\n\n // Compare the two halves\n while (second != NULL) {\n if (first->val != second->val) {\n reverseLinkedList(newHead); // Reverse back the second half\n return false;\n }\n first = first->next;\n second = second->next;\n }\n\n // Restore the list to its original form\n reverseLinkedList(newHead);\n\n return true;\n }\n};", "memory": "123375" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

2

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n\nListNode* reverseList(ListNode* head) {\n if(head==NULL || head->next==NULL)return head;\n ListNode* newHead = reverseList(head->next);\n ListNode* front = head->next;\n front->next = head;\n head->next = NULL;\n return newHead;\n }\n bool isPalindrome(ListNode* head) {\n ListNode* slow = head;\n ListNode* fast = head;\n while(fast->next != NULL && fast->next->next != NULL){\n slow = slow->next;\n fast = fast->next->next;\n }\n\n ListNode* newHead = reverseList(slow->next);\n ListNode* first = head;\n ListNode* second = newHead;\n while(second != NULL ){\n if(first->val != second->val){\n reverseList(newHead);\n return false;\n }first = first->next;\n second = second->next;\n }\n reverseList(newHead);\n return true;\n }\n};", "memory": "123375" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

2

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n bool isPalindrome(ListNode* head) {\n ListNode* slow = head;\n ListNode* fast = head;\n int count = 0;\n bool answer = true;\n bool check = false;\n std::string palindrome = \"\";\n while (fast != nullptr) {\n palindrome.append(std::to_string(slow->val));\n slow = slow->next;\n if (fast->next != nullptr) {\n fast = fast->next;\n fast = fast->next;\n } else {\n check = true;\n fast = fast->next;\n }\n }\n if (check) {\n palindrome.pop_back(); \n }\n count = palindrome.length();\n \n \n \n cout << palindrome;\n while (slow != nullptr) {\n //cout << palindrome[count - 1] << endl;\n //std::string char_as_str(1, palindrome[count - 1]); \n if (slow->val != std::stoi(std::string(1, palindrome[count - 1]))) {\n\n answer = false;\n }\n \n slow = slow->next;\n count -= 1;\n }\n \n return answer;\n }\n};", "memory": "124965" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

2

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n bool isPalindromestring(string s)\n {\n int i=0,j=s.length()-1;\n while(i<=j)\n {\n if(s[i]!=s[j])\n return false;\n i++;j--;\n }\n return true;\n\n }\n bool isPalindrome(ListNode* head) {\n ListNode* curr=head;\n string s;\n while(curr)\n {\n s.push_back(curr->val);\n curr=curr->next;\n }\n return isPalindromestring(s);\n }\n};", "memory": "124965" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

2

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n bool isPalindrome(ListNode* head) {\n stack<int>st; \n ListNode* curr = head; \n while(curr!= NULL){\n st.push(curr->val);\n curr = curr->next;\n }\n curr = head; \n while(curr!=NULL && curr->val == st.top()){\n st.pop(); \n curr = curr->next;\n }\n return curr == NULL;\n }\n};", "memory": "126555" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

2

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n bool isPalindrome(ListNode* head) {\n stack<int> stack;\n ListNode *current =head;\n\n while(current)\n {\n stack.push(current->val);\n current= current->next;\n\n }\n current=head;\n while(current&& current->val == stack.top())\n {\n stack.pop();\n current=current->next;\n }\nreturn current == nullptr;\n }\n};", "memory": "126555" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

3

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n int len(ListNode* head){\n if(!head) return 0;\n\n return 1 + len(head->next);\n }\n\n bool isPalindrome(ListNode* head) {\n int t = len(head);\n\n if(t==1){\n return true;\n }\n\n vector<int>temp;\n\n int i;\n\n for(i=0;i<t/2;i++){\n temp.push_back(head->val);\n head = head->next;\n }\n\n if(t%2){\n head = head->next;\n i++;\n }\n\n int j = temp.size();\n\n while(i<t){\n if(head->val == temp[j-1]){\n head = head->next;\n j--;\n i++;\n }\n else{\n return false;\n }\n }\n\n return true;\n }\n};", "memory": "128145" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

3

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n bool isPalindrome(ListNode* head) {\n string check = \"\";\n while(head!=nullptr){\n check += to_string(head->val);\n head=head->next;\n }\n\n string first = check;\n reverse(check.begin(),check.end());\n string second = check;\n\n if (first == second) return true;\n return false;\n }\n};", "memory": "128145" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

3

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n\tstring normal, reverse;\n bool isPalindrome(ListNode* head) {\n goNormal(head);\n goReverse(head);\n return (normal == reverse);\n }\n \n void goNormal(ListNode* current) {\n \tif(!current) return;\n \tnormal.push_back(current->val);\n \tgoNormal(current->next);\n\t}\n \n void goReverse(ListNode* current) {\n \tif(!current) return;\n \tgoReverse(current->next);\n \treverse.push_back(current->val);\n\t}\n};", "memory": "129735" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

3

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n int length(ListNode* head){\n ListNode* temp = head;\n int len = 0;\n while(temp != NULL){\n len++;\n temp = temp->next;\n }\n return len;\n }\n\n bool isReverse(vector<int> arr,int n){\n int s = 0;\n int e = n-1;\n\n while(s<e){\n if(arr[s]==arr[e]){\n s++;\n e--;\n }\n else{\n return false;\n }\n }\n return true;\n }\n bool isPalindrome(ListNode* head) {\n int n = length(head);\n\n vector<int> arr(n,0);\n\n ListNode* curr = head;\n int i = 0;\n while(curr != NULL){\n arr[i] = curr->val;\n i++;\n curr = curr->next;\n }\n\n return isReverse(arr,n);\n }\n};", "memory": "129735" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

3

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n bool isPalindrome(ListNode* head) {\n vector<int>arr;\n ListNode*temp=head;\n bool p=1;\n while(temp!=nullptr){\n arr.push_back(temp->val);\n temp=temp->next;\n }\n int n=arr.size();\n int fast=n-1;\n for(int i=0;i<=n/2;i++){\n if(arr[i]==arr[fast]){\n fast--;\n }\n else{\n p=0;\n break;\n }\n }\n return p;\n }\n};", "memory": "131325" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

3

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n bool isPalindrome(ListNode* head) {\n vector<int> num;\n auto current = head;\n while(current !=nullptr) {\n num.push_back(current->val);\n current = current->next;\n }\n int size = num.size() - 1;\n for(int i = 0 ; i < num.size()/2 ; ++i) {\n if(num[i] != num[size-i]) {\n return false;\n }\n }\n return true;\n \n }\n};", "memory": "131325" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

3

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\nprivate:\n bool _isPalindrome(ListNode* h, queue<int>& storage) {\n if (h->next == nullptr) {\n storage.push(h->val);\n if ((storage.front() == h->val)) {\n storage.pop();\n return true;\n } else {\n storage.pop();\n return false;\n }\n }\n storage.push(h->val);\n auto future_ans =\n _isPalindrome(h->next, storage); // with storage filled\n bool status = future_ans && (storage.front() == h->val);\n storage.pop();\n return status;\n }\n\npublic:\n bool isPalindrome(ListNode* head) {\n queue<int> q;\n return _isPalindrome(head, q);\n }\n};", "memory": "132915" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

3

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n void recursion(ListNode*head,string &start,string &end){\n if(head==nullptr){\n return ;\n }\n start+=head->val;\n recursion(head->next,start,end);\n end+=head->val;\n }\n bool isPalindrome(ListNode* head) {\n string start=\"\",end=\"\";\n recursion(head,start,end);\n return start==end;\n }\n};", "memory": "132915" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

3

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\nvector<int>c;\nint f=0;\nvoid shit(ListNode* start){\n if(start==NULL){\n return;\n }\n c.push_back(start->val);\n \n shit(start->next);\n if(c[f]==start->val){\n f++;\n }\n\n}\n bool isPalindrome(ListNode* head) {\n shit(head);\n \n return f==c.size();\n }\n};", "memory": "134505" }

234

Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome or <code>false</code> otherwise.   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" /> <pre> Input: head = [1,2,2,1] Output: true </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" /> <pre> Input: head = [1,2] Output: false </pre>   Constraints: <ul> <li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li> <li><code>0 <= Node.val <= 9</code></li> </ul>   Follow up: Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?

3

{ "code": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\nprivate:\n void reverse(vector<int>& rev, ListNode* head){\n if(head==NULL){\n return;\n }\n reverse(rev, head-> next);\n rev.push_back(head -> val);\n }\n\n \npublic:\n bool isPalindrome(ListNode* head) {\n vector<int> rev; \n reverse(rev, head);\n int size = rev.size();\n int index = 0;\n while(head!=NULL && index < size){\n if(rev[index] != head -> val){\n return false;\n }\n index++;\n head = head -> next;\n }\n return true;\n }\n};", "memory": "134505" }

235

Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 Output: 6 Explanation: The LCA of nodes 2 and 8 is 6. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 Output: 2 Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [2,1], p = 2, q = 1 Output: 2 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == NULL) return NULL;\n root->left = lowestCommonAncestor(root->left, p, q);\n root->right = lowestCommonAncestor(root->right, p, q);\n if(root->val == p->val || root->val == q->val) return root;\n if(root->left && root->right) return root;\n return root->left == NULL ? root -> right : root -> left;\n }\n};", "memory": "14200" }

235

Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 Output: 6 Explanation: The LCA of nodes 2 and 8 is 6. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 Output: 2 Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [2,1], p = 2, q = 1 Output: 2 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\n\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if (root == NULL || root == p || root == q)\n return root;\n root->left = lowestCommonAncestor(root->left, p, q);\n root->right = lowestCommonAncestor(root->right, p, q);\n\n if (root->left != NULL && root->right != NULL)\n return root;\n else if (root->left != NULL)\n return root->left;\n else\n return root->right;\n }\n};", "memory": "14300" }

235

Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 Output: 6 Explanation: The LCA of nodes 2 and 8 is 6. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 Output: 2 Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [2,1], p = 2, q = 1 Output: 2 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\n\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n vector<TreeNode*> cur_path;\n TreeNode* ancestor = nullptr;\n\n stack<TreeNode*> dfs;\n dfs.push(root);\n while (!dfs.empty()) {\n TreeNode* cur_node = dfs.top();\n\n if (!cur_node) {\n dfs.pop();\n continue;\n }\n if (!cur_path.empty() && (cur_node == cur_path.back())) {\n cur_path.pop_back();\n dfs.pop();\n if (cur_node == ancestor) {\n ancestor = cur_path.back();\n }\n continue;\n }\n\n cur_path.push_back(cur_node);\n\n if ((cur_node == p) || (cur_node == q)) {\n if (ancestor) {\n break;\n }\n ancestor = cur_node;\n }\n\n dfs.push(cur_node->left);\n dfs.push(cur_node->right);\n cur_node->left = cur_node->right = nullptr;\n }\n\n return ancestor;\n }\n};", "memory": "14400" }

235

Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 Output: 6 Explanation: The LCA of nodes 2 and 8 is 6. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 Output: 2 Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [2,1], p = 2, q = 1 Output: 2 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\n\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root==NULL){\n return NULL;\n }\n if(root==p || root==q){\n return root;\n }\n root->left=lowestCommonAncestor(root->left,p,q);\n root->right=lowestCommonAncestor(root->right,p,q);\n\n if(root->right!=NULL && root->left!=NULL){\n return root;\n }\n else if(root->right!=NULL && root->left==NULL){\n return root->right;\n }\n else if(root->right==NULL && root->left!=NULL){\n return root->left;\n }\n else{\n return NULL;\n }\n }\n};", "memory": "14500" }

235

Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 Output: 6 Explanation: The LCA of nodes 2 and 8 is 6. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 Output: 2 Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [2,1], p = 2, q = 1 Output: 2 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\n\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n return solve(root,p,q);\n \n }\n TreeNode* solve(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root==NULL) return NULL;\n if(root->val ==p->val || root->val ==q->val) return root;\n root->right=solve(root->right,p,q);\n root->left=solve(root->left,p,q);\n if(root->left!=NULL && root->right!=NULL) return root;\n if(root->left==NULL) return root->right;\n return root->left;\n \n }\n};", "memory": "14600" }

235

Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 Output: 6 Explanation: The LCA of nodes 2 and 8 is 6. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 Output: 2 Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [2,1], p = 2, q = 1 Output: 2 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\n\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n TreeNode * temp = root;\n while(temp){\n if(temp->val > p->val && temp->val > q->val) temp = temp->left;\n if(temp->val < p->val && temp->val < q->val) temp = temp->right;\n\n if((temp->val > p->val && temp->val < q->val) || (temp->val < p->val && temp->val > q->val)){\n temp->left = NULL;\n temp->right = NULL;\n return temp;\n }\n if(temp->val == p->val || temp->val == q->val){\n temp->left = NULL;\n temp->right = NULL;\n return temp;\n }\n }\n return NULL;\n }\n};", "memory": "19300" }

235

Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 Output: 6 Explanation: The LCA of nodes 2 and 8 is 6. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 Output: 2 Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [2,1], p = 2, q = 1 Output: 2 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\n\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == p || q == root)\n return root;\n \n if(root==NULL){\n return NULL;\n }\n if ((root -> val > p -> val) && (root -> val > q -> val)) {\n return lowestCommonAncestor(root -> left, p, q);\n }\n else if ((root -> val val) && (root -> val < q -> val)) {\n return lowestCommonAncestor(root -> right, p, q);\n }\n root->left = root->right = nullptr;\n return root;\n }\n};", "memory": "19400" }

235

Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 Output: 6 Explanation: The LCA of nodes 2 and 8 is 6. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 Output: 2 Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [2,1], p = 2, q = 1 Output: 2 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\n\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root==NULL){ \n return root;\n }\n root->left=lowestCommonAncestor(root->left, p,q); \n root->right=lowestCommonAncestor(root->right, p,q);\n\n if(p->val < root->val && q->val < root->val){\n return root->left;\n }\n if(p->val > root->val && q->val > root->val){\n return root->right;\n }\n return root;\n\n \n }\n};", "memory": "20700" }

235

Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 Output: 6 Explanation: The LCA of nodes 2 and 8 is 6. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 Output: 2 Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [2,1], p = 2, q = 1 Output: 2 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\n\nclass Solution {\npublic:\n TreeNode *val(TreeNode *r,TreeNode *p,TreeNode *q)\n { \n if (r)\n {\n if (r->val==p->val) return r;\n if (r->val==q->val) return r;\n if (!r->left && !r->right) return NULL;\n TreeNode *l=val(r->left,p,q);\n TreeNode *t=val(r->right,p,q);\n if (l && t) return r;\n if (!l && t) return t;\n if (l && !t) return l;\n }\n return NULL;\n }\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n return val(root,p,q);\n }\n};", "memory": "21700" }

235

Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 Output: 6 Explanation: The LCA of nodes 2 and 8 is 6. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 Output: 2 Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [2,1], p = 2, q = 1 Output: 2 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\n\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root==nullptr)return root;\n if(root->val < p->val && root->val < q->val) return lowestCommonAncestor(root->right,p,q);\n if(root->val > p->val && root->val > q->val) return lowestCommonAncestor(root->left,p,q);\n return root;\n }\n};", "memory": "21800" }

235

Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 Output: 6 Explanation: The LCA of nodes 2 and 8 is 6. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 Output: 2 Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [2,1], p = 2, q = 1 Output: 2 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\n\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n //if the current root is greater than both\n if(root -> val > p -> val && root -> val > q->val)\n return lowestCommonAncestor(root -> left, p, q);\n \n if(root -> val val && root -> val < q->val)\n return lowestCommonAncestor(root -> right, p,q);\n \n return root;\n }\n};", "memory": "21800" }

235

Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 Output: 6 Explanation: The LCA of nodes 2 and 8 is 6. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 Output: 2 Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [2,1], p = 2, q = 1 Output: 2 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\n\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == NULL){\n return root;\n }\n else if((p->val > root->val && q->val < root->val) || (p->val < root-> val && q->val > root->val)){\n return root;\n }else if(p->val > root->val && q->val > root->val){\n return lowestCommonAncestor(root->right, p, q);\n }else if(p->val < root->val && q->val < root->val){\n return lowestCommonAncestor(root->left, p, q);\n }else if(p->val == root->val){\n return p;\n }else{\n return q;\n }\n }\n};", "memory": "21900" }

235

Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 Output: 6 Explanation: The LCA of nodes 2 and 8 is 6. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 Output: 2 Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [2,1], p = 2, q = 1 Output: 2 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\n\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if (root == NULL) return root;\n else if (p->val < root->val && q->val < root->val) return lowestCommonAncestor(root->left, p,q);\n else if (p->val > root->val && q->val > root->val) return lowestCommonAncestor(root->right, p,q);\n return root;\n }\n};", "memory": "21900" }

235

Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 Output: 6 Explanation: The LCA of nodes 2 and 8 is 6. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 Output: 2 Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [2,1], p = 2, q = 1 Output: 2 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\n\nclass Solution {\npublic:\n TreeNode* f(TreeNode* root, TreeNode* p, TreeNode* q){\n\n if(root==p || root==q)return root;\n\n int cur= root->val;\n if(cur >p->val && cur >q->val)return f(root->left,p,q); \n if(cur <p->val && cur <q->val)return f(root->right,p,q);\n \n return root;\n }\n\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q){\n return f(root,p,q);\n }\n};", "memory": "22000" }

235

Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 Output: 6 Explanation: The LCA of nodes 2 and 8 is 6. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 Output: 2 Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [2,1], p = 2, q = 1 Output: 2 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\n\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n\n if(!root) return NULL;\n\n if(root->val > p->val && root->val > q->val)\n return lowestCommonAncestor(root->left, p, q);\n\n else if(root->val < p->val && root->val < q->val)\n return lowestCommonAncestor(root->right, p, q);\n\n return root; \n }\n};", "memory": "22000" }

235

Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 Output: 6 Explanation: The LCA of nodes 2 and 8 is 6. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 Output: 2 Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [2,1], p = 2, q = 1 Output: 2 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>

1

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\n\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(!root)\n return nullptr;\n if(root == p || root == q)\n {\n return root;\n }\n bool r = find(root->right, p, q);\n bool l = find(root->left, p, q);\n if(r && l)\n return root;\n if (r)\n return lowestCommonAncestor(root->right, p, q);\n return lowestCommonAncestor(root->left, p, q);\n \n }\n bool find(TreeNode* root, TreeNode* p, TreeNode* q){\n if(!root)\n return false;\n if(root == p || root == q)\n return true;\n else\n return find(root->right, p, q) || find(root->left, p, q);\n }\n};", "memory": "22100" }

235

Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 Output: 6 Explanation: The LCA of nodes 2 and 8 is 6. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 Output: 2 Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [2,1], p = 2, q = 1 Output: 2 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the BST.</li> </ul>

1

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\n\nclass Solution {\npublic:\n\nTreeNode * findLCA(TreeNode * root , TreeNode * p , TreeNode * q)\n{\n if(root == NULL) return NULL;\n if(root->val == p->val || root->val == q->val) return root;\n\n if(p->val < root->val && q->val < root->val )\n return findLCA(root->left , p ,q);\n else if ( p ->val > root->val && q->val > root->val)\n return findLCA(root->right , p ,q);\n else\n return root;\n\n}\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n \n if(root == NULL) return nullptr;\n\n return findLCA(root , p , q);\n\n }\n};", "memory": "22100" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == p || root == q){\n return root;\n }\n if(root->left){\n root->left = lowestCommonAncestor(root->left, p, q);\n }\n if(root->right){\n root->right = lowestCommonAncestor(root->right, p, q);\n }\n if(root->left){\n if(root->right){\n return root;\n }\n else{\n return root->left;\n }\n }\n else{\n return root->right;\n }\n }\n};", "memory": "13200" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == p || root == q){\n return root;\n }\n if(root->left){\n root->left = lowestCommonAncestor(root->left, p, q);\n }\n if(root->right){\n root->right = lowestCommonAncestor(root->right, p, q);\n }\n if(root->left && root->right){\n return root;\n }\n else if(!root->left){\n return root->right;\n }\n else{\n return root->left;\n }\n }\n};", "memory": "13300" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\n class Solution {\n public:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root==NULL)\n return NULL;\n root->left = lowestCommonAncestor(root->left,p,q);\n root->right = lowestCommonAncestor(root->right,p,q);\n if(root->val==p->val || root->val==q->val)\n return root;\n if(root->left && root->right)\n return root;\n return root->left==NULL ? root->right : root->left;\n }\n };", "memory": "13300" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == p || root == q){\n return root;\n }\n if(root->left){\n root->left = lowestCommonAncestor(root->left, p, q);\n }\n if(root->right){\n root->right = lowestCommonAncestor(root->right, p, q);\n }\n if(root->left && root->right){\n return root;\n }\n else if(!root->left){\n return root->right;\n }\n else{\n return root->left;\n }\n }\n};", "memory": "13400" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == p || root == q){\n return root;\n }\n if(root->left){\n root->left = lowestCommonAncestor(root->left, p, q);\n }\n if(root->right){\n root->right = lowestCommonAncestor(root->right, p, q);\n }\n if(root->left){\n if(root->right){\n return root;\n }\n else{\n return root->left;\n }\n }\n else{\n return root->right;\n }\n }\n};", "memory": "13400" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == p || root == q){\n return root;\n }\n if(root->left){\n root->left = lowestCommonAncestor(root->left, p, q);\n }\n if(root->right){\n root->right = lowestCommonAncestor(root->right, p, q);\n }\n if(root->left){\n if(root->right){\n return root;\n }\n else{\n return root->left;\n }\n }\n else{\n return root->right;\n }\n }\n};", "memory": "13500" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == p || root == q){\n return root;\n }\n if(root->left){\n root->left = lowestCommonAncestor(root->left, p, q);\n }\n if(root->right){\n root->right = lowestCommonAncestor(root->right, p, q);\n }\n if(root->left){\n if(root->right){\n return root;\n }\n else{\n return root->left;\n }\n }\n else{\n return root->right;\n }\n }\n};", "memory": "13500" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == p || root == q){\n return root;\n }\n if(root->left){\n root->left = lowestCommonAncestor(root->left, p, q);\n }\n if(root->right){\n root->right = lowestCommonAncestor(root->right, p, q);\n }\n if(root->left && root->right){\n return root;\n }\n else if(!root->left){\n return root->right;\n }\n else{\n return root->left;\n }\n }\n};", "memory": "13600" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == p || root == q){\n return root;\n }\n if(root->left){\n root->left = lowestCommonAncestor(root->left, p, q);\n }\n else{\n root->left = nullptr;\n }\n if(root->right){\n root->right = lowestCommonAncestor(root->right, p, q);\n }\n else{\n root->right = nullptr;\n }\n\n if(root->left && root->right){\n return root;\n }\n else if(!root->left){\n return root->right;\n }\n else{\n return root->left;\n }\n }\n};", "memory": "13600" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == p || root == q){\n return root;\n }\n if(root->left){\n root->left = lowestCommonAncestor(root->left, p, q);\n }\n else{\n root->left = nullptr;\n }\n if(root->right){\n root->right = lowestCommonAncestor(root->right, p, q);\n }\n else{\n root->right = nullptr;\n }\n\n if(root->left && root->right){\n return root;\n }\n else if(!root->left){\n return root->right;\n }\n else{\n return root->left;\n }\n }\n};", "memory": "13700" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == p || root == q){\n return root;\n }\n if(root->left){\n root->left = lowestCommonAncestor(root->left, p, q);\n }\n else{\n root->left = nullptr;\n }\n if(root->right){\n root->right = lowestCommonAncestor(root->right, p, q);\n }\n else{\n root->right = nullptr;\n }\n\n if(root->left && root->right){\n return root;\n }\n else if(!root->left){\n return root->right;\n }\n else{\n return root->left;\n }\n }\n};", "memory": "13700" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root==NULL || root==p || root==q) return root;\n root->left=lowestCommonAncestor(root->left, p, q);\n root->right=lowestCommonAncestor(root->right, p ,q);\n if(root->left==NULL){\n return root->right;\n }\n if(root->right==NULL){\n return root->left;\n }\n\n return root;\n\n }\n};", "memory": "13800" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n vector<TreeNode*> cur_path;\n TreeNode* ancestor = nullptr;\n\n stack<TreeNode*> dfs;\n dfs.push(root);\n while (!dfs.empty()) {\n TreeNode* cur_node = dfs.top();\n\n if (!cur_node) {\n dfs.pop();\n continue;\n }\n if (!cur_path.empty() && (cur_node == cur_path.back())) {\n cur_path.pop_back();\n dfs.pop();\n if (cur_node == ancestor) {\n ancestor = cur_path.back();\n }\n continue;\n }\n\n cur_path.push_back(cur_node);\n\n if ((cur_node == p) || (cur_node == q)) {\n if (ancestor) {\n break;\n }\n ancestor = cur_node;\n }\n\n dfs.push(cur_node->left);\n dfs.push(cur_node->right);\n cur_node->left = cur_node->right = nullptr;\n }\n\n return ancestor;\n }\n};", "memory": "13900" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode * lca(TreeNode * &root, TreeNode * p, TreeNode * q, TreeNode * &a){\n if(root == NULL || a)\n return a;\n lca(root->left, p, q, a);\n lca(root->right, p, q, a);\n if(a != NULL)\n return a;\n if((root->left == p && root->right == q) ||( root->left == q && root->right == p))\n a = root;\n else if(root->left == p || root->right == p){\n if(root == q){\n a = q;\n return a;}\n root = p;\n }\n else if(root->left == q || root->right == q){\n if(root == p){\n a = p;\n return a;\n }\n root = q;\n }\n return a;\n }\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n TreeNode * a = NULL;\n return lca(root, p ,q, a);\n }\n};", "memory": "14300" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n bool lca1(TreeNode* root, TreeNode* p){\n if(root==p) return true;\n if(root==NULL) return false;\n return lca1(root->left,p)||lca1(root->right,p);\n }\n bool lca2(TreeNode* root,TreeNode* q){\n if(root==q) return true;\n if(root==NULL) return false;\n return lca2(root->left,q)||lca2(root->right,q);\n }\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root==p || root==q) return root;\n if(lca1(root->left,p) && lca2(root->left,q)){\n return lowestCommonAncestor(root->left,p,q);\n }\n else if(lca1(root->right,p) && lca2(root->right,q)){\n return lowestCommonAncestor(root->right,p,q);\n }\n else{\n return root;\n }\n }\n};", "memory": "15800" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n bool findNode(TreeNode* root, TreeNode* cur){\n if(root == NULL) return false;\n if(root == cur) return true;\n return findNode(root->right, cur) || findNode(root->left, cur);\n }\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(p == root || q == root){\n return root;\n }\n if(root->left == NULL) return lowestCommonAncestor(root->right, p, q);\n if(root->right == NULL) return lowestCommonAncestor(root->left, p, q);\n if(findNode(root->left, p) && findNode(root->right,q)){\n return root;\n }\n if(findNode(root->left, p) && findNode(root->left, q)){\n return lowestCommonAncestor(root->left, p, q);\n }\n if(findNode(root->right, p) && findNode(root->right, q)){\n return lowestCommonAncestor(root->right, p, q);\n }\n return root;\n \n }\n};", "memory": "15900" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n\n TreeNode* LCA_helper(TreeNode* root, TreeNode* p, TreeNode* q)\n {\n if(root==NULL || root==p || root==q)\n return root;\n \n TreeNode* lst_LCA = LCA_helper(root->left,p,q);\n TreeNode* rst_LCA = LCA_helper(root->right,p,q);\n\n if(lst_LCA==NULL)\n return rst_LCA;\n \n else if(rst_LCA==NULL)\n return lst_LCA;\n \n else // neither lst_LCA nor rst_LCA are NULL\n return root;\n }\n\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) { \n return LCA_helper(root,p,q);\n }\n};", "memory": "16000" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == NULL || root == p || root == q){\n return root;\n }\n TreeNode* l = lowestCommonAncestor(root->left,p,q);\n TreeNode* r = lowestCommonAncestor(root->right,p,q);\n if(l == NULL){\n return r;\n }\n else if(r == NULL){\n return l;\n }\n else{\n return root;\n }\n }\n};", "memory": "16000" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "class Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if (!root) return nullptr;\n\n // If either p or q is the root, then root is the LCA\n if (root == p || root == q) {\n return root;\n }\n\n // Recur on the left and right subtrees\n TreeNode* left = lowestCommonAncestor(root->left, p, q);\n TreeNode* right = lowestCommonAncestor(root->right, p, q);\n\n // If p and q are found in left and right subtrees respectively, root is the LCA\n if (left && right) {\n return root;\n }\n\n // If either left or right subtree has both p and q, return that subtree's result\n return left ? left : right;\n }\n};\n", "memory": "16100" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(!root)\n return NULL;\n if(root==p || root==q)\n return root;\n TreeNode* l=lowestCommonAncestor(root->left,p,q);\n TreeNode* r=lowestCommonAncestor(root->right,p,q);\n if(l && r)return root;\n if(l)return l;\n if(r)return r;\n return NULL;\n \n }\n};", "memory": "16100" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n bool existingInTree(TreeNode* root, TreeNode* target){\n if(root==target) return true;\n if(root==NULL) return false;\n return existingInTree(root->left,target) || existingInTree(root->right,target);\n }\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root==p || root==q) return root;\n else if(existingInTree(root->left, p) && existingInTree(root->right,q)) return root;\n else if(!existingInTree(root->left,p) && !existingInTree(root->right,q)) return root;\n else if(existingInTree(root->left,p) && !existingInTree(root->right,q)) return lowestCommonAncestor(root->left,p,q);\n else return lowestCommonAncestor(root->right,p,q);\n }\n};", "memory": "16200" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n bool exists(TreeNode* root,TreeNode* target){\n if(root== NULL) return false;\n if(root==target) return true;\n return exists(root->left,target) || exists(root->right,target);\n }\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(p==root || q==root) return root;\n else if(exists(root->left,p)&& exists(root->right ,q)) return root;\n else if(exists(root->right,p)&& exists(root->left ,q)) return root;\n else if(exists(root->left,p)&& exists(root->left ,q)) return lowestCommonAncestor(root->left ,p,q) ;\n else return lowestCommonAncestor(root->right,p,q);\n }\n};", "memory": "16200" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root==NULL||root==p||root==q) return root;\n\n TreeNode* left=lowestCommonAncestor(root->left,p,q);\n TreeNode* right=lowestCommonAncestor(root->right,p,q);\n\n if(left==NULL)\n return right;\n else if(right==NULL)\n return left;\n else\n return root;\n }\n};", "memory": "16300" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

0

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if (root == nullptr) {\n return nullptr;\n }\n if (root == p || root == q) {\n return root;\n }\n TreeNode* foundInLeft = lowestCommonAncestor(root->left, p, q);\n TreeNode* foundInRight = lowestCommonAncestor(root->right, p, q);\n if (foundInLeft && foundInRight) {\n return root;\n } \n if (foundInLeft) {\n return foundInLeft;\n } else {\n return foundInRight;\n }\n }\n};", "memory": "16300" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

1

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root==NULL){\n return NULL;\n }\n if(root==p || root==q){\n return root;\n }\n\n TreeNode* leftA=lowestCommonAncestor(root->left,p,q);\n TreeNode* rightA=lowestCommonAncestor(root->right,p,q);\n\n if(leftA!=NULL && rightA!=NULL){\n return root;\n }\n else if(leftA!=NULL && rightA==NULL){\n return leftA;\n }\n else if(leftA==NULL && rightA!=NULL){\n return rightA;\n }\n else{\n return NULL;\n }\n }\n};", "memory": "16400" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

1

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n if(root == nullptr) return root;\n if(root == p || root == q) return root;\n TreeNode* left = lowestCommonAncestor(root->left, p,q);\n TreeNode* right = lowestCommonAncestor(root->right,p,q);\n\n if(left == nullptr){\n return right;\n }\n else if(right == nullptr){\n return left;\n }\n else {\n return root;\n }\n }\n};", "memory": "16400" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

3

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n\n if(root==NULL|| root==p|| q==root)\n {\n return root;\n }\n\n TreeNode*lnode=lowestCommonAncestor(root->left,p,q);\n TreeNode*right=lowestCommonAncestor(root->right,p,q);\n\n\n if(lnode==NULL)\n {\n return right;\n }else if(right==NULL)\n {\n return lnode;\n }else{\n return root;\n }\n\n\n\n\n }\n};", "memory": "16500" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

3

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n //basic fundamenta l idea for this questuin is that ki \n\n if(!root)\n {\n return NULL;\n }\n if(root==p||root==q)\n {\n return root;\n }\n\n TreeNode*l=lowestCommonAncestor( root->left, p,q);\n TreeNode*r=lowestCommonAncestor( root->right, p,q);\n\n if(l && r)\n {\n return root;\n }\n\n if(!l)\n {\n if(r)\n {\n return r;\n }\n else\n {\n return NULL;\n }\n }\n\n if(!r)\n {\n if(l)\n {\n return l;\n }\n else\n {\n return NULL;\n }\n }\n return NULL;\n }\n};", "memory": "16500" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

3

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n TreeNode* L=NULL;\n fn(root,p,q,L);\n return L;\n }\n bool fn(TreeNode* root, TreeNode* &p, TreeNode* &q,TreeNode* &L){\n if(!L){\n if(root){\n bool l,r,c;\n c = (root == p || root == q);\n l = fn(root->left,p,q,L);\n r = fn(root->right,p,q,L);\n if(l && r){\n L = root;\n return false;\n }\n if(c && (l||r)){\n L = root;\n return false;\n }\n if(l||r||c){\n return true;\n }\n }\n else{\n return false;\n }\n }\n return false;\n }\n};", "memory": "16600" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

3

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n TreeNode* L=NULL;\n fn(root,p,q,L);\n return L;\n }\n bool fn(TreeNode* root, TreeNode* &p, TreeNode* &q,TreeNode* &L){\n if(!L){\n if(root){\n bool l,r,c;\n c = (root == p || root == q);\n l = fn(root->left,p,q,L);\n r = fn(root->right,p,q,L);\n if(l && r){\n L = root;\n return false;\n }\n if(c && (l||r)){\n L = root;\n return false;\n }\n if(l||r||c){\n return true;\n }\n }\n else{\n return false;\n }\n }\n return false;\n }\n};", "memory": "16600" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

3

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n bool mylowestCommonAncestor(TreeNode*& root, TreeNode*& p, TreeNode*& q,\n TreeNode*& pLCA, bool& leftFound) {\n if (!root)\n return false;\n if (pLCA)\n return false;\n if (leftFound && (p == root || q == root))\n return true;\n bool bLeftFound =\n mylowestCommonAncestor(root->left, p, q, pLCA, leftFound);\n if (bLeftFound && (p == root || q == root)) {\n pLCA = root;\n return false;\n }\n if (bLeftFound)\n leftFound = bLeftFound;\n bool bRightFound =\n mylowestCommonAncestor(root->right, p, q, pLCA, leftFound);\n if ((bLeftFound && bRightFound) ||\n ((bLeftFound || bRightFound) && (p == root || q == root))) {\n pLCA = root;\n return false;\n }\n return bLeftFound || bRightFound || p == root || q == root;\n }\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n auto init = []() {\n ios::sync_with_stdio(0);\n cin.tie(0);\n cout.tie(0);\n return 'c';\n }();\n if (!root)\n return NULL;\n TreeNode* LCA = NULL;\n bool b = false;\n mylowestCommonAncestor(root, p, q, LCA, b);\n return LCA;\n }\n};\n", "memory": "16700" }

236

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow a node to be a descendant of itself).”   Example 1: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 Output: 3 Explanation: The LCA of nodes 5 and 1 is 3. </pre> Example 2: <img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" /> <pre> Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 Output: 5 Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. </pre> Example 3: <pre> Input: root = [1,2], p = 1, q = 2 Output: 1 </pre>   Constraints: <ul> <li>The number of nodes in the tree is in the range <code>[2, 105]</code>.</li> <li><code>-109 <= Node.val <= 109</code></li> <li>All <code>Node.val</code> are unique.</li> <li><code>p != q</code></li> <li><code>p</code> and <code>q</code> will exist in the tree.</li> </ul>

3

{ "code": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n bool mylowestCommonAncestor(TreeNode*& root, TreeNode*& p, TreeNode*& q,\n TreeNode*& pLCA, bool& leftFound) {\n if (!root || pLCA)\n return false;\n else if (leftFound && (p == root || q == root))\n return true;\n bool bLeftFound =\n mylowestCommonAncestor(root->left, p, q, pLCA, leftFound);\n if (bLeftFound && (p == root || q == root)) {\n pLCA = root;\n return false;\n }\n else if (bLeftFound)\n leftFound = bLeftFound;\n bool bRightFound =\n mylowestCommonAncestor(root->right, p, q, pLCA, leftFound);\n if ((bLeftFound && bRightFound) ||\n ((bLeftFound || bRightFound) && (p == root || q == root))) {\n pLCA = root;\n return false;\n }\n return bLeftFound || bRightFound || p == root || q == root;\n }\n TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n auto init = []() {\n ios::sync_with_stdio(0);\n cin.tie(0);\n cout.tie(0);\n return 'c';\n }();\n if (!root)\n return NULL;\n TreeNode* LCA = NULL;\n bool b = false;\n mylowestCommonAncestor(root, p, q, LCA, b);\n return LCA;\n }\n};\n", "memory": "16700" }