GFG and LeetCode

Author: harshit2608

GeeksForGeeks/Easy/BFS of graph.cpp

@@ -0,0 +1,30 @@
+class Solution
+{
+public:
+    //Function to return Breadth First Traversal of given graph.
+    vector<int> bfsOfGraph(int V, vector<int> adj[])
+    {
+        int visited[V + 1];
+        vector<int> ans;
+        memset(visited, 0, sizeof(visited));
+        queue<int> q;
+        q.push(0);
+        visited[0] = 1;
+        while (!q.empty())
+        {
+            int node = q.front();
+            ans.push_back(node);
+            q.pop();
+            for (auto v : adj[node])
+            {
+                if (!visited[v])
+                {
+                    visited[v] = 1;
+                    q.push(v);
+                }
+            }
+        }
+
+        return ans;
+    }
+};

GeeksForGeeks/Easy/DFS of Graph.cpp

@@ -0,0 +1,26 @@
+class Solution
+{
+public:
+    //Function to return a list containing the DFS traversal of the graph.
+    void dfs(vector<int> adj[], int v, int visited[], vector<int> &ans)
+    {
+        visited[v] = 1;
+        ans.push_back(v);
+        for (auto i : adj[v])
+        {
+            if (visited[i] == false)
+            {
+                dfs(adj, i, visited, ans);
+            }
+        }
+    }
+
+    vector<int> dfsOfGraph(int V, vector<int> adj[])
+    {
+        int visited[V];
+        memset(visited, 0, sizeof(visited));
+        vector<int> ans;
+        dfs(adj, 0, visited, ans);
+        return ans;
+    }
+};

GeeksForGeeks/Easy/Kth largest element in BST.cpp

@@ -0,0 +1,25 @@
+// return the Kth largest element in the given BST rooted at 'root'
+class Solution
+{
+public:
+    void inorder(Node *root, int &k, int &ans)
+    {
+        if (root == NULL)
+            return;
+        inorder(root->right, k, ans);
+        k--;
+        if (k == 0)
+        {
+            ans = root->data;
+            return;
+        }
+        inorder(root->left, k, ans);
+    }
+
+    int kthLargest(Node *root, int K)
+    {
+        int ans = 0;
+        inorder(root, K, ans);
+        return ans;
+    }
+};

GeeksForGeeks/Medium/Detect cycle in a directed graph.cpp

@@ -0,0 +1,38 @@
+class Solution
+{
+public:
+    //Function to detect cycle in a directed graph.
+    bool dfs(vector<int> adj[], bool visited[], bool recStack[], int src)
+    {
+        visited[src] = true;
+        recStack[src] = true;
+        for (int it : adj[src])
+        {
+            if (recStack[it])
+            {
+                return true;
+            }
+            else if (!visited[it] && dfs(adj, visited, recStack, it))
+            {
+                return true;
+            }
+        }
+        recStack[src] = false;
+        return false;
+    }
+
+    bool isCyclic(int V, vector<int> adj[])
+    {
+        bool visited[V] = {false};
+        bool recStack[V] = {false};
+
+        for (int i = 0; i < V; ++i)
+        {
+            if (!visited[i] && dfs(adj, visited, recStack, i))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+};

GeeksForGeeks/Medium/Detect cycle in an undirected graph.cpp

@@ -0,0 +1,37 @@
+class Solution
+{
+public:
+    //Function to detect cycle in an undirected graph.
+    bool dfs(vector<int> adj[], int src, vector<bool> &visited, int parent)
+    {
+        visited[src] = true;
+        for (auto j : adj[src])
+        {
+            if (!visited[j])
+            {
+                if (dfs(adj, j, visited, src))
+                {
+                    return true;
+                }
+            }
+            else if (j != parent)
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    bool isCycle(int V, vector<int> adj[])
+    {
+        vector<bool> visited(V);
+        for (int i = 0; i < V; ++i)
+        {
+            if (!visited[i] && dfs(adj, i, visited, -1))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+};

Leet Code/C++/617. Merge Two Binary Trees.cpp

@@ -0,0 +1,30 @@
+/**
+ * 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:
+    TreeNode *mergeTrees(TreeNode *root1, TreeNode *root2)
+    {
+        if (root1 == nullptr)
+        {
+            return root2;
+        }
+        if (root2 == nullptr)
+        {
+            return root1;
+        }
+        root1->val = root1->val + root2->val;
+        root1->left = mergeTrees(root1->left, root2->left);
+        root1->right = mergeTrees(root1->right, root2->right);
+        return root1;
+    }
+};