Update readme.md

Co-Authored-By: Antim-IWP <203163676+Antim-IWP@users.noreply.github.com>
Co-Authored-By: Shiwangi Srivastava <174641070+IamShiwangi@users.noreply.github.com>

Author: 3 people

Solution/841. Keys and Rooms/readme.md

@@ -106,256 +106,6 @@ class Solution:
         return root
 ```
 
-#### Java
-
-```java
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode() {}
- *     TreeNode(int val) { this.val = val; }
- *     TreeNode(int val, TreeNode left, TreeNode right) {
- *         this.val = val;
- *         this.left = left;
- *         this.right = right;
- *     }
- * }
- */
-class Solution {
-    public TreeNode deleteNode(TreeNode root, int key) {
-        if (root == null) {
-            return null;
-        }
-        if (root.val > key) {
-            root.left = deleteNode(root.left, key);
-            return root;
-        }
-        if (root.val < key) {
-            root.right = deleteNode(root.right, key);
-            return root;
-        }
-        if (root.left == null) {
-            return root.right;
-        }
-        if (root.right == null) {
-            return root.left;
-        }
-        TreeNode node = root.right;
-        while (node.left != null) {
-            node = node.left;
-        }
-        node.left = root.left;
-        root = root.right;
-        return root;
-    }
-}
-```
-
-#### C++
-
-```cpp
-/**
- * Definition for a binary tree node.
- * struct TreeNode {
- *     int val;
- *     TreeNode *left;
- *     TreeNode *right;
- *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
- *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
- *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
- * };
- */
-class Solution {
-public:
-    TreeNode* deleteNode(TreeNode* root, int key) {
-        if (!root) return root;
-        if (root->val > key) {
-            root->left = deleteNode(root->left, key);
-            return root;
-        }
-        if (root->val < key) {
-            root->right = deleteNode(root->right, key);
-            return root;
-        }
-        if (!root->left) return root->right;
-        if (!root->right) return root->left;
-        TreeNode* node = root->right;
-        while (node->left) node = node->left;
-        node->left = root->left;
-        root = root->right;
-        return root;
-    }
-};
-```
-
-#### Go
-
-```go
-/**
- * Definition for a binary tree node.
- * type TreeNode struct {
- *     Val int
- *     Left *TreeNode
- *     Right *TreeNode
- * }
- */
-func deleteNode(root *TreeNode, key int) *TreeNode {
-	if root == nil {
-		return nil
-	}
-	if root.Val > key {
-		root.Left = deleteNode(root.Left, key)
-		return root
-	}
-	if root.Val < key {
-		root.Right = deleteNode(root.Right, key)
-		return root
-	}
-	if root.Left == nil {
-		return root.Right
-	}
-	if root.Right == nil {
-		return root.Left
-	}
-	node := root.Right
-	for node.Left != nil {
-		node = node.Left
-	}
-	node.Left = root.Left
-	root = root.Right
-	return root
-}
-```
-
-#### TypeScript
-
-```ts
-/**
- * Definition for a binary tree node.
- * class TreeNode {
- *     val: number
- *     left: TreeNode | null
- *     right: TreeNode | null
- *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
- *         this.val = (val===undefined ? 0 : val)
- *         this.left = (left===undefined ? null : left)
- *         this.right = (right===undefined ? null : right)
- *     }
- * }
- */
-
-function deleteNode(root: TreeNode | null, key: number): TreeNode | null {
-    if (root == null) {
-        return root;
-    }
-    const { val, left, right } = root;
-    if (val > key) {
-        root.left = deleteNode(left, key);
-    } else if (val < key) {
-        root.right = deleteNode(right, key);
-    } else {
-        if (left == null && right == null) {
-            root = null;
-        } else if (left == null || right == null) {
-            root = left || right;
-        } else {
-            if (right.left == null) {
-                right.left = left;
-                root = right;
-            } else {
-                let minPreNode = right;
-                while (minPreNode.left.left != null) {
-                    minPreNode = minPreNode.left;
-                }
-                const minVal = minPreNode.left.val;
-                root.val = minVal;
-                minPreNode.left = deleteNode(minPreNode.left, minVal);
-            }
-        }
-    }
-    return root;
-}
-```
-
-#### Rust
-
-```rust
-// Definition for a binary tree node.
-// #[derive(Debug, PartialEq, Eq)]
-// pub struct TreeNode {
-//   pub val: i32,
-//   pub left: Option<Rc<RefCell<TreeNode>>>,
-//   pub right: Option<Rc<RefCell<TreeNode>>>,
-// }
-//
-// impl TreeNode {
-//   #[inline]
-//   pub fn new(val: i32) -> Self {
-//     TreeNode {
-//       val,
-//       left: None,
-//       right: None
-//     }
-//   }
-// }
-use std::cell::RefCell;
-use std::rc::Rc;
-impl Solution {
-    fn dfs(root: &Option<Rc<RefCell<TreeNode>>>) -> i32 {
-        let node = root.as_ref().unwrap().borrow();
-        if node.left.is_none() {
-            return node.val;
-        }
-        Self::dfs(&node.left)
-    }
-
-    pub fn delete_node(
-        mut root: Option<Rc<RefCell<TreeNode>>>,
-        key: i32,
-    ) -> Option<Rc<RefCell<TreeNode>>> {
-        if root.is_some() {
-            let mut node = root.as_mut().unwrap().borrow_mut();
-            match node.val.cmp(&key) {
-                std::cmp::Ordering::Less => {
-                    node.right = Self::delete_node(node.right.take(), key);
-                }
-                std::cmp::Ordering::Greater => {
-                    node.left = Self::delete_node(node.left.take(), key);
-                }
-                std::cmp::Ordering::Equal => {
-                    match (node.left.is_some(), node.right.is_some()) {
-                        (false, false) => {
-                            return None;
-                        }
-                        (true, false) => {
-                            return node.left.take();
-                        }
-                        (false, true) => {
-                            return node.right.take();
-                        }
-                        (true, true) => {
-                            if node.right.as_ref().unwrap().borrow().left.is_none() {
-                                let mut r = node.right.take();
-                                r.as_mut().unwrap().borrow_mut().left = node.left.take();
-                                return r;
-                            } else {
-                                let val = Self::dfs(&node.right);
-                                node.val = val;
-                                node.right = Self::delete_node(node.right.take(), val);
-                            }
-                        }
-                    };
-                }
-            }
-        }
-        root
-    }
-}
-```
-
 <!-- tabs:end -->
 
 <!-- solution:end -->