排序

        #include <iostream>
        #include <functional>
        #include <mutex>
        using namespace std;
        
        //插入排序  最好情况  O(n)  最坏情况 O(n^2)
        template <typename FUN>
        void InsertSort(int *a, int length, FUN fun)
        {
        	if (length <= 1) return true;
        	//从第2个数开始 比较 (数组从0开始)
        	for (int i = 1; i < length; i++)
        	{
        		int key = a[i];
        		int j = i - 1;
        		//当前元素前一个 到第一个元素为止
        		while (j >= 0 && fun(a[j],key))
        		{
        			a[j + 1] = a[j];
        			//下次比较的元素位置
        			j--;
        		}
        		//条件终止 当前j为满足条件的前一个位置 
        		a[j + 1] = key;
        	}
        	return true;
        }
        
        int findIndex(int *a, int nStart, int nEnd,int nValue)
        {
        	int mid = (nEnd + nStart) >> 1;
        	if (nStart > nEnd)
        		return nStart;
        	if (a[mid] == nValue)
        		return mid;
        	if (a[mid] < nValue)
        		return findIndex(a, mid + 1, nEnd, nValue);
        	else
        		return findIndex(a, nStart, mid - 1, nValue);
        }
        //插入排序 +  二分查找
        void InsertSort(int *a, int length)
        {
        	if (length <= 1) return ;
        	//从第2个数开始 比较 (数组从0开始)
        	for (int i = 1; i < length; i++)
        	{
        		int nValue = a[i];
        		//当前元素前一个 到第一个元素为止
        		int nIndex = findIndex(a, 0, i - 1, nValue);
        		
        		for (int j = i - 1; j >= nIndex; j--)
        		{
        			a[j + 1] = a[j];
        		}
        		a[nIndex] = nValue;
        	}
        	return ;
        }
        
        //选择排序  最好情况  O(n^2)  最坏情况 O(n^2)
        void SelectSort(int *a, int length)
        {
        	if (length <= 1) return ;
        
        	for (int i = 0; i < length - 1; i++)
        	{
        		int key = i;
        		for (int j = i+1; j < length; j++)
        		{
        			if (a[j] > a[key])
        			{
        				key = j;
        			}
        		}
        		int temp = a[i];
        		a[i] = a[key];
        		a[key] = temp;
        	}
        	return ;
        
        }
        
        bool findNum(int *a, int nStart, int nEnd, int nValue)
        {
        	if (nStart >= nEnd) return false;
        	bool result = false;
        	
        	int mid = (nStart + nEnd) >> 1;
        	result = findNum(a, nStart, mid, nValue) || findNum(a, mid+1, nEnd, nValue);
        	if (result == false)
        	{
        		for (int i = nStart; i <= mid; i++)
        		{
        			for (int j = mid + 1; j <= nEnd; j++)
        			{
        				if (a[i] + a[j] == nValue)
        					return true;
        			}
        		}
        	}
        	return result;
        }
        //是否存在2个数和 刚好为nValue
        void FindSum(int *a, int length, int nValue)
        {
        	bool result = findNum(a, 0, length - 1, nValue);
        	if (result)
        		cout << "find num = " << nValue;
        	else
        		cout << "Nofind num = " << nValue;
        }
        
        
        void Combine(int *a, int nStart, int mid, int nEnd)
        {
        	if (nStart >= nEnd) return;
        
        	int *temp = new int[nEnd - nStart + 1];
        	int num = 0;
        	int nA = nStart,nB = mid +1;
        	while (nA <= mid && nB <= nEnd)
        	{
        		if (a[nA] < a[nB])
        		{
        			temp[num] = a[nA];
        			nA++;
        			
        		}
        		else{
        			temp[num] = a[nB];
        			nB++;
        		}
        		num++;	
        	}
        
        	while (nA <= mid)
        	{
        		temp[num] = a[nA];
        		nA++;
        		num++;
        	}
        	
        	while (nB <=nEnd)
        	{
        		temp[num] = a[nB];
        		nB++;
        		num++;
        	}
        
        	num = 0;
        	for (int i = nStart; i <= nEnd; i++)
        	{
        		a[i] = temp[num++];
        	}
        
        	delete[] temp;
        }
        void Merge(int *a, int nStart, int nEnd)
        {
        	if (nStart >= nEnd) return;
        
        	if (nEnd - nStart + 1 <= 32)
        	{
        		InsertSort(a + nStart, nEnd - nStart + 1);
        	}
        	else{
        		int mid = (nStart + nEnd) >> 1;
        
        		Merge(a, nStart, mid);
        		Merge(a, mid + 1, nEnd);
        		Combine(a, nStart, mid, nEnd);
        	}
        	
        }
        //归并排序
        void MergeSort(int *a,int nLength)
        {
        	Merge(a, 0, nLength - 1);
        }
        void BuildHeap(int *a, int nLength, int i)
    {
    	int nLeftChild = 2 * i;
    	int nRightChild = nLeftChild + 1;
    	int nMax = i;
    
    	if (nLeftChild >= nLength)
    		return;
    
    
    	if (std::greater<int>()(a[nLeftChild], a[i]) == true)
    	{
    		nMax = nLeftChild;
    	}
    
    	if (nRightChild < nLength && std::greater<int>()(a[nRightChild], a[nMax]) == true)
    	{
    		nMax = nRightChild;
    	}
    
    	if (nMax != i)
    	{
    		swap(a[i], a[nMax]);
    		BuildHeap(a, nLength, nMax);
    	}
    }
    
    void OutArray(int *a, int nLength)
    {
    	for (int i = 0; i < nLength; i++)
    	{
    		cout << a[i] << " ";
    	}
    	cout << endl;
    }
    //堆排序
    void HeapSort(int *a,int nLength)
    {
    	if (nLength < 2) return;
    
    	for (int i = (nLength >> 1); i >= 0; i--)
    	{
    		BuildHeap(a, nLength, i);
    	}
    
    	OutArray(a, nLength);
    
    	swap(a[0], a[nLength - 1]);
    	
    	OutArray(a, nLength);
    	cout << endl;
    
    	HeapSort(a, nLength - 1);
    }
    
    int QuickSort1(int *a, int nStart, int nEnd)
{
	if (nStart < nEnd)
	{
		int q = a[nEnd];
		int index = nStart - 1;

		for (int i = nStart; i < nEnd; i++)
		{
			if (a[i] <= q)
			{
				index++;
				swap(a[index], a[i]);
			}
		}
		swap(a[index + 1], a[nEnd]);
		return index + 1;
	}
	return nEnd + 1;
}

//快速排序
void QuickSort(int *a,int nStart,int nEnd)
{
	if (nStart < nEnd)
	{
		int p = QuickSort1(a, nStart, nEnd);
		QuickSort(a, nStart, p - 1);
		QuickSort(a, p+1, nEnd);
	}
}
        int main()
        {
        	int a[] = { 1 ,8 , 3, 6, 5, 4, 7, 2, 9 };
        	MergeSort(a, 9);
        	
        	
        	//FindSum(a, 9, 16);
        
        	//int a[] = { 1,3,2 };
        	//InsertSort(a, 9 , (std::greater<int>()));
        	//InsertSort(a, 9);
        	//SelectSort(a, 9);
        	/*int m = 9;
        	SelectSort(a, std::move(m));*/
        	return 0;
        }