Added a cpp code for inverting binary tree

README.md

@@ -10,14 +10,14 @@
 - Pull requests can be made in any GitHub-hosted repositories/projects.
 - You can sign up anytime between October 1 and October 31.
 
-## HactoberFest Rules :
+## HacktoberFest Rules :
 
 To earn your Hacktoberfest tee or tree reward, you must register and make four valid pull requests (PRs) between October 1-31 (in any time zone). PRs can be made to any public repo on GitHub, not only the ones with issues labeled Hacktoberfest. If a maintainer reports your pull request as spam or behavior not in line with the project’s code of conduct, you will be ineligible to participate. This year, the first 70,000 participants who successfully complete the challenge will be eligible to receive a prize.
 ***
 
 <h3 align="center">
     <a href="https://hacktoberfest.digitalocean.com/">
-        Link To HactoberFest 2020
+        Link To HacktoberFest 2020
     </a>
 </h3>
 
@@ -42,6 +42,13 @@ To earn your Hacktoberfest tee or tree reward, you must register and make four v
 ## Steps For Contribution
 
     1. Fork this repo
-    2. Add a file
-    3. commit the code
-    4. Make pull request
+    2. Star this repo
+    3. Add a file
+    4. commit the code
+    5. Make pull request
+***
+<h2 align="center">
+    <p>
+        Thank You
+    </p>
+</h2>

c++/Bubble_sort.cpp

@@ -0,0 +1,41 @@
+#include<iostream>
+using namespace std;
+void swapping(int &a, int &b) {      //swap the content of a and b
+   int temp;
+   temp = a;
+   a = b;
+   b = temp;
+}
+void display(int *array, int size) {
+   for(int i = 0; i<size; i++)
+      cout << array[i] << " ";
+   cout << endl;
+}
+void bubbleSort(int *array, int size) {
+   for(int i = 0; i<size; i++) {
+      int swaps = 0;         //flag to detect any swap is there or not
+      for(int j = 0; j<size-i-1; j++) {
+         if(array[j] > array[j+1]) {       //when the current item is bigger than next
+            swapping(array[j], array[j+1]);
+            swaps = 1;    //set swap flag
+         }
+      }
+      if(!swaps)
+         break;       // No swap in this pass, so array is sorted
+   }
+}
+int main() {
+   int n;
+   cout << "Enter the number of elements: ";
+   cin >> n;
+   int arr[n];     //create an array with given number of elements
+   cout << "Enter elements:" << endl;
+   for(int i = 0; i<n; i++) {
+      cin >> arr[i];
+   }
+   cout << "Array before Sorting: ";
+   display(arr, n);
+   bubbleSort(arr, n);
+   cout << "Array after Sorting: ";
+   display(arr, n);
+}

c++/Circular_linked_list.cpp

