Leetcode and Binary Search

Author: harshit2608

BinarySearch/Easy/982. First Fit Room.cpp

@@ -0,0 +1,13 @@
+int solve(vector<int> &rooms, int target)
+{
+    if (rooms.empty())
+        return -1;
+
+    int n = rooms.size();
+    for (int i = 0; i < n; i++)
+    {
+        if (rooms[i] >= target)
+            return rooms[i];
+    }
+    return -1;
+}

BinarySearch/Hard/580. Partition String.cpp

@@ -0,0 +1,25 @@
+vector<int> solve(string s)
+{
+    vector<int> ans;
+    int n = s.size();
+    int last[26];
+    for (int i = 0; i < n; ++i)
+    {
+        last[s[i] - 'a'] = i;
+    }
+
+    int i = 0;
+    while (i < n)
+    {
+        int k = last[s[i] - 'a'];
+        int j = i + 1;
+        while (j <= k)
+        {
+            k = max(k, last[s[j] - 'a']);
+            j += 1;
+        }
+        ans.push_back(j - i);
+        i = j;
+    }
+    return ans;
+}

BinarySearch/Medium/72. Invert Tree.cpp

@@ -0,0 +1,35 @@
+/**
+ * class Tree {
+ *     public:
+ *         int val;
+ *         Tree *left;
+ *         Tree *right;
+ * };
+ */
+Tree *solve(Tree *root)
+{
+    if (root == nullptr)
+    {
+        return root;
+    }
+
+    queue<Tree *> q;
+    q.push(root);
+    while (!q.empty())
+    {
+        Tree *curr = q.front();
+        q.pop();
+        Tree *temp = curr->left;
+        curr->left = curr->right;
+        curr->right = temp;
+        if (curr->left)
+        {
+            q.push(curr->left);
+        }
+        if (curr->right)
+        {
+            q.push(curr->right);
+        }
+    }
+    return root;
+}

BinarySearch/Medium/81. Central Linked List.cpp

@@ -0,0 +1,17 @@
+/**
+ * class LLNode {
+ *     public:
+ *         int val;
+ *         LLNode *next;
+ * };
+ */
+int solve(LLNode *node)
+{
+    LLNode *fast = node, *slow = node;
+    while (fast != nullptr and fast->next != nullptr)
+    {
+        slow = slow->next;
+        fast = fast->next->next;
+    }
+    return slow->val;
+}

Leet Code/C++/203. Remove Linked List Elements.cpp

@@ -0,0 +1,43 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution
+{
+public:
+    ListNode *removeElements(ListNode *head, int val)
+    {
+        if (head == NULL)
+        {
+            return head;
+        }
+        ListNode *prev = NULL, *tmp = head;
+
+        while (head)
+        {
+            if (head->val != val)
+            {
+                prev = head;
+            }
+            else
+            {
+                if (prev != NULL)
+                {
+                    prev->next = head->next;
+                }
+                else
+                {
+                    tmp = head->next;
+                }
+            }
+            head = head->next;
+        }
+        return tmp;
+    }
+};

Leet Code/C++/231. Power of Two.cpp

@@ -0,0 +1,14 @@
+class Solution
+{
+public:
+    bool isPowerOfTwo(int n)
+    {
+        if (n == 1)
+            return true;
+        if (n % 2 != 0 || n == 0)
+            return false;
+        if (isPowerOfTwo(n / 2))
+            return true;
+        return false;
+    }
+};

Leet Code/C++/509. Fibonacci Number.cpp

@@ -0,0 +1,12 @@
+class Solution
+{
+public:
+    int fib(int n)
+    {
+        if (n == 0 || n == 1)
+        {
+            return n;
+        }
+        return fib(n - 1) + fib(n - 2);
+    }
+};