Added tasks 230-1143

Author: javadev

README.md

@@ -0,0 +1,87 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Php/LeetCode-in-Php?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Php/LeetCode-in-Php)
+[![](https://img.shields.io/github/forks/LeetCode-in-Php/LeetCode-in-Php?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Php/LeetCode-in-Php/fork)
+
+## 230\. Kth Smallest Element in a BST
+
+Medium
+
+Given the `root` of a binary search tree, and an integer `k`, return _the_ <code>k<sup>th</sup></code> _smallest value (**1-indexed**) of all the values of the nodes in the tree_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/28/kthtree1.jpg)
+
+**Input:** root = [3,1,4,null,2], k = 1
+
+**Output:** 1 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/01/28/kthtree2.jpg)
+
+**Input:** root = [5,3,6,2,4,null,null,1], k = 3
+
+**Output:** 3 
+
+**Constraints:**
+
+*   The number of nodes in the tree is `n`.
+*   <code>1 <= k <= n <= 10<sup>4</sup></code>
+*   <code>0 <= Node.val <= 10<sup>4</sup></code>
+
+**Follow up:** If the BST is modified often (i.e., we can do insert and delete operations) and you need to find the kth smallest frequently, how would you optimize?
+
+## Solution
+
+```php
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     public $val = null;
+ *     public $left = null;
+ *     public $right = null;
+ *     function __construct($val = 0, $left = null, $right = null) {
+ *         $this->val = $val;
+ *         $this->left = $left;
+ *         $this->right = $right;
+ *     }
+ * }
+ */
+class Solution {
+    private $k;
+    private $count = 0;
+    private $val;
+
+    /**
+     * @param TreeNode $root
+     * @param Integer $k
+     * @return Integer
+     */
+    public function kthSmallest($root, $k) {
+        $this->k = $k;
+        $this->calculate($root);
+        return $this->val;
+    }
+
+    private function calculate($node) {
+        if ($node->left == null && $node->right == null) {
+            $this->count++;
+            if ($this->count == $this->k) {
+                $this->val = $node->val;
+            }
+            return;
+        }
+        if ($node->left != null) {
+            $this->calculate($node->left);
+        }
+        $this->count++;
+        if ($this->count == $this->k) {
+            $this->val = $node->val;
+            return;
+        }
+        if ($node->right != null) {
+            $this->calculate($node->right);
+        }
+    }
+}
+```

src/main/php/g0201_0300/s0230_kth_smallest_element_in_a_bst/readme.md

@@ -0,0 +1,69 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Php/LeetCode-in-Php?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Php/LeetCode-in-Php)
+[![](https://img.shields.io/github/forks/LeetCode-in-Php/LeetCode-in-Php?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Php/LeetCode-in-Php/fork)
+
+## 234\. Palindrome Linked List
+
+Easy
+
+Given the `head` of a singly linked list, return `true` if it is a palindrome.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg)
+
+**Input:** head = [1,2,2,1]
+
+**Output:** true 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg)
+
+**Input:** head = [1,2]
+
+**Output:** false 
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.
+*   `0 <= Node.val <= 9`
+
+**Follow up:** Could you do it in `O(n)` time and `O(1)` space?
+
+## Solution
+
+```php
+/**
+ * Definition for a singly-linked list.
+ * class ListNode {
+ *     public $val = 0;
+ *     public $next = null;
+ *     function __construct($val = 0, $next = null) {
+ *         $this->val = $val;
+ *         $this->next = $next;
+ *     }
+ * }
+ */
+class Solution {
+    /**
+     * @param ListNode $head
+     * @return Boolean
+     */
+    public function isPalindrome($head) {
+        $array = [];
+        while ($head) {
+            $array[] = $head->val;
+            $head = $head->next;
+        }
+        $cnt = count($array);
+        for ($x = 0; $x < $cnt / 2; $x++) {
+            $yKey = $cnt - 1 - $x;
+
+            if ($array[$x] !== $array[$yKey]) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```

src/main/php/g0201_0300/s0234_palindrome_linked_list/readme.md

