Merge pull request neetcode-gh#66 from Ibraam-Nashaat/main

 Create 11- Container with most water in c++

Author: neetcode-gh

cpp/102. Binary-Tree-Level-Order-Traversal.cpp

@@ -0,0 +1,44 @@
+/**
+ * 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:
+    vector<vector<int>> levelOrder(TreeNode* root) {
+      queue< TreeNode* > q;
+        q.push(root);
+        vector<vector<int>> v;
+         vector<int> k;
+         TreeNode* c;
+        int j;
+      while(!q.empty() )
+      {
+          k.clear();
+          j=q.size();
+          for(int i=0;i<j;i++)
+          {
+              c=q.front();
+             q.pop();
+              if(c)
+              {
+                  k.push_back(c->val);
+                  q.push(c->left);
+                  q.push(c->right);
+              }
+          }
+          if(!k.empty())
+          v.push_back(k);
+          
+      }
+    return v;
+        
+    }
+};

cpp/11- Container with most water.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    int maxArea(vector<int>& height) {
+        int i=0,j=height.size()-1;
+        int maxA=0,minh;
+        while(i<j)
+        {
+            minh=min(height[i],height[j]);
+            if(minh*(j-i)>maxA)
+                maxA=minh*(j-i);
+           if(minh==height[i]) 
+               i++;
+            else
+                j--;
+        }
+        return maxA;
+    }
+};

cpp/141-Linked-List-Cycle.cpp

@@ -0,0 +1,29 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    bool hasCycle(ListNode *head) {
+        if(!head) return 0;
+       unordered_set<ListNode*> s;
+        s.insert(head);
+         ListNode * ptr=head->next;
+        while(ptr)
+        {
+            if(s.find(ptr)==s.end())
+        {
+            s.insert(ptr);
+                ptr=ptr->next;
+        }
+            else
+                return 1;
+        }
+        return 0;
+        
+    }
+};

cpp/36- Valid-Sudoku.cpp

@@ -0,0 +1,28 @@
+class Solution {
+public:
+    bool isValidSudoku(vector<vector<char>>& board) {
+      
+  unordered_set <int> row[9];
+    unordered_set<int> col[9];
+    unordered_set<int> squ[3][3];
+      
+    for(int i=0;i<9;i++)
+        for(int j=0;j<9;j++)
+        {
+            if (board[i][j]=='.')
+                continue;
+            else if(row[i].find(board[i][j]) !=row[i].end()
+                   || col[j].find(board[i][j]) !=col[j].end()
+                    || squ[i/3][j/3].find(board[i][j]) !=squ[i/3][j/3].end()
+                   )
+                return false;
+            else
+            {
+                row[i].insert(board[i][j]);
+                col[j].insert(board[i][j]);
+                squ[i/3][j/3].insert(board[i][j]);
+                
+            }
+        }
+        return 1;}
+};

cpp/74-Search-a-2D-Matrix.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    bool searchMatrix(vector<vector<int>>& matrix, int target) {
+        int r=matrix.size();
+        int c=matrix[0].size();
+        for(int i=0;i<r;i++)
+        {
+            
+           if(target>=matrix[i][0] && target<=matrix[i][c-1])
+               if(binary_search(matrix[i].begin(),matrix[i].end(),target))
+               return true;
+            else return false;
+           
+                
+        }
+        return false;
+    }
+};

cpp/98-Validate-Binary-Search-Tree.cpp

@@ -0,0 +1,31 @@
+/**
+ * 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) {}
+ * };
+ */
+void check(TreeNode* root,vector<int>& v)
+ {
+    if(!root) return;
+ check(root->left,v);
+    v.push_back(root->val);
+    check(root->right,v);
+}
+class Solution {
+public:
+    bool isValidBST(TreeNode* root) {
+     vector<int> v;
+    check(root,v);
+        for(int i=0;i<v.size()-1;i++)
+        {
+            if(v[i]>=v[i+1])
+                return 0;
+        }
+        return 1;
+    }
+};