@@ -0,0 +1,173 @@
+#include<iostream>
+using namespace std;
+
+struct Node
+{
+   int data;
+   struct Node *next;
+};
+//insert a new node in an empty list
+struct Node *insertInEmpty(struct Node *last, int new_data)
+{
+   // if last is not null then list is not empty, so return
+   if (last != NULL)
+   return last;
+
+   // allocate memory for node
+   struct Node *temp = new Node;
+
+   // Assign the data.
+   temp -> data = new_data;
+   last = temp;
+
+   // Create the link.
+   last->next = last;
+
+   return last;
+}
+//insert new node at the beginning of the list
+struct Node *insertAtBegin(struct Node *last, int new_data)
+{
+   //if list is empty then add the node by calling insertInEmpty
+   if (last == NULL)
+   return insertInEmpty(last, new_data);
+
+   //else create a new node
+   struct Node *temp = new Node;
+
+   //set new data to node
+   temp -> data = new_data;
+   temp -> next = last -> next;
+   last -> next = temp;
+
+   return last;
+}
+//insert new node at the end of the list
+struct Node *insertAtEnd(struct Node *last, int new_data)
+{
+   //if list is empty then add the node by calling insertInEmpty
+   if (last == NULL)
+   return insertInEmpty(last, new_data);
+
+   //else create a new node
+   struct Node *temp = new Node;
+
+   //assign data to new node
+   temp -> data = new_data;
+   temp -> next = last -> next;
+   last -> next = temp;
+   last = temp;
+
+   return last;
+}
+
+//insert a new node in between the nodes
+struct Node *insertAfter(struct Node *last, int new_data, int after_item)
+{
+   //return null if list is empty
+   if (last == NULL)
+   return NULL;
+
+   struct Node *temp, *p;
+   p = last -> next;
+   do
+   {
+      if (p ->data == after_item)
+      {
+         temp = new Node;
+         temp -> data = new_data;
+         temp -> next = p -> next;
+         p -> next = temp;
+
+         if (p == last)
+         last = temp;
+         return last;
+       }
+   p = p -> next;
+ } while(p != last -> next);
+
+   cout << "The node with data "<<after_item << " is not present in the list." << endl;
+   return last;
+
+}
+//traverse the circular linked list
+void traverseList(struct Node *last) {
+   struct Node *p;
+
+   // If list is empty, return.
+   if (last == NULL) {
+      cout << "Circular linked List is empty." << endl;
+      return;
+      }
+p = last -> next; // Point to the first Node in the list.
+
+// Traverse the list starting from first node until first node is visited again
+
+do {
+      cout << p -> data << "==>";
+      p = p -> next;
+      } while(p != last->next);
+   if(p == last->next)
+   cout<<p->data;
+   cout<<"\n\n";
+   }
+
+//delete the node from the list
+void deleteNode(Node** head, int key)
+{
+   // If linked list is empty retun
+   if (*head == NULL)
+   return;
+
+   // If the list contains only a single node,delete that node; list is empty
+   if((*head)->data==key && (*head)->next==*head) {
+      free(*head);
+      *head=NULL;
+      }
+Node *last=*head,*d;
+
+// If key is the head
+if((*head)->data==key) {
+   while(last->next!=*head) // Find the last node of the list
+   last=last->next;
+
+   // point last node to next of head or second node of the list
+   last->next=(*head)->next;
+   free(*head);
+   *head=last->next;
+   }
+
+// end of list is reached or node to be deleted not there in the list
+while(last->next!=*head&&last->next->data!=key) {
+   last=last->next;
+}
+// node to be deleted is found, so free the memory and display the list
+if(last->next->data==key) {
+      d=last->next;
+      last->next=d->next;
+      cout<<"The node with data "<<key<<" deleted from the list"<<endl;
+      free(d);
+      cout<<endl;
+      cout<<"Circular linked list after deleting "<<key<<" is as follows:"<<endl;
+      traverseList(last);
+      }
+   else
+   cout<<"The node with data "<< key << " not found in the list"<<endl;
+   }
+
+// main Program
+int main()
+{
+   struct Node *last = NULL;
+
+   last = insertInEmpty(last, 30);
+   last = insertAtBegin(last, 20);
+   last = insertAtBegin(last, 10);
+   last = insertAtEnd(last, 40);
+   last = insertAtEnd(last, 60);
+   last = insertAfter(last, 50,40 );
+   cout<<"The circular linked list created is as follows:"<<endl;
+   traverseList(last);
+   deleteNode(&last,10);
+   return 0;
+}

c++/Insert Interval.cpp

@@ -0,0 +1,27 @@
+//https://leetcode.com/problems/insert-interval/
+
+//This is the link to the problem you can go and see the problem from there
+
+class Solution {
+public:
+    vector<vector<int>> insert(vector<vector<int>>& intervals, vector<int>& newInterval) {
+        int n = intervals.size();
+        vector<vector<int> > ans;
+        for(int i = 0; i < n; ++i){
+            if(intervals[i][1] < newInterval[0]){
+                ans.push_back(intervals[i]);
+            }
+            else if(newInterval[1] < intervals[i][0]){
+                ans.push_back(newInterval);
+                newInterval = intervals[i];
+            }
+            else{
+                newInterval[0] = min(newInterval[0],intervals[i][0]);
+                newInterval[1] = max(newInterval[1],intervals[i][1]);
+            }
+
+        }
+        ans.push_back(newInterval);
+        return ans;
+    }
+};

c++/basic-search.cpp

@@ -0,0 +1,20 @@
+#include <iostream>
+#include <algorithm>
+
+using namespace std;
+
+int main()
+{
+    static int array[]{4,12,56,754,1235,435,64,1,2,3,4};
+    int size = sizeof(array)/sizeof(array[0]);
+    sort(array, array + size);
+    int x = 3;
+
+    for(int i = 0; i < size; i++) {
+        if (array[i] == x) {
+            cout << "Fount at index: " << i;
+        }
+    }
+
+
+}

c++/binary-search.cpp

@@ -0,0 +1,28 @@
+#include <iostream>
+#include <algorithm>
+
+using namespace std;
+
+int main()
+{
+    static int array[]{4,12,56,754,1235,435,64,1,2,3,4};
+    int size = sizeof(array)/sizeof(array[0]);
+    sort(array, array + size);
+    int x = 3;
+    int a = 0;
+    int b = size-1;
+
+    while (a <= b) {
+        int k = (a+b)/2;
+        if (array[k] == x) {
+            cout << "Found at index: " << k;
+        }
+        if (array[k] > x) {
+            b = k-1;
+        } else {
+            a = k+1;
+        }
+    }
+
+
+}

c++/binaryExponentiation.cpp

@@ -0,0 +1,17 @@
+#include <iostream>
+using namespace std;
+#define mod 1000000007
+int main()
+{
+   long long int a,b;
+   cin >> a >> b;
+   long long int res=1;
+   while(b>0)
+   {
+      if(b & 1)
+         res=(res*a)%(long long int)mod;
+      a=(a*a)%(long long int)mod;
+      b=b>>1;
+    }
+      cout << res;
+  }