@@ -0,0 +1,83 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Php/LeetCode-in-Php?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Php/LeetCode-in-Php)
+[![](https://img.shields.io/github/forks/LeetCode-in-Php/LeetCode-in-Php?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Php/LeetCode-in-Php/fork)
+
+## 236\. Lowest Common Ancestor of a Binary Tree
+
+Medium
+
+Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.
+
+According to the [definition of LCA on Wikipedia](https://en.wikipedia.org/wiki/Lowest_common_ancestor): “The lowest common ancestor is defined between two nodes `p` and `q` as the lowest node in `T` that has both `p` and `q` as descendants (where we allow **a node to be a descendant of itself**).”
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2018/12/14/binarytree.png)
+
+**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. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2018/12/14/binarytree.png)
+
+**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. 
+
+**Example 3:**
+
+**Input:** root = [1,2], p = 1, q = 2
+
+**Output:** 1 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.
+*   <code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code>
+*   All `Node.val` are **unique**.
+*   `p != q`
+*   `p` and `q` will exist in the tree.
+
+## Solution
+
+```php
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     public $val = null;
+ *     public $left = null;
+ *     public $right = null;
+ *     function __construct($value) { $this->val = $value; }
+ * }
+ */
+class Solution {
+    /**
+     * @param TreeNode $root
+     * @param TreeNode $p
+     * @param TreeNode $q
+     * @return TreeNode
+     */
+    public function lowestCommonAncestor($root, $p, $q) {
+        if ($root == null) {
+            return null;
+        }
+        if ($root->val == $p->val || $root->val == $q->val) {
+            return $root;
+        }
+        $left = $this->lowestCommonAncestor($root->left, $p, $q);
+        $right = $this->lowestCommonAncestor($root->right, $p, $q);
+        if ($left != null && $right != null) {
+            return $root;
+        }
+        if ($left != null) {
+            return $left;
+        }
+        return $right;
+    }
+}
+```

src/main/php/g0201_0300/s0236_lowest_common_ancestor_of_a_binary_tree/readme.md

@@ -0,0 +1,64 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Php/LeetCode-in-Php?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Php/LeetCode-in-Php)
+[![](https://img.shields.io/github/forks/LeetCode-in-Php/LeetCode-in-Php?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Php/LeetCode-in-Php/fork)
+
+## 238\. Product of Array Except Self
+
+Medium
+
+Given an integer array `nums`, return _an array_ `answer` _such that_ `answer[i]` _is equal to the product of all the elements of_ `nums` _except_ `nums[i]`.
+
+The product of any prefix or suffix of `nums` is **guaranteed** to fit in a **32-bit** integer.
+
+You must write an algorithm that runs in `O(n)` time and without using the division operation.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,4]
+
+**Output:** [24,12,8,6] 
+
+**Example 2:**
+
+**Input:** nums = [-1,1,0,-3,3]
+
+**Output:** [0,0,9,0,0] 
+
+**Constraints:**
+
+*   <code>2 <= nums.length <= 10<sup>5</sup></code>
+*   `-30 <= nums[i] <= 30`
+*   The product of any prefix or suffix of `nums` is **guaranteed** to fit in a **32-bit** integer.
+
+**Follow up:** Can you solve the problem in `O(1) `extra space complexity? (The output array **does not** count as extra space for space complexity analysis.)
+
+## Solution
+
+```php
+class Solution {
+    /**
+     * @param Integer[] $nums
+     * @return Integer[]
+     */
+    public function productExceptSelf($nums) {
+        $product = 1;
+        $ans = array_fill(0, count($nums), 0);
+        foreach ($nums as $num) {
+            $product = $product * $num;
+        }
+        for ($i = 0; $i < count($nums); $i++) {
+            if ($nums[$i] != 0) {
+                $ans[$i] = $product / $nums[$i];
+            } else {
+                $p = 1;
+                for ($j = 0; $j < count($nums); $j++) {
+                    if ($j != $i) {
+                        $p = $p * $nums[$j];
+                    }
+                }
+                $ans[$i] = $p;
+            }
+        }
+        return $ans;
+    }
+}
+```