Adding the solution for Redundant Connection (codedecks-in#136)

* Added a Leetcode solution for Valid Sudoku

* Added Solution code and Editorial-readme

* Added problem in readme

* Added editorial for the problem

* Added image for editorial

* Added editorial Image

Author: SauravP97

Java/Redundant-Connection/README.md

@@ -0,0 +1,39 @@
+# Redundant Connection
+
+> **Problem Link** : [Redundant Connection (LeetCode)](https://leetcode.com/problems/redundant-connection/) <br>
+> **Concepts Involved** : *Tree, Disjoint Union Set* 
+
+## Problem Statement
+We have been provided with a list of edges. These edges form a Tree. The list has one extra edge as well. We have to find that extra edge which if removed from the list makes the resulting list of edges a Tree of N nodes.
+
+## Solution
+<p>
+We have been given with a list of edges. Now we need to remove one edge from the List so that the resultant list forms a Tree. Basically a Tree can be termed as a special Graph where every nodes are connected to one another directly or indirectly and there no loops present. As there is only one extra edge, then it must join two nodes which are already connected. And we neeed to find that particular edge.
+</p>
+<p>
+The basic idea is to use a Disjoint Union Sets here. We will iterate over the list of edges and for every edge <b>(u,v)</b> we will put u and v in a single set. If during the iteration we find an edge such that both the nodes u and v is in the same set, then we can say that it is an extra edge which can be removed. We can store that as our result and return it after the iteration.
+</p>
+
+![Editorial Image](./images/image-1.png)
+
+<p>
+The basic source code for the problem looks like :
+
+```
+    for each (edge in edge_list) :
+        if(same_set(edge.u, edge.v)){
+            extra_node_u = edge.u
+            extra_node_v = edge.v
+        }
+        else{
+            put_in_same_set(edge.u, edge.v)
+        }
+    }  
+```
+</p>
+
+## Complexity
+  * The solution Time Complexity is : ***O(N)***
+  * The solution Space Complexity is : ***O(N)***
+  
+> **Author's Note** : I would highly encourage readers to learn the Disjoint Set Union data structure before attempting the question from [here](https://www.geeksforgeeks.org/union-find/).

Java/Redundant-Connection/images/image-1.png

@@ -0,0 +1,59 @@
+/** 
+ *  Problem Name : Redundant Connection
+ *  Concept Involved : Trees, Union Find
+ * 
+ *  Execution Time : 1 ms
+ *  Memory Consumed : 39 mb
+**/
+
+class DUS{
+    public int[] parent;
+    public int n;
+    
+    DUS(int n){
+        this.n = n;
+        parent = new int[n];
+        for(int i=0; i<n; i++){
+            parent[i] = i;
+        }
+    }
+    
+    public int find(int u){
+        if(parent[u] != u){
+            parent[u] = find(parent[u]);
+        }
+        return parent[u];
+    }
+    
+    public void union(int u, int v){
+        int pu = find(u);
+        int pv = find(v);
+        
+        if(pu != pv){
+            parent[pv] = pu;
+        }
+    }
+}
+class Solution {
+    public int[] findRedundantConnection(int[][] edges) {
+        int[] res = new int[2];
+        DUS dus = new DUS(edges.length+1);
+        
+        for(int i=0; i<edges.length; i++){
+            int u = edges[i][0];
+            int v = edges[i][1];
+            int pu = dus.find(u);
+            int pv = dus.find(v);
+            
+            if(pu != pv){
+                dus.union(u,v);    
+            }
+            else{
+                res[0] = u;
+                res[1] = v;
+            }
+        }
+        
+        return res;
+    }
+}

Java/Redundant-Connection/redundant-connection.java

@@ -236,6 +236,7 @@ Check out ---> [Sample PR](https://github.com/codedecks-in/LeetCode-Solutions/pu
 | 1028 | [Recover a Tree From Preorder Traversal](https://leetcode.com/problems/recover-a-tree-from-preorder-traversal/) | [C++](./C++/Recover-a-Tree-From-Preorder-Traversal.cpp)                                                          | _O(n)_      | _O(n)_      | Hard       | Tree                                           |      |
 | 968  | [Binary Tree Cameras](https://leetcode.com/problems/binary-tree-cameras/)                                       | [C++](./C++/Binary-Tree-Cameras.cpp)                                                                             | _O(n)_      | _O(logn)_   | Hard       | Binary Tree, Dynamic Programming               |
 | 98   | [Validate Binary Search Tree](https://leetcode.com/problems/validate-binary-search-tree/)                       | [Javascript](./JavaScript/98.Validate-Binary-Search-Tree.js)                                                     | _O(log(n))_ | _O(log(n))_ | Medium     | Binary Tree                                    |
+| 684   | [Redundant Connection](https://leetcode.com/problems/redundant-connection/)                       | [Java](./Java/Redundant-Connection/redundant-connection.java)                                                     | _O(N)_ | _O(N)_ | Medium     | Tree, Union Find                                    |
 
 <br/>
 <div align="right">