diff --git a/sorting/1.cpp b/sorting/1.cpp
new file mode 100644
index 0000000..72a3211
--- /dev/null
+++ b/sorting/1.cpp
@@ -0,0 +1,79 @@
+//InPlace-Algorithm.......
+
+
+
+//Bubble Sort
+//This algorithm is used to swap two adjacent elements one by one untill and unless we get the sorted array.
+//Stable
+
+#include<bits/stdc++.h>
+using namespace std;
+
+//Time Complexity is O(n**2)........
+
+void bubble_sort(int *a,int n)
+{
+    for(int i=0;i<n-1;i++)
+    {
+        int temp=true;
+        for(int j=0;j<n-i-1;j++)
+        {
+            if(a[j]>a[j+1]){
+                swap(a[j],a[j+1]);
+                temp=false;
+            }
+        }
+        if(temp)
+            break;
+    }
+
+}
+//Selection sort
+//This Algorthim is used to find the min index at every iteration and swap the current element with the minimum element.
+//Unstable
+//Time Complexity is O(n**2)...........
+
+void selection_sort(int *a,int n)
+{
+    for(int i=0;i<n-1;i++)
+    {
+        int min_index=i;
+        for(int j=i+1;j<n;j++)
+        {
+            if(a[min_index]>a[j])
+                min_index=j;
+        }
+        swap(a[i],a[min_index]);
+    }
+}
+//Insertion sort
+//This algortith is used to place the current element at correct position and then it will place all lesser element before the current element.
+//stable........
+
+//Time Complexity is O(n**2)......
+void insertion_sort(int *a,int n)
+{
+    for(int i=1;i<n;i++)
+    {
+        int temp=a[i],j;
+        for(j=i-1;j>=0 && a[j]>temp;j--)
+            a[j+1]=a[j];
+        a[j+1]=temp;
+    }
+}
+int main()
+{
+    int a[]={5,4,3,2,1};
+    bubble_sort(a,5);
+    for(int i=0;i<5;i++)
+        cout<<a[i]<<" ";
+    cout<<endl;
+    selection_sort(a,5);
+    for(int i=0;i<5;i++)
+        cout<<a[i]<<" ";
+    cout<<endl;
+    insertion_sort(a,5);
+    for(int i=0;i<5;i++)
+        cout<<a[i]<<" ";
+        return 0;
+}
diff --git a/sorting/10.cpp b/sorting/10.cpp
new file mode 100644
index 0000000..a8003e1
--- /dev/null
+++ b/sorting/10.cpp
@@ -0,0 +1,83 @@
+//Counting sort.........
+
+//This algorthim is used to sort the elements which are in range of [1,k].....
+
+//We will first count the frequenecy of all elements in the another array.
+//Now,We will find the cummulative frequency of all elements then we will place the correct element at correct position...
+
+//Not a Comparison based Algorithm........
+
+//Time Complexity is Theta(n+k)......
+
+//Auxiliary space is Theta(n+k).....
+
+//Stable
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+//Method 1
+//Naive-Implementation.....
+
+//Time Complexity is O(n+k)...................
+
+void count_sort_1(int *a,int n,int k)
+{
+    int temp[k]={0};
+    int index=0;
+    for(int i=0;i<n;i++)
+    {
+        temp[a[i]]++;
+    }
+    for(int i=0;i<k;i++)
+    {
+        for(int j=0;j<temp[i];j++)
+        {
+            a[index]=i;
+            index++;
+        }
+    }
+    for(int i=0;i<n;i++)
+        cout << a[i] <<" ";
+}
+
+//Method 2
+void counting_sort(int *a,int n,int k)
+{
+    int count[k];
+    for(int i=0;i<k;i++)
+    {
+        count[i]=0;
+    }
+    for(int i=0;i<n;i++)
+    {
+        count[a[i]]++;
+    }
+    for(int i=1;i<k;i++)
+    {
+        count[i]=count[i-1]+count[i];
+    }
+    int output[n];
+    for(int i=n-1;i>=0;i--)
+    {
+        output[count[a[i]-1]]=a[i];
+        count[a[i]]--;
+    }
+    for(int i=0;i<n;i++)
+    {
+        a[i]=output[i];
+    }
+    for(int i=0;i<n;i++)
+        cout << output[i] <<" ";
+}
+
+int main()
+{
+    int a[]={1,4,4,1,0,1};
+    //count_sort_1(a,6,5);
+    //cout<<endl;
+    counting_sort(a,6,5);
+    return 0;
+}
diff --git a/sorting/11.cpp b/sorting/11.cpp
new file mode 100644
index 0000000..c89e47f
--- /dev/null
+++ b/sorting/11.cpp
@@ -0,0 +1,53 @@
+//Bucket sort
+//This algorithm is used when the data is uniformaly distributed.
+//we will divide all the elements into K buckets.
+//But we have to find the maximum element in original array to get the bucket index.Once we get the Bucket index,we will push the values into bucket array or vector.
+//We sort the Bucket vector then we will place the sorted elements into original array...
+//Time Complexity
+
+//Data is uniformly distributed....
+//best case is O(n).....
+
+//When data is not uniformly distributed....
+//worst case O(n**2)..........
+
+#include<bits/stdc++.h>
+using namespace std;
+
+void bucket_sort(int *a,int total_bucket,int n)
+{
+    int m=a[0];
+    for(int i=1;i<n;i++)
+        m=max(m,a[i]);
+    m=m+1;
+    vector<int>buckets[total_bucket];
+    for(int i=0;i<n;i++)
+    {
+        int bucket_index=a[i]*total_bucket/m;
+        buckets[bucket_index].push_back(a[i]);
+
+    }
+    for(int i=0;i<total_bucket;i++)
+    {
+        sort(buckets[i].begin(),buckets[i].end());
+
+    }
+    //Finally concatination
+    int index=0;
+    for(int i=0;i<total_bucket;i++)
+    {
+        for(int j=0;j<buckets[i].size();j++)
+        {
+            a[index++]=buckets[i][j];
+        }
+    }
+
+}
+int main()
+{
+    int a[]={30,40,10,80,5,12,70};
+    bucket_sort(a,4,7);
+    for(int i=0;i<7;i++)
+        cout<<a[i]<<" ";
+    return 0;
+}
diff --git a/sorting/12.cpp b/sorting/12.cpp
new file mode 100644
index 0000000..b6533af
--- /dev/null
+++ b/sorting/12.cpp
@@ -0,0 +1,59 @@
+#include<bits/stdc++.h>
+using namespace std;
+//Radix sort
+//This algorthim is the extended version of counting sort because the data may be is  in the range of 1 to k**2,that's why we use this algorithm insteed of using Counting sort.
+//In this algorithm we will sort the array acc.to digits.
+//We will first sort it acc to least significant digit ,then sort it acc to middle digit and finally sort it acc to  most significant digit.
+//The whole logic is similar to counting sort......
+
+//Time Complexity is Theta(d*(n+b))........
+//b is the base
+//here b=10;
+//Auxiliary space is Theta(n+b)..........
+
+//counting-sort
+void counting_sort(int *a,int n,int exp)
+{
+    int count[10]={0};
+    for(int i=0;i<n;i++)
+    {
+        count[(a[i]/exp)%10]++;
+    }
+    for(int i=1;i<10;i++)
+    {
+        count[i]+=count[i-1];
+    }
+    int output[n];
+    for(int i=n-1;i>=0;i--)
+    {
+        output[count[(a[i]/exp)%10]-1]=a[i];
+        count[(a[i]/exp)%10]--;
+    }
+    for(int i=0;i<n;i++)
+    {
+        a[i]=output[i];
+    }
+}
+void radix_sort(int *a,int n)
+{
+    int m=a[0];
+    for(int i=1;i<n;i++)
+        m=max(m,a[i]);
+
+    //Run loop through  number of digits in a maximum number .......
+
+    for(int exp=1;m/exp>0;exp=exp*10)
+    {
+        counting_sort(a,n,exp);
+    }
+    for(int i=0;i<n;i++)
+    {
+        cout<<a[i]<<" ";
+    }
+}
+int main()
+{
+    int a[]={319,212,6,8,100,50};
+    radix_sort(a,6);
+    return 0;
+}
diff --git a/sorting/13.cpp b/sorting/13.cpp
new file mode 100644
index 0000000..4d32cba
--- /dev/null
+++ b/sorting/13.cpp
@@ -0,0 +1,62 @@
+//Find the Kth smallest Element.....
+
+#include<bits/stdc++.h>
+using namespace std;
+
+//Method1...........
+//Time Complexity is O(n*log(n)).........
+
+int find_k_element(int *a,int n,int k)
+{
+    return a[k-1];
+}
+
+//Method2............
+int find_pivot(int *a,int l,int h)
+{
+    int k=l-1;
+    int pivot=a[h];
+    for(int i=l;i<h;i++)
+    {
+        if(a[i] <  pivot)
+        {
+            k++;
+            swap(a[k],a[i]);
+        }
+    }
+    swap(a[k+1],a[h]);
+    return k+1;
+}
+int find_pos_k(int *a,int n,int k)
+{
+    int low=0;
+    int high=n-1;
+    while(low<=high)
+    {
+
+        int p=find_pivot(a,low,high);
+        if(p==k-1)
+            return p;
+        if(k-1 > p)
+        {
+            low=p+1;
+        }
+        else if(k-1 < p)
+        {
+            high=p-1;
+        }
+    }
+    return -1;
+}
+
+int main()
+{
+    int a[] = { 51, 86, 34, 79, 92, 68, 14, 47, 22, 6};
+    sort(a,a+10);
+    cout << find_k_element(a,5,2) << endl;
+        for(int i=0;i<10;i++)
+        {
+            cout << a[find_pos_k(a,10,i+1)]<<" ";
+        }
+    return 0;
+}
diff --git a/sorting/14.cpp b/sorting/14.cpp
new file mode 100644
index 0000000..68aad9e
--- /dev/null
+++ b/sorting/14.cpp
@@ -0,0 +1,23 @@
+//Chocolate Distribution Problem......
+
+#include<bits/stdc++.h>
+using namespace std;
+
+//Time complexity is O(n*log(n))......
+
+int difference_chocolate(int *a,int n,int m)
+{
+    int ans=INT_MAX;
+    for(int i=0;i<=n-m;i++)
+    {
+        ans=min(ans,a[m+i-1]-a[i]);
+    }
+    return ans;
+}
+int main()
+{
+    int a[]={3,4,1,9,56,7,9,12};
+    sort(a,a+8);
+    cout << difference_chocolate(a,8,5);
+    return 0;
+}
diff --git a/sorting/15.cpp b/sorting/15.cpp
new file mode 100644
index 0000000..5a163e5
--- /dev/null
+++ b/sorting/15.cpp
@@ -0,0 +1,60 @@
+//Sort an array with two elements.......
+//Segregate negative or positive elements........
+
+#include<bits/stdc++.h>
+using namespace std;
+
+//Naive Method........
+
+void sort_two(int *a,int n)
+{
+    int temp[n],index=0;
+
+    for(int i=0;i<n;i++)
+    {
+      if(a[i] < 0)
+      {
+          temp[index]=a[i];
+          index++;
+      }
+    }
+
+    for(int i=0;i<n;i++)
+    {
+      if(a[i] >=0)
+      {
+          temp[index]=a[i];
+          index++;
+      }
+    }
+    for(int i=0;i<n;i++)
+    {
+      a[i]=temp[i];
+    }
+}
+//efficient method.....
+void sort_2(int *a,int n)
+{
+    int i=-1;
+    int j=n;
+    while(true)
+    {
+        do{i++;}while(a[i]<0);
+
+        do{j--;}while(a[j]>=0);
+        if(i>=j)
+            return;
+        swap(a[i],a[j]);
+    }
+}
+int main()
+{
+    int a[]={15,-3,-2,16,-3,-2,15,16};
+    //sort_two(a,8);
+    sort_2(a,8);
+    for(int i=0;i<8;i++)
+    {
+        cout << a[i] <<" ";
+    }
+    return 0;
+}
diff --git a/sorting/16.cpp b/sorting/16.cpp
new file mode 100644
index 0000000..f80282b
--- /dev/null
+++ b/sorting/16.cpp
@@ -0,0 +1,80 @@
+//Sort an array of three types of elements.........
+
+#include<bits/stdc++.h>
+using namespace std;
+
+//Naive Method.........
+void sort_3(int *a,int n)
+{
+    int temp[n];
+    int index=0;
+    for(int i=0;i<n;i++)
+    {
+        if(a[i]==0)
+        {
+            temp[index]=a[i];
+            index++;
+        }
+    }
+
+    for(int i=0;i<n;i++)
+    {
+        if(a[i]==1)
+        {
+            temp[index]=a[i];
+            index++;
+        }
+    }
+
+    for(int i=0;i<n;i++)
+    {
+        if(a[i]==2)
+        {
+            temp[index]=a[i];
+            index++;
+        }
+    }
+    for(int i=0;i<n;i++)
+    {
+        a[i]=temp[i];
+    }
+}
+//Efficient Solution......
+
+void sort_effiecient(int *a,int n)
+{
+    int l,h,m;
+    l=0;
+    m=0;
+    h=n-1;
+
+    while (m<=h)
+    {
+        switch(a[m])
+        {
+        case 0:
+            swap(a[l],a[m]);
+            l++;
+            m++;
+            break;
+        case 1:
+            m++;
+            break;
+        case 2:
+            swap(a[m],a[h]);
+            h--;
+            break;
+        }
+    }
+}
+int main()
+{
+    int a[]={0,1,1,2,0,1,1,2,2};
+    //sort_3(a,8);
+    sort_effiecient(a,9);
+    for(int i=0;i<8;i++)
+        cout <<a[i]<<" ";
+    return 0;
+}
+
+
diff --git a/sorting/17.cpp b/sorting/17.cpp
new file mode 100644
index 0000000..f550c59
--- /dev/null
+++ b/sorting/17.cpp
@@ -0,0 +1,36 @@
+//you are given arrival and departure times of the guests, you need to find the time to go to the party so that you can meet maximum people.
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int find_time(int a[],int n,int b[],int m)
+{
+    int i,ma=1,j;
+    i=1;
+    j=0;
+    int count=1;
+    while(i < n && j<m)
+    {
+        if(a[i]<=b[j])
+        {
+            i++;
+            count++;
+        }
+        else
+        {
+            j++;
+            count--;
+        }
+        ma=max(count,ma);
+    }
+    return ma;
+}
+int main()
+{
+    int arrival[]={900,600,700};
+    int departure[]={1000,800,730};
+    sort(arrival,arrival+3);
+    sort(departure,departure+3);
+    cout << find_time(arrival,3,departure,3);
+    return 0;
+}
diff --git a/sorting/18.cpp b/sorting/18.cpp
new file mode 100644
index 0000000..3238a9a
--- /dev/null
+++ b/sorting/18.cpp
@@ -0,0 +1,37 @@
+//Merge Overlapping intervals....
+#include<bits/stdc++.h>
+using namespace std;
+struct interval
+{
+    int start,end;
+};
+
+void merge_interval(struct interval arr[],int n)
+{
+    int res=0;
+    for(int i=1;i<n;i++)
+    {
+        if(arr[res].end>=arr[i].start)
+        {
+            arr[res].start=min(arr[res].start,arr[i].start);
+            arr[res].end=max(arr[res].end,arr[i].end);
+        }
+        else{
+            res++;
+            arr[res]=arr[i];
+        }
+    }
+    for(int i=0;i<=res;i++)
+        cout << arr[i].start <<" " << arr[i].end <<endl;
+}
+bool compare(interval a,interval b)
+{
+    return a.start < b.end;
+}
+int main()
+{
+    interval arr[]={ {5,10}, {3,15}, {18,30}, {2,7} };
+    sort(arr,arr+4,compare);
+    merge_interval(arr,4);
+    return 0;
+}
diff --git a/sorting/2.cpp b/sorting/2.cpp
new file mode 100644
index 0000000..83fb340
--- /dev/null
+++ b/sorting/2.cpp
@@ -0,0 +1,88 @@
+//Merge-sort
+
+//This algorithm is used to sort the orignal array by divide it into two equal parts and then again apply the merge sort logic to both left array as well as right array.
+//We will first find the middle point then well call merge function for left array and right array.
+//Then we wil merge the left array and right array untill and unless we get the sorted array.
+//Divide and Conquer algorithm..
+
+//Stable algorithm.....
+
+//Time Complexity is :
+//Theta(n*log(n))
+
+//Auxiliary space is:
+//O(n).........
+
+//Best suited for Linked list...
+//Works in  o(1)............
+
+//used in external sort............
+
+#include<bits/stdc++.h>
+using namespace std;
+
+void merge(int *a,int start,int mid,int end)
+{
+    int n1=mid-start+1;
+    int n2=end-mid;
+    int temp[n1],temp2[n2];
+    for(int i=0;i<n1;i++)
+    {
+        temp[i]=a[start+i];
+    }
+    for(int j=0;j<n2;j++)
+    {
+        temp2[j]=a[mid+j+1];
+    }
+    int i,j,k=start;
+    i=j=0;
+    while(i<n1 && j<n2)
+    {
+        if(temp[i]<=temp2[j])
+        {
+            a[k]=temp[i];
+            i++;
+        }
+        else
+        {
+            a[k]=temp2[j];
+            j++;
+        }
+        k++;
+    }
+    while(i<n1)
+    {
+         a[k]=temp[i];
+            i++;
+            k++;
+    }
+
+    while(j<n2)
+    {
+         a[k]=temp2[j];
+            j++;
+            k++;
+    }
+}
+
+void merge_sort(int *a,int start,int end)
+{
+    if(start < end)
+    {
+        int mid=start +(end-start)/2;
+        merge_sort(a,start,mid);
+        merge_sort(a,mid+1,end);
+        merge(a,start,mid,end);
+    }
+}
+
+int main()
+{
+    int a[]={10,9,8,7,6,5,4,3,2,1};
+    merge_sort(a,0,9);
+    for(int i=0;i<10;i++)
+        cout<<a[i]<<" ";
+    return 0;
+}
+
+
diff --git a/sorting/3.cpp b/sorting/3.cpp
new file mode 100644
index 0000000..e6221e4
--- /dev/null
+++ b/sorting/3.cpp
@@ -0,0 +1,57 @@
+//Intersection of two sorted arrays..
+
+#include<bits/stdc++.h>
+using namespace std;
+
+//Method-1
+//Naive-solution.....
+//Time complexity is O(n1*n2)............
+void find_intersect(int *a,int *b,int n1,int n2)
+{
+    for(int i=0;i<n1;i++)
+    {
+        if(i>0 && a[i]==a[i-1])
+            continue;
+        for(int j=0;j<n2;j++)
+        {
+            if(a[i]==b[j])
+            {
+                cout << a[i]<<" ";
+            }
+        }
+    }
+}
+
+//Method2---------
+//Time Complexity is O(n1+n2)...........
+
+void find_intersect_1(int *a,int *b,int n1,int n2)
+{
+    int i=0,j=0;
+    while(i < n1 && j<n2)
+    {
+        if(a[i]==a[i-1] && i>0){
+                i++;
+            continue;
+        }
+        if(b[j] > a[i])
+        {
+            i++;
+        }
+        else if(a[i]>b[j])
+            j++;
+        else
+        {
+            cout << a[i] <<" ";
+            i++;j++;
+        }
+    }
+}
+int main()
+{
+    int a[]={3,5,10,10,10,15,15,20};
+    int b[]={5,10,10,15,30};
+    find_intersect(a,b,8,5);
+    cout<<endl;
+    find_intersect_1(a,b,8,5);
+}
diff --git a/sorting/4.cpp b/sorting/4.cpp
new file mode 100644
index 0000000..7a870fb
--- /dev/null
+++ b/sorting/4.cpp
@@ -0,0 +1,103 @@
+//Union of two sorted array...
+
+//Method 1
+//Time complexity is O(m+n*log(m+n))......
+//Auxiliary space is O(m+n).......
+
+#include<bits/stdc++.h>
+using namespace std;
+
+//Method 1
+//Time complexity is O(m+n)......
+//Auxiliary space is O(m+n).........
+void find_union(int *a,int *b,int m,int n)
+{
+    int temp[m+n];
+    int p=m+n;
+    for(int i=0;i<m;i++)
+    {
+        temp[i]=a[i];
+    }
+    for(int i=0;i<n;i++)
+    {
+        temp[i+m]=b[i];
+    }
+    sort(temp,temp+p);
+    for(int i=0;i<p;i++)
+    {
+        if(i==0 || temp[i]!=temp[i-1])
+            cout << temp[i]<<" ";
+    }
+
+}
+
+//Method 2
+//Time complexity is O(m+n)......
+//Auxiliary space is O(1)....................
+
+
+
+void find_union_1(int *a,int *b,int m,int n)
+{
+    int i=0;
+    int j=0;
+    while(i < n && j<m)
+    {
+        if(a[j]==a[j-1] && j>0)
+        {
+            j++;
+            continue;
+        }
+        if(b[i]==b[i-1] && i>0)
+        {
+            i++;
+            continue;
+        }
+        if(a[j] > b[i])
+        {
+            cout << b[i]<<" ";
+            i++;
+        }
+        else if(b[i] > a[j])
+        {
+            cout << a[j]<<" ";
+            j++;
+        }
+        else
+        {
+            cout << a[j] <<" ";
+            i++;
+            j++;
+        }
+
+    }
+    while(i < n)
+    {
+        if(b[i]!=b[i-1] || i==0)
+        {
+            cout << b[i] <<" ";
+            i++;
+
+        }
+    }
+    while( j < m)
+    {
+        if(a[j]!=a[j-1] || j==0)
+        {
+            cout << a[j] <<" ";
+            j++;
+
+        }
+
+    }
+}
+
+
+int main()
+{
+    int a[]={3,8,10};
+    int b[]={2,8,9,10,15};
+    find_union(a,b,3,5);
+    cout << endl;
+    find_union_1(a,b,3,5);
+}
diff --git a/sorting/5.cpp b/sorting/5.cpp
new file mode 100644
index 0000000..a69c629
--- /dev/null
+++ b/sorting/5.cpp
@@ -0,0 +1,95 @@
+//Count Inversions in Array...............
+//two elements a[i] and a[j] form an inversion if a[i] > a[j] and i < j
+
+//Method 1
+//Naive Solution...
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int count_inversion(int *a,int n)
+{
+    int count=0;
+    for(int i=0;i<n-1;i++)
+    {
+        for(int j=i+1;j<n;j++)
+        {
+            if(a[i] > a[j])
+                count++;
+        }
+    }
+    return count;
+}
+//Method2......
+//Time Complexity is O(n*log n)................
+//Aux space is O(n)...........
+int merge(int *a,int l,int m,int h)
+{
+    int n1=m-l+1;
+    int n2=h-m;
+    int left[n1];
+    int right[n2];
+    for(int i=0;i<n1;i++)
+    {
+        left[i]=a[i+l];
+    }
+    for(int i=0;i<n2;i++)
+    {
+        right[i]=a[m+i+1];
+    }
+    int i,j,k;
+    i=j=0;
+    k=l;
+    int c=0;
+    while(i < n1 && j < n2)
+    {
+        if(left[i]<=right[j])
+        {
+            a[k]=left[i];
+            i++;
+        }
+        else{
+            a[k]=right[j];
+            j++;
+            c=c+(n1-i);
+        }
+        k++;
+    }
+    while(i < n1)
+    {
+        a[k]=left[i];
+        i++;
+        k++;
+    }
+    while(j < n2)
+    {
+        a[k]=right[j];
+        j++;
+        k++;
+    }
+    return c;
+
+}
+int count_inversion_eff(int *a,int l,int h)
+{
+    int res=0;
+    if(l < h)
+    {
+        int m=l+(h-l)/2;
+        res+=count_inversion_eff(a,l,m);
+        res+=count_inversion_eff(a,m+1,h);
+        res+=merge(a,l,m,h);
+    }
+    return res;
+
+}
+
+
+
+int main()
+{
+    int a[]={10,9,8,7,6,5,4,3,2,1};
+    cout << count_inversion(a,10) << endl;
+    cout << count_inversion_eff(a,0,9);
+    return 0;
+}
diff --git a/sorting/6.cpp b/sorting/6.cpp
new file mode 100644
index 0000000..0580b45
--- /dev/null
+++ b/sorting/6.cpp
@@ -0,0 +1,97 @@
+#include<bits/stdc++.h>
+using namespace std;
+//Quick sort
+//In this alorithm we find the pivot point then partitioning the array such that all elements  are smaller than pivot and all elements are greater than pivot.
+//To find the Pivot,we will consider three method.
+//1.Naive partition 
+//2.Lumotu partition
+//3.hoor's partition
+//Method1
+//Naive partition..........
+//Time Complexity is O(n).......
+//Auxiliary Space is O(n)......
+
+void partition(int *a,int l,int h,int p)
+{
+    int temp[h-l+1];
+    int index=0;
+    for(int i=l;i<=h;i++)
+    {
+        if(a[i] <=a[p])
+        {
+            temp[index]=a[i];
+            index++;
+        }
+    }
+    for(int i=l;i<=h;i++)
+    {
+        if(a[i]>a[p])
+        {
+            temp[index]=a[i];
+            index++;
+        }
+    }
+    for(int i=l;i<=h;i++)
+    {
+        a[i]=temp[i-l];
+        cout << a[i] <<" ";
+    }
+}
+
+//Method 2........
+//Time Complexity is O(n)...
+//Auxiliary space is o(1)...........
+//Lomuto Partition.......
+// We assumed the pivot element is the last-element................
+
+int partition_1(int *a,int l,int h)
+{
+    int pivot=a[h];
+    int j=l-1;
+    for(int i=l;i<h;i++)
+    {
+        if(a[i]<pivot)
+        {
+            j++;
+            swap(a[i],a[j]);
+        }
+    }
+    swap(a[j+1],a[h]);
+    return j+1;
+}
+//Method 3........
+//Time Complexity is O(n)...
+//Auxiliary space is o(1)...........
+//Hoore's Partition.......
+// We assumed the pivot element is the first-element................
+
+int partition_2(int *a,int l,int h)
+{
+    int start=l-1;
+    int end=h+1;
+    int pivot=a[0];
+    while(true)
+    {
+        do
+        {
+            start++;
+        }while(a[start]<pivot);
+
+        do
+        {
+            end--;
+        }while(a[end] > pivot);
+        if(start>=end)
+            return end;
+        swap(a[start],a[end]);
+    }
+}
+
+int main()
+{
+    int a[]={5,3,8,4,2,7,1,10};
+    partition(a,0,6,6);
+    cout<<endl;
+    cout << partition_1(a,0,6) << endl;
+    cout << partition_2(a,0,6);
+}
diff --git a/sorting/7.cpp b/sorting/7.cpp
new file mode 100644
index 0000000..1c46344
--- /dev/null
+++ b/sorting/7.cpp
@@ -0,0 +1,88 @@
+//Quick sort
+//Divide and Conquer
+//Key part is Partitioning (Hoore,Lomoto,Naive)
+//Worst Time Complexity is O(n**2).....//we can avoid this by using random partitioning.........
+//Despite having higher worst case time,it is preferred over other algorithm many times due to following reasons..........
+// 1.Tail Recursive
+// 2.In-place
+// 3.Cache-friendly.....
+// 4.Best and Average Case :Theta(n*log(n))............
+
+
+//Auxiliary space :
+//Best case and Average Case:O(log(n)).........
+//Worst case is O(n).............
+#include<bits/stdc++.h>
+using namespace std;
+//Using Lomuto-Partitioning
+
+int lomuto_parition(int *a,int l,int h)
+{
+    int k=l-1;
+    int pivot=a[h];
+    for(int i=l;i<h;i++)
+    {
+        if(a[i] < pivot)
+        {
+            k++;
+            swap(a[i],a[k]);
+        }
+    }
+    swap(a[k+1],a[h]);
+    return (k+1);
+}
+void quick_sort(int *a,int l,int h)
+{
+    if(h > l)
+    {
+        int p=lomuto_parition(a,l,h);
+        quick_sort(a,l,p-1);
+        quick_sort(a,p+1,h);
+    }
+}
+//Using Hoore's-Partitioning
+int Hoore_parition(int *a,int l,int h)
+{
+    int low=l-1;
+    int high=h+1;
+    int pivot=a[h];
+    while(true)
+    {
+        do
+        {
+           low++;
+        }while(a[low] < pivot);
+        do
+        {
+            high--;
+        }while(a[high]>pivot);
+        if(low>=high)
+            return high;
+        swap(a[low],a[high]);
+    }
+}
+void quick_sort_Hoore(int *a,int l,int h)
+{
+    if(h > l)
+    {
+        int p=Hoore_parition(a,l,h);
+        quick_sort_Hoore(a,l,p);
+        quick_sort_Hoore(a,p+1,h);
+    }
+}
+
+void display(int *a,int n)
+{
+        for(int i=0;i<n;i++)
+        cout<< a[i] <<" ";
+}
+int main()
+{
+    int a[]={8,4,7,9,3,10,5};
+    quick_sort(a,0,6);
+    display(a,7);
+    cout<<endl;
+    quick_sort(a,0,6);
+    display(a,7);
+    return 0;
+}
diff --git a/sorting/8.cpp b/sorting/8.cpp
new file mode 100644
index 0000000..73fd783
--- /dev/null
+++ b/sorting/8.cpp
@@ -0,0 +1,108 @@
+//Optimized Quick sort for worst case..........
+
+///When does the worst case of Quicksort occur?
+/*
+) Array is already sorted in same order.
+2) Array is already sorted in reverse order.
+3) All elements are same (special case of case 1 and 2)
+*/
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+
+//Lomuto-partition............
+
+int lomuto_parition(int *a,int l,int h)
+{
+    int k=l-1;
+    int pivot=a[h];
+    for(int i=l;i<h;i++)
+    {
+        if(a[i] < pivot)
+        {
+            k++;
+            swap(a[i],a[k]);
+        }
+    }
+    swap(a[k+1],a[h]);
+    return (k+1);
+}
+
+int random_partion_Lomuto(int *a,int l,int h)
+{
+    int ra=l + rand()%(h-l);
+    swap(a[h],a[ra]);
+    return lomuto_parition(a,l,h);
+}
+
+void Randomized_Quick_sort_lomuto(int *a,int l,int h)
+{
+    if(l < h)
+    {
+        int p=random_partion_Lomuto(a,l,h);
+        Randomized_Quick_sort_lomuto(a,l,p-1);
+        Randomized_Quick_sort_lomuto(a,p+1,h);
+    }
+}
+
+//Hoore's Partition//
+
+int Hoore_parition(int *a,int l,int h)
+{
+    int beg=l-1;
+    int end=h+1;
+    int pivot=a[l];
+    while(7)
+    {
+        do
+        {
+            beg++;
+        }while(a[beg] < pivot);
+
+        do
+        {
+            end--;
+        }while(a[end] > pivot);
+
+        if(beg>=end)
+            return end;
+        swap(a[beg],a[end]);
+
+    }
+}
+
+int random_partion_Hoore(int *a,int l,int h)
+{
+    int ra=l + rand()%(h-l);
+    swap(a[l],a[ra]);
+    return Hoore_parition(a,l,h);
+}
+void Randomized_Quick_sort_Hoore(int *a,int l,int h)
+{
+    if(h > l)
+    {
+        int p=random_partion_Hoore(a,l,h);
+        Randomized_Quick_sort_Hoore(a,l,p);
+        Randomized_Quick_sort_Hoore(a,p+1,h);
+    }
+}
+void display(int *a,int n)
+{
+    for(int i=0;i<n;i++)
+            cout << a[i] <<" ";
+}
+int main()
+{
+    int a[]={10,9,8,7,6,5,4,3,2,1};
+    Randomized_Quick_sort_Hoore(a,0,9);
+   Randomized_Quick_sort_lomuto(a,0,9);
+    display(a,10);
+}
+
+
+
+
diff --git a/sorting/9.cpp b/sorting/9.cpp
new file mode 100644
index 0000000..3d1365f
--- /dev/null
+++ b/sorting/9.cpp
@@ -0,0 +1,58 @@
+///Cycle-sort
+//This algorithm is used when the memory cost is expensive
+//In this algorithm ,we find how many elements are smaller than current element then we will place the current element at correct position..
+//We maintain a cycle between the elements.
+//Find the minimum swaps required to sort the array.............
+//Time complexity is :
+//Worst case : O(n**2)..........
+//In-place and not stable........
+
+#include<bits/stdc++.h>
+using namespace std;
+
+
+
+void cycle_sort(int *a,int n)
+{
+    for(int i=0;i<n-1;i++)
+    {
+        int item=a[i];
+        int pos=i;
+        for(int j=i+1;j<n;j++)
+        {
+            if(item > a[j])
+            {
+                pos++;
+            }
+        }
+        swap(item,a[pos]);
+        while(pos!=i)
+        {
+            pos=i;
+            for(int j=i+1;j<n;j++)
+            {
+                if(item > a[j])
+                {
+                    pos++;
+                }
+            }
+            swap(a[pos],item);
+        }
+    }
+}
+void display(int *a,int n)
+{
+    for(int i=0;i<n;i++)
+    {
+        cout << a[i] <<" ";
+    }
+}
+int main()
+{
+    int a[]={5,4,3,2,1};
+    cycle_sort(a,5);
+    display(a,5);
+    return 0;
+}
+
+