Sort~

Insertion sort, buble sort, selection sort, shell sort, quick sort, heap sort, merge sort, radix sort......

Sort seems like a simple problem but fascinating.

// SearchAlgorithm.cpp : 定义控制台应用程序的入口点。
 //
 
#include "stdafx.h"
#include <iostream>
#include <vector>
#include <math.h>

 using namespace std;

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


void InsertionSort ( vector <int> &A )
{
    for ( int i = 1 ; i < ( int )A.size() ; i++ )
    {
        int tmp = A [ i ];
        int position;
        for ( position = i  ; position>0 && A [ position - 1 ] > tmp  ; position-- )
        {
            A [ position ] = A [ position - 1 ];
        }
        A [ position ] = tmp;
    }
}


void BubleSort ( vector < int > &A )
{
    for ( int i = A.size()-1 ;  i >0 ; i-- )
    {
        for ( int j = 0 ; j < i ; j++ )
        {
            if ( A [ j ] > A [ j+1 ] )
            {
                swap ( A [ j ] , A [ j+1 ] );
            }
        }
    }
}

vector < int > ShellFunction ( int max )
{
    vector < int > Increment;
    int i = 0 , j = 0;
    int a = 9*( ( int ) pow ( 4 , ( double ) i ) )-9*( ( int ) pow ( 2 , ( double ) i ) )+1;
    int b = ( ( int ) pow ( 4 , ( double ) j ) )-3*( ( int ) pow ( 2 , ( double ) j ) )+1;
    while ( a < max || b< max )
    {
        if ( a <= 0 )
        {
            i++;
        }
        else if ( b <= 0 )
        {
            j++;
        }
        else
        {
            if ( b < a  )
            {
                Increment.push_back ( b );
                j ++;
            }
            else 
            {
                Increment.push_back ( a );            
                i++;
            }            
        }
    a = 9*( ( int ) pow ( 4 , ( double ) i ) )-9*( ( int ) pow ( 2 , ( double ) i ))+1;
    b = ( ( int ) pow ( 4 , ( double ) j ) )-3*( ( int ) pow ( 2 , ( double ) j ) )+1;
    }

    return Increment;
}

void ShellSort ( vector < int > &A )
{
    vector < int > Increment;

    Increment = ShellFunction (  ( int ) A.size () );
    
    for ( int increment = Increment.size() - 1 ; increment >=0 ; increment --  )
    {
        for ( int i = Increment [ increment ] ; i < ( int ) A.size () ; i ++ )
        {
            int tmp = A [ i ];
            int j;
            for ( j = i ; j >= Increment [ increment ] ; j-= Increment [ increment ] )
            {
                if ( tmp < A [ j - Increment [ increment ] ] )
                {
                    A [ j ] = A [ j - Increment [ increment ] ];
                }
                else
                {
                    break;
                }
            }
            A [ j ] = tmp;
        }
    }
}


void SelectSort ( vector < int > &A )
{
    for ( int i = A.size()-1 ; i >0 ; i-- )
    {
        int max = 0 ;
        for ( int j = 0 ; j <= i ; j++ )
        {
            if ( A [ max ] < A [ j ] )
            {
                max = j;
            }
        }
        swap ( A [ max ] , A [ i ] );
    }
}

void Merge ( vector < int > &A , vector < int > &tmp , int lbegin , int rbegin , int rend )
{
    int LeftBegin = lbegin;
    int RightBegin = rbegin;
    int LeftEnd = rbegin - 1;
    int RightEnd = rend;
    int LeftPosition = LeftBegin;
    int RightPosition = RightBegin;
    int MergePosition = LeftBegin; 

    while ( LeftPosition <= LeftEnd && RightPosition <= RightEnd )
    {
        if ( A [ LeftPosition ] < A [ RightPosition ] )
        {
            tmp [ MergePosition ] = A [ LeftPosition  ];
            MergePosition ++;
            LeftPosition ++;
        }
        else
        {
            tmp [ MergePosition ] = A [ RightPosition ];
            MergePosition ++;
            RightPosition ++;        
        }
    }

    while ( LeftPosition <= LeftEnd )
    {
        tmp [ MergePosition ] = A [ LeftPosition ];
        MergePosition ++;
        LeftPosition ++;
    }

    while ( RightPosition <= RightEnd )
    {
        tmp [ MergePosition ] = A [ RightPosition ];
        MergePosition ++;
        RightPosition ++;    
    }

    for ( int i = LeftBegin ; i <= RightEnd ; i++ )
    {
        A [ i ] = tmp [ i ];
    }

}

