排序算法

希尔排序

template <class T>
void ShellSort( T arr[] ,  int N ) 
{
        int h   ;
        for( ; h <= N/9 ; h = h*3+1) ;
        for( ; h>0; h /=3)
        {
            for( int i = h ; i < N ;++i )
            {
                if( arr[i-h] > arr[i]) 
                {
                    T tmp = arr[i] ;
                    int j =i  ; 
                    for( ;j > 0 && arr[j-h] > tmp ; j -= h)
                    {
                        arr[j] = arr[j-h] ;
                    }
                    arr[j] = tmp ; 
                }
            }
        }
}

冒泡排序

template <class T>
void BubbleSort( T arr[] ,  int  N) 
{
    for( int i = 0 ; i < N -1 ; ++i )
    {
        bool bExchange = false; 
        for(  int j = 0 ; j < N -1 -i ;j++ )
        {
            if(arr[j] > arr[j+1])
            {
                T tmp = arr[j] ;
                arr[j] = arr[j+1] ;
                arr[j+1] = tmp ; 
                bExchange = true ; 
            }
        }
        if( !bExchange )
        {
            break;
        }
    }
}

快速排序

template <class T>
int GetPrivote( T arr[] , int start ,int end )
{
    int iPivote = arr[start] ; 
    int s = start ;
    int e =end ; 
    while( s != e )
    {
        while(e>s && arr[e] > iPivote )
        {
            e-- ; 
        }
        while( s< e && arr[s] <= iPivote )
        {
            s++ ; 
        }
        if(s < e)
        {
            T tmp = arr[s] ; 
            arr[s] = arr[e] ;
            arr[e] = tmp ; 
        }
    }
    arr[start] = arr[s] ; 
    arr[s] = iPivote ; 
    return s ; 

}


template <class  T>
void QuickSort( T arr[]  ,int start ,int end)
{
    int s = start ; 
    int e = end ; 
    if( s < e )
    {
        int iPrivot = GetPrivote( arr , s, e ) ;
        QuickSort(arr,s ,iPrivot-1 ) ; 
        QuickSort( arr ,iPrivot+1 , e ) ; 
    }
}

堆排序

template <class T>
void HeadUp( T arr[] ,int start ,int end )
{
    int iFather = start ;
    int iChild= iFather*2 +1 ; 
    while( iChild < end )
    {
        if( iChild+1 < end && arr[iChild+1] > arr[iChild])
        {
            iChild++; 
        }
        if(arr[iFather] <= arr[iChild])
        {
            T tmp = arr[iFather] ;
            arr[iFather] = arr[iChild] ;
            arr[iChild] = tmp ; 
            iFather = iChild ; 
            iChild = iChild*2 +1 ; 
        }
        else
        {
            break;
        }
    }

}
template <class T>
void CreateHeap(T arr[] , int size)
{
    for( int i= size-1/2 ; i >=0 ; i--)
    {
        HeadUp<T>( arr , i , size ) ;  
    }
}

template<class T>
void HeadSort( T arr[] , int size ) 
{
    CreateHeap<T>( arr ,size  ) ;
    for( int  i = size-1 ; i > 0 ; )
    {
        T tmp = arr[0] ;
        arr[0] = arr[i] ; 
        arr[i] = tmp;
        HeadUp<T>(arr , 0 ,--i) ; 
    }
}

二分查找

    template<class T>
    int BinarySeach( T arr[] , int value , int start , int end)
    {
        int low = start ;
        int high  = end ; 
        if( low <= high)
        {
            int mid = (high+low)/2 ;
            if ( arr[mid] ==  value )
            {
                return mid ; 
            }
            if( arr[mid] > value )
            {
                BinarySeach(arr , value , low , mid-1 ) ; 
            }
            else
            {
                BinarySeach(arr , value ,mid+1 , high ) ; 
            }
        }
    }