Added a program of Count Inversion using Merge sort

Sorting/Heap Sort/algorithm.md

@@ -25,3 +25,8 @@ To sort an unsorted list with 'n' number of elements, following are the complexi
 Worst Case: O(n log n)
 
 Best Case : O(n log n)
+
+
+Questions realted to heap sort:
+
+Q1. K’th Smallest/Largest Element in Unsorted Array

Sorting/Heap Sort/kthelement.cpp

@@ -0,0 +1,106 @@
+#include <climits>
+#include <iostream>
+using namespace std;
+
+
+void swap(int* x, int* y);
+
+
+class MaxHeap {
+	int* harr; 
+	int capacity; 
+	int heap_size; 
+public:
+	MaxHeap(int a[], int size); 
+	void maxHeapify(int i); 
+	int parent(int i) { return (i - 1) / 2; }
+	int left(int i) { return (2 * i + 1); }
+	int right(int i) { return (2 * i + 2); }
+
+	int extractMax(); 
+	int getMax() { return harr[0]; } 
+
+
+	void replaceMax(int x)
+	{
+		harr[0] = x;
+		maxHeapify(0);
+	}
+};
+
+MaxHeap::MaxHeap(int a[], int size)
+{
+	heap_size = size;
+	harr = a; // store address of array
+	int i = (heap_size - 1) / 2;
+	while (i >= 0) {
+		maxHeapify(i);
+		i--;
+	}
+}
+
+
+int MaxHeap::extractMax()
+{
+	if (heap_size == 0)
+		return INT_MAX;
+
+
+	int root = harr[0];
+
+
+	if (heap_size > 1) {
+		harr[0] = harr[heap_size - 1];
+		maxHeapify(0);
+	}
+	heap_size--;
+
+	return root;
+}
+
+
+void MaxHeap::maxHeapify(int i)
+{
+	int l = left(i);
+	int r = right(i);
+	int largest = i;
+	if (l < heap_size && harr[l] > harr[i])
+		largest = l;
+	if (r < heap_size && harr[r] > harr[largest])
+		largest = r;
+	if (largest != i) {
+		swap(&harr[i], &harr[largest]);
+		maxHeapify(largest);
+	}
+}
+
+
+void swap(int* x, int* y)
+{
+	int temp = *x;
+	*x = *y;
+	*y = temp;
+}
+
+
+int kthSmallest(int arr[], int n, int k)
+{
+
+	MaxHeap mh(arr, k);
+
+
+	for (int i = k; i < n; i++)
+		if (arr[i] < mh.getMax())
+			mh.replaceMax(arr[i]);
+
+	// Return root
+	return mh.getMax();
+}
+int main()
+{
+	int arr[] = { 12, 3, 5, 7, 19 };
+	int n = sizeof(arr) / sizeof(arr[0]), k = 4;
+	cout << "K'th smallest element is: " << kthSmallest(arr, n, k);
+	return 0;
+}
+

Sorting/Merge Sort/C++/InversionCount.cpp.cpp

@@ -0,0 +1,68 @@
+
+
+int _mergeSort(int a[], int t[], int l, int r);
+int merge(int a[], int t[], int l, int m,
+		int r);
+
+
+int mergeSort(int a[], int size)
+{
+	int t[size];
+	return _mergeSort(a, t, 0, size - 1);
+}
+
+int _mergeSort(int a[], int t[], int l, int r)
+{
+	int m, inversion_count = 0;
+	if (r > l) {
+		m = (r + l) / 2;
+		inversion_count += _mergeSort(a, t, l, m);
+		inversion_count += _mergeSort(a, t, m + 1, r);
+
+
+		inversion_count += merge(a, t, l, m + 1, r);
+	}
+	return inversion_count;
+}
+
+
+int merge(int a[], int t[], int l, int m,int r)
+{
+	int i, j, k;
+	int inversion_count = 0;
+
+	i = l; 
+	j = m; 
+	k = l; 
+	while ((i <= m - 1) && (j <= r)) {
+		if (a[i] <= a[j]) {
+			t[k++] = a[i++];
+		}
+		else {
+			t[k++] = a[j++];
+
+
+			inversion_count = inversion_count + (m - i);
+		}
+	}
+
+
+	while (i <= m - 1)
+		t[k++] = a[i++];
+
+
+	while (j <= r)
+		t[k++] = a[j++];
+
+
+	for (i = l; i <= r; i++)
+		a[i] = t[i];
+
+	return inversion_count;
+}
+
+
+
+//Sample Input; a={1,20,6,4,5}
+//Sample Output; 5
+

Sorting/Merge Sort/C++/SortLinkedList.cpp

@@ -0,0 +1,74 @@
+
+
+node* MergetheSortedList(node* list1, node* list2) 
+{ 
+	node* res = NULL; 
+
+
+	if (list1 == NULL) 
+		return (list2); 
+	else if (list2 == NULL) 
+		return (list1); 
+
+
+	if (list1->data <= list2->data) { 
+		res = list1; 
+		res->next = MergetheSortedList(list1->next, list2); 
+	} 
+	else { 
+		res = list2; 
+		res->next = MergetheSortedList(list1, list2->next); 
+	} 
+	return res; 
+} 
+
+
+void SplitList(node* s, node** front, node** back) 
+{ 
+	node* p1; 
+	node* p2; 
+	p2 = s; 
+	p1 = s->next; 
+
+
+	while (p1 != NULL) { 
+		p1 = p1->next; 
+		if (p1 != NULL) { 
+			p2 = p2->next; 
+			p1 = p1->next; 
+		} 
+	} 
+
+
+	*front = s; 
+	*back = p2->next; 
+	p2->next = NULL; 
+} 
+
+
+
+void MergeSort(node** one) 
+{ 
+	node* head = *one; 
+	node* ptr1; 
+	node* ptr2; 
+
+
+	if ((head == NULL) || (head->next == NULL)) { 
+		return; 
+	} 
+
+
+	SplitList(head, &p1, &p2); 
+
+
+	MergeSort(&p1); 
+	MergeSort(&p2); 
+
+
+	*one = MergetheSortedList(p1, p2); 
+} 
+
+
+
+

Sorting/Merge Sort/algorithm.md

@@ -14,3 +14,9 @@ Step 6: end of if
 Step 7: END of Merge_sort
 Step 8:Exit
 ```
+
+Count Inversion:
+This problem shows how far (or close) the array is from being sorted. 
+
+
+Sort Linked List Using Merge sort