Divide and Conquer

/*
	Alrogithms: Divide and Conquer
	1) Binary Search
	2) QuickSort
	3) MergeSort
	4) Maximum and minimum of an array using minimum number of comparisons
*/
#include <iostream>
using namespace std;

struct Pairs
{
	int min;
	int max;
};

int BinarySearch(int arr[], int l, int r, int val);
void QuickSort(int arr[], int l, int r);
int partition(int arr[], int l, int r);
void swap(int &a, int &b);
void MergeSort(int arr[], int l, int r);
void Merge(int arr[], int l, int m, int r); 
struct Pairs getMinMax(int arr[], int l, int r);

int main()
{
	// Binary Search test
	cout<<"BinarySearch test"<<endl;
	int arr1[10] = {1, 3, 5, 7, 9, 10, 22, 33, 55, 100};
	int index = BinarySearch(arr1, 0, 9, 55);
	cout<<arr1[index]<<endl;

	// Quick Sort test
	cout<<"QuickSort test"<<endl;
	int arr2[10] = {1, 3, 5, 7, 9, 10, 8, 6, 4, 2};
	QuickSort(arr2, 0, 9);
	for (int i=0; i<10; i++)
	{
		cout<<arr2[i]<<"  ";
	}
	cout<<endl;

	// MergeSort test
	cout<<"MergeSort test"<<endl;
	int arr3[10] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
	MergeSort(arr3, 0, 9);
	for (int i=0; i<10; i++)
	{
		cout<<arr3[i]<<"  ";
	}
	cout<<endl;

	// Maximum and minimum of an array using minimum number of comparisons
	cout<<"Maximum and minimum of an array using minimum number of comparisons"<<endl;
	int arr4[10] = {1, 3, 5, 7, 9, 10, 8, 6, 4, 2};
	struct Pairs minmax = getMinMax(arr4, 0, 9);
	cout<<"max:"<<minmax.max<<" min:"<<minmax.min<<endl;

	system("pause");
	return 0;
}

int BinarySearch(int arr[], int l, int r, int val)
{
	if (l > r)
	{
		return -1;
	}

	int m = (l + r) / 2;

	if (arr[m] == val)
	{
		return m;
	}

	if (l == r)
	{
		return -1;
	}

	if (arr[m] > val)
	{
		return BinarySearch(arr, l, m-1, val);
	}
	else
	{
		return BinarySearch(arr, m+1, r, val);
	}
}

void QuickSort(int arr[], int l, int r)
{
	if (l >= r)
	{
		return ;
	}

	int i = partition(arr, l, r);
	QuickSort(arr, l, i-1);
	QuickSort(arr, i+1, r);
}

int partition(int arr[], int l, int r)
{
	int t = arr[r];
	int i = l- 1;
	int j = r;

	for ( ; ; )
	{
		while (arr[++i] < t);

		while (arr[--j] > t)
		{
			if (j == l)
			{
				break;
			}
		}

		if (i >= j)
		{
			break;
		}

		swap(arr[i], arr[j]);
	}

	swap(arr[i], arr[r]);

	return i;	
}

void swap(int &a, int &b)
{
	int temp = a;
	a = b;
	b = temp;
}

struct Pairs getMinMax(int arr[], int l, int r)
{
	struct Pairs minmax;

	if (l == r)
	{
		minmax.max = arr[l];
		minmax.min = arr[l];

		return minmax;
	}

	if (r == l+1)
	{
		if (arr[l] > arr[r])
		{
			minmax.max = arr[l];
			minmax.min = arr[r];
		}
		else
		{
			minmax.max = arr[r];
			minmax.min = arr[l];
		}

		return minmax;
	}

	struct Pairs mml, mmr;
	int mid = (l + r) / 2;

	mml = getMinMax(arr, l, mid);
	mmr = getMinMax(arr, mid+1, r);

	if (mml.max > mmr.max)
	{
		minmax.max = mml.max;
	}
	else
	{
		minmax.max = mmr.max;
	}

	if (mml.min < mmr.min)
	{
		minmax.min = mml.min;
	}
	else
	{
		minmax.min = mmr.min;
	}

	return minmax;
}

// Top-down mergesort
void MergeSort(int arr[], int l, int r)
{
	if (l >= r)
	{
		return ;
	}

	int m = (l + r) / 2;

	MergeSort(arr, l, m);
	MergeSort(arr, m+1, r);
	Merge(arr, l, m, r);
}

void Merge(int arr[], int l, int m, int r)
{
	int i, j, k;
	int len = r - l + 1;
	int *aux = new int[len];

	for (k=0, i=l; i<=m; i++, k++)
	{
		aux[k] = arr[i];
	}

	for (k=len-1, j=m+1; j<=r; j++, k--)
	{
		aux[k] = arr[j];
	}

	i = 0;
	j = len-1;

	for (k=l; k<=r; k++)
	{
		if (aux[j] < aux[i])
		{
			arr[k] = aux[j--];
		}
		else
		{
			arr[k] = aux[i++];
		}
	}
}