快速排序、求旋转数组最小数字

#include <iostream>
#include <stack>
#include <queue>
#include <algorithm>

using namespace std;

// 快速排序1
void quickSort( int a[], int l, int r )
{
	if( l >= r )
	{
		return;
	}
	
	int i = l; 
	int j = r;

	int mid = ( l + r ) / 2;
	int tmp = a[mid];
	a[mid] = a[l];
	a[l] = tmp;

	int value = a[l];

	while( i < j )
	{

		while( i < j && a[j] >= value ) j--;
		
		a[i] = a[j];

		while( i < j && a[i] <= value ) i++;
		
		a[j] = a[i];		
		
	}

	a[i] = value;

	quickSort( a, l, i - 1 );
	quickSort( a, i + 1, r );
	
	
	return;

}


// 快速排序2，容易理解的快排
void quickSort1( int a[], int start, int end )
{
	if( start >= end )
	{
		return;
	}	

	int mid = ( start + end ) / 2;
	int tmp = a[mid];
	a[mid] = a[end];
	a[end] = tmp;

	int idx = start - 1;

	for( int i = start; i < end; i++ )
	{		
		if( a[i] < a[end] )   // a[end]作为pivot 
		{
			idx++;
			
			if( idx != i )
			{
				int tmp = a[idx];
				a[idx] = a[i];
				a[i] = tmp;
			}
		}		
	}

	idx++;
	tmp = a[idx];
	a[idx] = a[end];
	a[end] = tmp;

	quickSort1( a, start, idx - 1 );
	quickSort1( a, idx + 1, end );
	
	return;
}


void print( int a[], int len )
{
	for( int i = 0; i < len; i++ )
	{
		cout << a[i] << ' ';	
	}

	cout << endl;

	return;
}


// 求旋转数组的最小数字 递归实现
int midRotatedArray( int a[], int start, int end )
{
	int min = -1;

	if( NULL == a )
	{
		min = -1;
		return min;
	}

	if( start >= end )
	{
		min = a[start];
		return min;
	}

	int mid = ( start + end ) / 2;

	//if( a[mid] <= a[ ( mid + 1 ) % 
	int right = mid + 1 > end ? start : mid + 1;
	int left = mid - 1 < start ? end: mid - 1;

	if( a[mid] <= a[right] && a[mid] <= a[left] )  
	{
		if( !( a[mid] == a[right] && a[mid] == a[left] ) ) // for { 2 3 3 3 1 }
		{
			min = a[mid];
			//cout << start << ' ' << mid << ' ' << end << endl;
			return min;
		}
		
	}

	int minLeft = midRotatedArray( a, start, mid - 1 );
	int minRight = midRotatedArray( a, mid + 1, end );

	return minLeft > minRight ? minRight : minLeft;
	
}

// 求旋转数组的最小数字 非递归实现
int midRotatedArray_noRecur( int a[], int start, int end )
{
	int min = -1;

	if( NULL == a )
	{
		min = -1;
		return min;
	}

	if( start >= end )
	{
		min = a[start];
		return min;
	}

	int mid = ( start + end ) / 2;
	
	while( a[start] >= a[end] )
	{
		mid = ( start + end ) / 2;
			
		int right = mid + 1 > end ? start : mid + 1;
		int left = mid - 1 < start ? end : mid - 1;

		if( a[mid] <= a[right] && a[mid] <= a[left] )
		{
			if( !( a[mid] == a[right] && a[mid] == a[left] ) )
			{
				min = a[mid];
				//cout << start << ' ' << mid << ' ' << end << endl;
				return min;
			}
		
		}	
		
		if( a[start] == a[mid] && a[mid] == a[end] ) // 顺序查找, for : { 1 0 1 1 1 } and  { 1 1 1 0 1 }
		{
			min = a[start];

			for( int i = start + 1; i <= end; i++ )
			{
				if( min > a[i] )
				{
					min = a[i];
				}
			}

			return min;
		}

		if( start != mid && a[start] >= a[mid] )
		{
			end = mid - 1;
		}
		else 
		{
			start = mid + 1;
		}

	}

	min = a[start];
	return min;
}

// 总结： 先写测试用例，否则很多考虑不周

int main()
{
	int ret = 0;
	int data = -2;
	data = data << 2;
	cout << data << endl;
	
	data = -2;
	data = data >> 2;
	cout << data << endl;
        // 针对求旋转数组的最小数字的测试用例
	int b0[] = { 3, 4, 5, 6, 1 };
	int b1[] = { 2, 2, 3, 0, 1 };
	int b2[] = { 1, 2, 3, 4, 5 };
	int b3[] = { 2, 2, 2, 2, 2 };
	int b4[] = { 1, 1, 1, 0, 1 };
	int b5[] = { 1, 0, 1, 1, 1 };
	int b6[] = { 2, 1 };
	int b7[] = { 3 };
	int *b8 = NULL;

	cout << midRotatedArray( b7, 0, 0 ) << endl;
	cout << midRotatedArray_noRecur( b7, 0, 0 ) << endl;

	int a1[] = { 1, 2, 3, 4, 5 };
	int a2[] = { 5, 4, 3, 2, 1 };
	int a3[] = { 5, 7, 1, 3, 6 };
	int a4[] = { 5, 4, 4, 4, 1 };
	int a5[] = { 4, 4, 4, 4, 4 };

	quickSort1( a1, 0, 4 );
	quickSort1( a2, 0, 4 );
	quickSort1( a3, 0, 4 );
	quickSort1( a4, 0, 4 );
	quickSort1( a5, 0, 4 );

	print( a1, 5 );
	print( a2, 5 );
	print( a3, 5 );
	print( a4, 5 );
	print( a5, 5 );

	return ret;
}