void MSort ( vector < int > &A , vector < int > &tmp , int begin , int end )
{
    if ( end - begin >= 1 )
    {
        MSort ( A , tmp , begin , ( begin + end ) / 2  );
        MSort ( A , tmp , ( begin + end ) / 2+1 , end );
        Merge ( A , tmp , begin , ( begin + end ) / 2+1 , end );
    }
}


void MergeSort ( vector < int > &A )
{
    if ( ( int )A.size() > 1  )
    {
        vector < int > tmp ( A.size() , 0 );
        MSort ( A , tmp , 0 , ( int )A.size() - 1  );
    }
}


int Median3 ( vector  < int > &A , int left , int right )
{
    if ( right > left )
    {
        int center = ( right + left ) / 2;
        if ( A [ left ] > A [ center ] )
        {
            swap ( A [ left ] , A [ center ] );
        }
        
        if ( A [ center ] > A [ right ] )
        {
            swap ( A [ center ] , A [ right ] );
        }

        if ( A [ left ] > A [ center ] )
        {
            swap ( A [ left ] , A [ center ] );
        }

        swap ( A [ center ] , A [ right - 1 ] );

        return A [ right - 1 ];
    }
    else 
    {
        return A [ right ];
    }
}


void QSort ( vector < int > &A , int begin , int end )
{
    if ( end - begin > 1 )
    {
        int pivot = Median3 ( A , begin , end );   //pick the pivot
        int i = begin , j = end -1 ;
        for ( ;  ; )
        {
            while ( A [ ++i ] < pivot )
            {}
            while ( A [ --j ] > pivot )
            {}
            if ( i < j )
            {
                swap ( A [ i ] , A [ j ] );
            }
            else 
            {
                break;
            }
        }
        swap ( A[ i ] , A [ end - 1 ] );

        QSort ( A , begin , i -1 );
        QSort ( A , i+1 , end );
    }
    else if ( end - begin == 1 )
    {
        if ( A [ begin ] > A [ end ] )
        {
            swap ( A [ begin ] , A [ end ] );
        }
    }
}


void QuickSort ( vector < int > &A )
{
    if ( ( int ) A.size() > 5 )   // if size is small, we prefer insertion sort
    {
        QSort ( A , 0 , ( int )A.size() - 1 );
    }
    else
    {
        InsertionSort ( A );
    }
}


void RadixSort ( vector < int > &A , int digits )
{
    for ( int i = 0 ; i < digits ; i++ )
    {
        vector < vector < int > > bucket ( 10 );
        for ( int bucketnum = 0 ; bucketnum < ( int )bucket.size() ; bucketnum++ )
        {
            bucket [ bucketnum ] .clear();
        }
        for ( int j = 0 ; j < ( int ) A.size() ; j++ )
        {
            int m = ( int )( A [ j ] / pow ( 10 , ( double ) i ) );
            m = m % 10;
            bucket [ m ].push_back ( A [ j ] );
        }

        for ( int digit= 0 , position = 0 ; digit < 10 && position < ( int )A.size(); digit++ )
        {    
            if ( !bucket [ digit ].empty() )
            {
                for ( int  num = 0 ; num < ( int ) bucket [ digit ].size() ; num++ )
                {
                    A [ position ] = bucket [ digit ] [ num ];
                    position ++;
                }
            }
        }
    }
}

int _tmain(int argc, _TCHAR* argv[])
{
    vector < int > v;
    for ( int i = 0 ; i < 100 ; i ++ )
    {
        v.push_back ( rand() % 100 );
    }

    for ( int i = 0 ; i < ( int )v.size() ; i++ )
    {
        cout << v [ i ] << endl;
    }


    cout << endl;
    MergeSort( v );
    for ( int i = 0 ; i < ( int )v.size() ; i++ )
    {
        cout << v [ i ] << endl;
    }
    cout << "done";

    cout << endl;
    QuickSort( v );
    for ( int i = 0 ; i < ( int )v.size() ; i++ )
    {
        cout << v [ i ] << endl;
    }
    cout << "done";

    cout << endl;
    RadixSort( v , 2 );
    for ( int i = 0 ; i < ( int )v.size() ; i++ )
    {
        cout << v [ i ] << endl;
    }
    cout << "done";


    getchar();
     
    return 0;
}