LeetCode Medium Design Solutions

Author: ashwanisharma3

251. Flatten 2D Vector.cpp

@@ -0,0 +1,50 @@
+/*
+Link: https://leetcode.com/problems/flatten-2d-vector
+https://www.lintcode.com/problem/flatten-2d-vector/description
+
+Implement an iterator to flatten a 2d vector.
+
+Example
+Example 1:
+
+Input:[[1,2],[3],[4,5,6]]
+Output:[1,2,3,4,5,6]
+Example 2:
+
+Input:[[7,9],[5]]
+Output:[7,9,5]
+*/
+
+// Solution
+class Vector2D {
+public:
+    int col, row;
+    vector<vector<int>>vec2d;
+    Vector2D(vector<vector<int>>& v) {
+        col = -1;
+        row = 0;
+        vec2d = v;
+        // Initialize your data structure here
+    }
+
+    int next() {
+        return vec2d[row][col];
+        // Write your code here
+    }
+
+    bool hasNext() {
+        col++;
+        while (row < vec2d.size() && col >= vec2d[row].size()) {
+            row++;
+            col = 0;
+        }
+        return row < vec2d.size();
+        // Write your code here
+    }
+};
+
+/**
+ * Your Vector2D object will be instantiated and called as such:
+ * Vector2D i(vec2d);
+ * while (i.hasNext()) cout << i.next();
+ */

297. Serialize and Deserialize Binary Tree.cpp

@@ -0,0 +1,104 @@
+/*
+Link: https://leetcode.com/problems/serialize-and-deserialize-binary-tree/
+
+Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.
+
+Design an algorithm to serialize and deserialize a binary tree. There is no restriction on how your serialization/deserialization algorithm should work. You just need to ensure that a binary tree can be serialized to a string and this string can be deserialized to the original tree structure.
+
+Example: 
+
+You may serialize the following tree:
+
+    1
+   / \
+  2   3
+     / \
+    4   5
+
+as "[1,2,3,null,null,4,5]"
+Clarification: The above format is the same as how LeetCode serializes a binary tree. You do not necessarily need to follow this format, so please be creative and come up with different approaches yourself.
+
+Note: Do not use class member/global/static variables to store states. Your serialize and deserialize algorithms should be stateless.
+*/
+
+// Solution
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Codec {
+public:
+
+    // Encodes a tree to a single string.
+    string serialize(TreeNode* root) {
+        // inorder traversal
+        queue<TreeNode *> q;
+        string ans;
+        q.push(root);
+        while (!q.empty()) {
+            int len = q.size();
+            for (int i = 0; i < len; i++) {
+                TreeNode *temp = q.front();
+                q.pop();
+                if (temp){
+                    ans += to_string(temp -> val) + ",";
+                    q.push (temp -> left);
+                    q.push (temp -> right);
+                } else {
+                    ans += "null," ;
+                }
+            }
+        }
+        ans.pop_back();
+        cout<<ans;
+        return ans;
+    }
+
+    // Decodes your encoded data to tree.
+    TreeNode* deserialize(string data) {
+        // obtaining tree from inorder traversal
+        queue<TreeNode *> q;
+        vector<string> v;
+        
+        stringstream ss(data);
+        
+        while (ss.good()) {
+            string substr;
+            getline(ss, substr, ','); 
+            v.push_back(substr); 
+        }
+        
+        if (v[0] == "null")
+            return NULL;
+        
+        TreeNode *root = new TreeNode(stoi(v[0]));
+        q.push(root);
+        int i = 1;
+        while (!q.empty()) {
+            TreeNode *temp = q.front();
+            q.pop();
+            
+            if(temp) {
+                temp -> left = v[i] == "null" ? NULL : new TreeNode(stoi(v[i]));
+                i++;
+                temp -> right = v[i] == "null" ? NULL : new TreeNode(stoi(v[i]));
+                i++;
+                q.push(temp ->left);
+                q.push(temp ->right);
+            }
+        }
+        
+        
+        return root;
+    }
+};
+
+// Your Codec object will be instantiated and called as such:
+// Codec codec;
+// codec.deserialize(codec.serialize(root));

380. Insert Delete GetRandom O(1).cpp

@@ -0,0 +1,82 @@
+/*
+Link: https://leetcode.com/problems/insert-delete-getrandom-o1/
+
+Design a data structure that supports all following operations in average O(1) time.
+
+insert(val): Inserts an item val to the set if not already present.
+remove(val): Removes an item val from the set if present.
+getRandom: Returns a random element from current set of elements. Each element must have the same probability of being returned.
+Example:
+
+// Init an empty set.
+RandomizedSet randomSet = new RandomizedSet();
+
+// Inserts 1 to the set. Returns true as 1 was inserted successfully.
+randomSet.insert(1);
+
+// Returns false as 2 does not exist in the set.
+randomSet.remove(2);
+
+// Inserts 2 to the set, returns true. Set now contains [1,2].
+randomSet.insert(2);
+
+// getRandom should return either 1 or 2 randomly.
+randomSet.getRandom();
+
+// Removes 1 from the set, returns true. Set now contains [2].
+randomSet.remove(1);
+
+// 2 was already in the set, so return false.
+randomSet.insert(2);
+
+// Since 2 is the only number in the set, getRandom always return 2.
+randomSet.getRandom();
+*/
+
+// Solution
+
+class RandomizedSet {
+public:
+    /** Initialize your data structure here. */
+    set<int> st;
+    RandomizedSet() {
+        
+    }
+    
+    /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
+    bool insert(int val) {
+        if (st.find(val) == st.end()) {
+            st.insert(val);
+            return true;
+        }
+        return false;
+    }
+    
+    /** Removes a value from the set. Returns true if the set contained the specified element. */
+    bool remove(int val) {
+        if (st.find(val) != st.end()) {
+            st.erase(st.find(val));
+            return true;
+        }
+        return false;
+    }
+    
+    /** Get a random element from the set. */
+    int getRandom() {
+        int x = rand() % st.size();
+        auto it = st.begin();
+        
+        while(x--) {
+            it ++;
+        }
+        return *it;
+    }
+};
+
+/**
+ * Your RandomizedSet object will be instantiated and called as such:
+ * RandomizedSet* obj = new RandomizedSet();
+ * bool param_1 = obj->insert(val);
+ * bool param_2 = obj->remove(val);
+ * int param_3 = obj->getRandom();
+ */