I added an imp application of DSU, No of Provinces (#920)

* added nqueens2

* added bfs hard prob

* dsu

* quick sort

* morris added

* vertical traversal

* modified quick sort

Author: diva-21

C++/Data Structure/Disjoint Set Union/no_of_provinces.cpp

@@ -0,0 +1,38 @@
+#include<bits/stdc++.h>
+using namespace std;
+class Solution {
+public:
+    // finding nod1->par equaility with nod2->par;
+    // to check whether their same component or not;
+    // if they are same locality then we count both as 1,
+    // else both are unique 
+    void dsu(int x,int y,vector<int>&par){
+        int p1=find(x,par),p2=find(y,par);
+        if(p1==p2) return;
+        else par[p1]=p2;
+    }
+    // checking their nodes vs parents
+    int find(int v,vector<int>&par){
+        if(par[v]==-1) return v;
+        return par[v]=find(par[v],par);
+    }
+    int findCircleNum(vector<vector<int>>& mat) {
+        int n=mat.size();
+        vector<int>par(n,-1);
+        for(int i=0;i<n;i++){
+            for(int j=0;j<n;j++){
+                if(mat[i][j]==1){
+                    dsu(i,j,par);
+                }
+            }
+        }
+        // find(); // parent finding
+        // together();
+        int c=0;
+        for(int i=0;i<n;i++){
+            if(par[i]==-1) c++;
+        }
+        return c;
+            
+    }
+};

C++/Data Structure/Trees/morris.cpp

@@ -0,0 +1,35 @@
+/* Tree Node
+struct Node {
+    int data;
+    Node* left;
+    Node* right;
+};*/
+#include<bits/stdc++.h>
+using namespace std;
+class Solution {
+public:
+    vector<int> inOrder(Node* root)
+    {
+        Node*cur=root;
+        vector<int>v;
+        //code here
+        while(cur){
+            if(!cur->left) {v.push_back(cur->data); cur=cur->right;}
+            else{
+                Node*pred=cur->left;
+                while(pred->right and pred->right!=cur) pred=pred->right;
+                if(!pred->right){
+                    pred->right=cur;
+                    cur=cur->left;
+                }
+                else{
+                    pred->right=NULL;
+                    v.push_back(cur->data);
+                    cur=cur->right;
+                }
+                
+            }
+        }
+        return v;
+    }
+};

C++/Data Structure/Trees/vertical_trav.cpp

@@ -0,0 +1,41 @@
+/**
+ * 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) {}
+ * };
+ */
+#include<bits/stdc++.h>
+using namespace std;
+class Solution {
+public:
+    vector<vector<int>> verticalTraversal(TreeNode* root) {
+        // map<vert,map<level,level vals>>
+        map<int,map<int,multiset<int>>>mp;
+        queue<pair<TreeNode*,pair<int,int>>>q; // node val, vert level;
+        q.push({root,{0,0}});
+        while(!q.empty()){
+            auto a=q.front(); // 3,0,0
+            q.pop();
+            TreeNode*ptr=a.first;
+            int vert=a.second.first,lev=a.second.second;
+            mp[vert][lev].insert(ptr->val);
+            if(ptr->left) q.push({ptr->left,{vert-1,lev+1}});
+            if(ptr->right) q.push({ptr->right,{vert+1,lev+1}});
+        }
+        vector<vector<int>>ans;
+        for(auto i:mp){
+            vector<int>v;
+            for(auto p:i.second){ // here i.second is int,multiset
+                // insert(pos,start and begin of another ds)
+                v.insert(v.end(),p.second.begin(),p.second.end());
+            }
+            ans.push_back(v);
+        }
+        return ans;
+    }
+};

Java/Algorithm/SortingAlgorithm/Quicksort_Recursive.java

@@ -0,0 +1,62 @@
+
+import java.util.*;
+class QuickSort
+{
+    // selects last element as pivot, pi using which array is partitioned.
+    int partition(int intArray[], int low, int high)
+    {
+        int pi = intArray[high];
+        int i = (low - 1); // smaller element index
+        for (int j = low; j < high; j++)
+        {
+            // check if current element is less than or equal to pi
+            if (intArray[j] <= pi)
+            {
+                i++;
+                // swap intArray[i] and intArray[j]
+                int temp = intArray[i];
+                intArray[i] = intArray[j];
+                intArray[j] = temp;
+            }
+        }
+        // swap intArray[i+1] and intArray[high] (or pi)
+        int temp = intArray[i + 1];
+        intArray[i + 1] = intArray[high];
+        intArray[high] = temp;
+        return i + 1;
+    }
+    // routine to sort the array partitions recursively
+    void quick_sort(int intArray[], int low, int high)
+    {
+        if (low < high)
+        {
+            // partition the array around pi=>partitioning index and return pi
+            int pi = partition(intArray, low, high);
+            // sort each partition recursively
+            quick_sort(intArray, low, pi - 1);
+            quick_sort(intArray, pi + 1, high);
+        }
+    }
+} 
+class Quicksort_Recursive
+{
+    public static void main(String args[])
+    {
+        Scanner sc = new Scanner(System.in);
+        System.out.println("enter array size");
+        int n = sc.nextInt();
+        int a[] = new int[n];
+        System.out.println("enter the elements of array ");
+        for (int i = 0; i < n; i++)
+        {
+            a[i] = sc.nextInt();
+        }
+        // print the original array
+        System.out.println("Original Array: " + Arrays.toString(a));
+        // call quick_sort routine using QuickSort object
+        QuickSort obj = new QuickSort();
+        obj.quick_sort(a, 0, n - 1);
+        // print the sorted array
+        System.out.println("Sorted Array: " + Arrays.toString(a));
+    }
+}