排序算法

#include 
typedef int T;
//////////////////////////////////////////////////////////////////////////
//基于相邻元素之间的相互比较
// 冒泡排序；
void bubbleSort(T v[],int n)
{
	int i,j;
	T temp;
	for (i = 0 ; i < n - 1; i++)
		for(j = 0; j < n - 1 - i; j ++)
		{
			if(v[j] > v[j + 1])
			{
				temp = v[j];
				v[j] = v[j + 1];
				v[j + 1] = temp;
			}
		}
}
//冒泡优化1:
void BubbleSort(T v[],int n)
{
	bool exchange;
	int i,j;
	T temp;
	for (i = 1; i < n; i++)
	{
		exchange = false;
		for (j = n - 1; j >= i; j--)
		{
			if (v[j - 1] > v[j])
			{
				temp = v[j];
				v[j] = v[j - 1];
				v[j - 1] = temp;
				exchange = true;
			}
		}
		if (false == exchange)
		{
			return;
		}
	}
}
//冒泡优化2：
void BubbleSort2(T v[], int n)
{
	int last = n - 1;
	int cLast;	
	T temp;
	while(last > 0)
	{
		cLast = last;
		last = 0;
		for (int i = 0; i < cLast; i++)
		{
			if (v[i] > v[i + 1])
			{
				temp = v[i];
				v[i] = v[i + 1];
				v[i + 1] = temp;
				last = i;
			}
		}
	}
}
// //插入排序
void InsertSort(T v[], int left, int right)
{
	T temp;
	int i, j;
	for (i = left + 1; i <= right; i++)
	{
		if (v[i] < v[i - 1])
		{
			temp = v[i];
			j = i - 1;
			do 
			{
				v[j + 1] = v[j];
				j--;		    	
			} while(j > left && temp < v[j]);
			v[j + 1] = temp;
		}
	}
}
//选择排序
void selectSort(T v[], int left, int right)
{
	T temp;
    for (int i = left; i < right; i++)
    {
		int k = i;
		for (int j = i + 1; j <= right; j++)
		{
			if (v[j] < v[k])
			{
				k = j;
			}
		}
		if (k != i)
		{
			temp = v[k];
			v[k] = v[i];
			v[i] = temp;
		}
    }
}
//////////////////////////////////////////////////////////////////////////
//                   基于分治策略
//归并排序
void merge(T L[], T CL[], int left, int mid, int right)
{	
	int i = left, j = mid + 1, k =left;
	while (i <= mid && j <= right)
	{
		if (L[i] < L[j])
		{
			CL[k++] = L[i++];
		}
		else
		{
			CL[k++] = L[j++];
		}
	}
	while(i <= mid)
	{
		CL[k++] = L[i++];
	}
	while(j <= right)
	{
		CL[k++] = L[j++];
	}
	for (int cnt = left; cnt <= right; cnt++)
	{
		L[cnt] = CL[cnt];
	}
}
void mergeSort(T L[], T CL[], int left, int right)
{
	if (right <= left)
	{
		return;
	}
	int mid = (left + right) / 2;
	mergeSort(L, CL, left, mid);
	mergeSort(L, CL, mid + 1, right);
	merge(L, CL, left, mid, right);
}
//快速排序
int partition(T L[], int low, int high)
{
	int pivotpos = low;
	T pivot = L[low];
	T temp;
	for (int i = low + 1; i <= high; i++)
	{
		if (L[i] < pivot)
		{
			pivotpos++;
			if (pivotpos != i)
			{
				temp = L[i];
				L[i] = L[pivotpos];
				L[pivotpos] = temp;
			}
		}
	}
	if (pivotpos != low)
	{
		temp = L[pivotpos];
    	L[pivotpos] = L[low];
		L[low] = temp;
	}
	
	return pivotpos;
}
/// partition2
int partition2(T L[], int low, int high)
{
	T pivot = L[low];
	T temp;
	int left = low + 1, right = high;
	while (left < right)
	{
		while(left < right && L[right] >= pivot)
		{
			right--;
		}
		while (left < right && L[left] < pivot)
		{
			left++;
		}
		
		if (left != right)
		{
			temp = L[left];
			L[left] = L[right];
			L[right] = temp;
		}
	}
	if (L[low] > L[low + 1])
	{
		temp = L[low];
		L[low] = L[left];
		L[left] = temp;
		return left;
	}
	else
		return low;
	
}
void quickSort(T L[], int low, int high)
{
	if (low < high)
	{
		//  分割函数的两个不同实现方式
//		int pivotpos = partition(L, low, high);
		int pivotpos = partition2(L, low, high);
		quickSort(L, low, pivotpos);
		quickSort(L,pivotpos + 1, high);
	}
	return;
	
}
//希尔排序
void shellSort(T L[], int left, int right)
{
	int len = right - left + 1;
	int gap = len;
	do
	{
		gap = gap / 3 + 1;
		for(int i = left + gap; i <= right; i++) 
		{
			T temp = L[i];
			int j = i - gap;
			while(j >= left && L[j] > temp)
			{
				L[j + gap] = L[j];
				j= j - gap;
			}
			L[j + gap] = temp;
		}
	}while(gap > 1);
}
// 堆排序
void siftDown(T L[], int left, int right)
{
	T temp = L[left];
	int i = left;
	int j = 2 * left + 1;
	while(j <= right)
	{
		if (j < right && L[j] < L[j + 1]) //条件j < right是必要的
		{
			j++;
		}
		if (temp >= L[j])  /// > or >= are both ok, but due to 'break',using >= is better.
		{
			break;
		}
		else
		{
			L[i] = L[j];
			i = j;
			j = 2 * i + 1;
		}
	}
	L[i] = temp;
}
void heapSort(T L[], int left, int right)
{
	int len = right - left + 1;
	for (int i = (len - 2) / 2; i >= left; i--)
	{
		siftDown(L, i, len - 1);
	}
	T temp;
	for (i = len - 1; i >= left; i--)
	{
		temp = L[left];
		L[left] = L[i];
		L[i] = temp;
		siftDown(L, left, i - 1);
	}
}
int main()
{	
	int i;
	int v[9] ={66,13,51,76,81,26,57,69,23}; 
 //   int v[8] = {2, 6, 1, 7, 23, 6, 12, 8};
	int sv[8];
 // bubbleSort(v,9);
 BubbleSort2(v,9);
 //	InsertSort(v,0,7);
 // selectSort(v,0,7);
 //	mergeSort(v, sv, 0, 7);
 //	quickSort(v, 0, 8);
//	shellSort(v,0,7);
//	heapSort(v,0,7);
	for (i = 0; i < 9; i++)
	{
		std::cout << v[i] << ",";
	}
	std::cout << std::endl;
	return 0;
}