practised lists

Author: piyushkhemka

240. Search a 2D Matrix II.cpp

@@ -0,0 +1,71 @@
+class Solution {
+public:
+    bool searchMatrix(vector<vector<int>>& matrix, int target) {
+
+        if(matrix.empty() || matrix[0].empty())
+            return false;
+
+
+        int row = 0;
+        int col = matrix[0].size()-1;
+
+
+        while(col >=0 && row < matrix.size()) {
+
+            if(matrix[row][col] == target)
+                return true;
+
+            else if (matrix[row][col] > target)
+                col--;
+
+            else
+                row++;
+
+        }
+        return false;
+
+    }
+};
+
+-------
+
+
+// Divide & conquer
+
+class Solution {
+
+    bool helper(vector<vector<int>>& matrix, int target, int rlow, int rhigh, int clow, int chigh) {
+        if ((rlow > rhigh) || (clow > chigh))
+            return false;
+
+        int rmid = rlow + (rhigh-rlow)/2;
+
+        int cmid = clow + (chigh-clow)/2;
+
+        if (matrix[rmid][cmid] == target)
+            return true;
+
+        else if  (matrix[rmid][cmid] > target)
+            return helper(matrix, target, rlow, rhigh, clow, cmid - 1)
+            || helper(matrix, target, rlow, rmid-1, cmid, chigh);
+
+        else
+            return helper(matrix, target, rmid+1, rhigh, clow, chigh)
+            || helper(matrix, target, rlow, rmid, cmid+1, chigh);
+    }
+
+
+public:
+    bool searchMatrix(vector<vector<int>>& matrix, int target) {
+
+
+        int rlow = 0;
+        int clow = 0;
+        int chigh = matrix[0].size()-1;
+        int rhigh = matrix.size()-1;
+
+        return helper(matrix, target, rlow, rhigh, clow, chigh);
+
+
+    }
+};

61. Rotate List.cpp

@@ -0,0 +1,59 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* rotateRight(ListNode* head, int k) {
+
+        if(!k)
+            return head;
+
+        int n = 0;
+
+        ListNode *onebeforek = head;
+
+        ListNode *cur = head;
+
+        int kcopy = k;
+
+        while(cur && cur->next && k--) {
+            cur = cur->next;
+            ++n;
+        }
+
+        while(cur && cur->next) {
+            cur = cur->next;
+            onebeforek = onebeforek->next;
+            ++n;
+        }
+
+        n++;
+
+        if (kcopy > n) {
+            k = kcopy % n;
+            k = n - k;
+            k--;
+            onebeforek = head;
+            while(k--) {
+                onebeforek = onebeforek->next;
+            }
+        }
+
+        if(kcopy == n)
+            return head;
+
+        if(!cur)
+            return head;
+
+        cur->next = head;
+        head = onebeforek->next;
+        onebeforek->next = nullptr;
+
+        return head;
+    }
+};

92. Reverse Linked List II.cpp

@@ -0,0 +1,58 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* reverseBetween(ListNode* head, int m, int n) {
+
+        if(!head)
+            return nullptr;
+
+        if(m == n)
+            return head;
+
+        ListNode *cur = head;
+        ListNode *prev = nullptr;
+        ListNode *next = nullptr;
+        ListNode *onebeforem = nullptr;
+        ListNode *mth = nullptr;
+        int mcopy = m;
+
+        m--;
+        n--;
+
+        while(cur->next && m-- && n--) {
+            prev = cur;
+            cur = cur->next;
+        }
+
+        onebeforem = prev;
+        mth = cur;
+
+        while(cur && n--) {
+            next = cur->next;
+            cur->next = prev;
+            prev = cur;
+            cur = next;
+        }
+
+        if(onebeforem)
+            onebeforem->next = cur;
+
+        if(cur)
+            mth->next = cur->next;
+
+        cur->next = prev;
+
+        if (mcopy == 1)
+            head = cur;
+
+        return head;
+
+    }
+};