GFG

Author: harshit2608

GeeksForGeeks/Easy/Print adjacency list.cpp

@@ -0,0 +1,19 @@
+class Solution
+{
+public:
+    //Function to return the adjacency list for each vertex.
+    vector<vector<int>> printGraph(int V, vector<int> adj[])
+    {
+        vector<vector<int>> v(V);
+        for (int i = 0; i < V; ++i)
+        {
+            v[i].push_back(i);
+            for (auto it : adj[i])
+            {
+                v[i].push_back(it);
+            }
+        }
+
+        return v;
+    }
+};

GeeksForGeeks/Easy/Reverse Level Order Traversal.cpp

@@ -0,0 +1,32 @@
+vector<int> reverseLevelOrder(Node *root)
+{
+    vector<int> ans;
+    if (root == nullptr)
+    {
+        return ans;
+    }
+
+    queue<Node *> q;
+    stack<int> s;
+    q.push(root);
+    while (!q.empty())
+    {
+        Node *curr = q.front();
+        s.push(curr->data);
+        q.pop();
+        if (curr->right)
+        {
+            q.push(curr->right);
+        }
+        if (curr->left)
+        {
+            q.push(curr->left);
+        }
+    }
+    while (!s.empty())
+    {
+        ans.push_back(s.top());
+        s.pop();
+    }
+    return ans;
+}

GeeksForGeeks/Easy/Sort an array of 0s, 1s and 2s.cpp

@@ -0,0 +1,26 @@
+class Solution
+{
+public:
+    void sort012(int arr[], int n)
+    {
+        long int low = 0, mid = 0, high = n - 1;
+        while (mid <= high)
+        {
+            if (arr[mid] == 0)
+            {
+                swap(arr[mid], arr[low]);
+                low++;
+                mid++;
+            }
+            else if (arr[mid] == 1)
+            {
+                mid++;
+            }
+            else
+            {
+                swap(arr[mid], arr[high]);
+                high--;
+            }
+        }
+    }
+};

GeeksForGeeks/Medium/Find the number of islands.cpp

@@ -0,0 +1,42 @@
+class Solution
+{
+public:
+    //Function to find the number of islands.
+
+    void dfs(vector<vector<char>> &grid, int n, int m, int i, int j)
+    {
+        if (i >= 0 && j >= 0 && i < n && j < m && grid[i][j] == '1')
+        {
+            grid[i][j] = '5';
+            dfs(grid, n, m, i - 1, j);     //top
+            dfs(grid, n, m, i + 1, j);     //down
+            dfs(grid, n, m, i, j - 1);     //left side
+            dfs(grid, n, m, i, j + 1);     //right side
+            dfs(grid, n, m, i - 1, j - 1); //north west
+            dfs(grid, n, m, i + 1, j + 1); //south east
+            dfs(grid, n, m, i - 1, j + 1); //north east
+            dfs(grid, n, m, i + 1, j - 1); //south west
+        }
+    }
+
+    int numIslands(vector<vector<char>> &grid)
+    {
+        int count = 0;
+        int n = grid.size();
+        int m = grid[0].size();
+
+        for (int i = 0; i < n; ++i)
+        {
+            for (int j = 0; j < m; ++j)
+            {
+                if (grid[i][j] == '1')
+                {
+                    dfs(grid, n, m, i, j);
+                    count++;
+                }
+            }
+        }
+
+        return count;
+    }
+};

GeeksForGeeks/Medium/Topological sort.cpp

@@ -0,0 +1,45 @@
+class Solution
+{
+public:
+    //Function to return list containing vertices in Topological order.
+    vector<int> topoSort(int V, vector<int> adj[])
+    {
+        vector<int> ans;
+        vector<int> inorder(V, 0);
+
+        for (int i = 0; i < V; ++i)
+        {
+            for (auto it : adj[i])
+            {
+                inorder[it]++;
+            }
+        }
+
+        queue<int> q;
+
+        for (int i = 0; i < V; ++i)
+        {
+            if (inorder[i] == 0)
+            {
+                q.push(i);
+            }
+        }
+
+        while (!q.empty())
+        {
+            int u = q.front();
+            ans.push_back(u);
+            for (auto v : adj[u])
+            {
+                inorder[v]--;
+                if (inorder[v] == 0)
+                {
+                    q.push(v);
+                }
+            }
+            q.pop();
+        }
+
+        return ans;
+    }
+};

Leet Code/C++/102. Binary Tree Level Order Traversal.cpp

@@ -0,0 +1,47 @@
+/**
+ * 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)
+    {
+        vector<vector<int>> ans;
+        vector<int> v;
+        if (root == nullptr)
+        {
+            return ans;
+        }
+        queue<TreeNode *> q;
+        q.push(root);
+        while (!q.empty())
+        {
+            int sz = q.size();
+            while (sz--)
+            {
+                TreeNode *curr = q.front();
+                v.push_back(curr->val);
+                q.pop();
+                if (curr->left)
+                {
+                    q.push(curr->left);
+                }
+                if (curr->right)
+                {
+                    q.push(curr->right);
+                }
+            }
+            ans.push_back(v);
+            v.clear();
+        }
+        return ans;
+    }
+};

Leet Code/C++/344. Reverse String.cpp

@@ -0,0 +1,15 @@
+class Solution
+{
+public:
+    void reverseString(vector<char> &s)
+    {
+        int last = s.size() - 1;
+        int first = 0;
+        while (first < last)
+        {
+            swap(s[first], s[last]);
+            first++;
+            last--;
+        }
+    }
+};