算法

<pre name="code" class="cpp">#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <string>

// 1 冒泡排序
void MPSort(int arr[],int len)
{
    assert(arr != NULL);
    int nTemp = 0;
    int nlength = len;
    for (int i = 0; i < nlength - 1; nlength --)
    {
        for (int j = 0; j < nlength - 1 ; j ++)
        {
            if (arr[j] > arr[j + 1])
            {
                nTemp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = nTemp;
            }
        }
    }
}

// 2 插入排序
void InsertSort(int arr[],int nlen)
{
    assert(arr != NULL);

    int nTemp = 0;
    for (int i = 1; i < nlen; i ++)
    {
        nTemp = arr[i];
        for (int j = 0; j < i; j ++)
        {
            if (arr[j] > nTemp)
            {
                for (int m = i; m > j; m --)
                {
                    arr[m] = arr[m-1];
                }
                
                arr[j] = nTemp;
                break;
            }
        }
    }
}

// 3 快速排序
void QuickSort(int arr[],int nleft, int nright)
{
    //assert(nleft <= nright);
    if (nleft < nright)
    {
        assert(arr != NULL);
        int nLeft = nleft;
        int nRight = nright;
        int nTemp = arr[nleft];
        while (nLeft < nRight)
        {
            while (nLeft < nRight && arr[nRight] >= nTemp)
            {
                nRight --;
            }
            if (nRight > nLeft)
            {
                arr[nLeft ++] = arr[nRight];
                //nLeft++;
            }

            while (nLeft < nRight && arr[nLeft] <= nTemp)
            {
                nLeft ++;
            }
            if (nLeft < nRight)
            {
                arr[nRight --] = arr[nLeft];
                //nRight --;
            }
        }

        arr[nLeft] = nTemp;
        QuickSort(arr,nleft,nLeft - 1);
        QuickSort(arr,nLeft + 1,nright);
    }
}

// 4 希尔排序
void ShellSort(int arr[],int nArrLen,const int nDisArr[],int nDisArrSize)
{
    assert(arr != NULL);
    int nIndex = 0;
    while (nIndex < nDisArrSize)
    {
        int nTemp = 0;
        while (nTemp < nArrLen && nTemp + nDisArr[nIndex] < nArrLen)
        {
            if (arr[nTemp] > arr[nTemp + nDisArr[nIndex]])
            {
                int ntemp = arr[nTemp];
                arr[nTemp] = arr[nTemp + nDisArr[nIndex]];
                arr[nTemp + nDisArr[nIndex]] = ntemp;
            }
            nTemp ++;
        }
        nIndex ++;
    }
    
}

// 5 选择排序
void SelectSort(int arr[], int nlen)
{
    assert(arr != NULL);

    int nIndex = 0;
    for (int i = 0; i < nlen; i ++)
    {
        nIndex = i;
        for (int j = i; j < nlen;j ++)
        {
            if (arr[j] > arr[nIndex])
            {
                nIndex = j;
            }
        }
        
        int nTemp = arr[i];
        arr[i] = arr[nIndex];
        arr[nIndex] = nTemp;
    }
}

void AdjustHeap(int arr[],int nlen,int npos)
{
    assert(arr != NULL);
    int nchild = 2 * npos + 1;
    while (nchild < nlen)
    {
        if (nchild + 1 < nlen 
            && arr[nchild] < arr[nchild + 1])
        {
            nchild ++;
        }

        if (arr[npos] < arr[nchild])
        {
            int nTemp = arr[npos];
            arr[npos] = arr[nchild];
            arr[nchild] = nTemp;
        }
	npos = nchild;
        nchild = 2 * npos +1;
    }
}

void ConstructHeap(int arr[],int nlen)
{
    assert(arr != NULL);
    for (int i = (nlen - 1) / 2;i > 0 ; i --)
    {
        AdjustHeap(arr,nlen,i);
    }
}
// 6 堆排序
void HeapSort(int arr[],int nlen)
{
    assert(arr != NULL);
    ConstructHeap(arr,nlen);
}
void PrintArr(int arr[],int nlen)
{
    assert(arr != NULL);
    for (int i = 0; i < nlen; i ++)
    {
        printf("%d  ",arr[i]);
    }
    printf("\n");
}

未完待续。