各類排序算法實現

#include <stdio.h>
#include <memory.h>

#define LEN 6

//O(n2)
//stable
void DirectInsertSort(int *a, int len)
{
    int n = 0;
    int x = 0;
    int tmp = 0;
    int move = 0;
    int y = 0;

    for(n=0; n<len; n++)
    {
        tmp = a[n];
        for(x=n-1; x>=0; x--)
            if(tmp>=a[x])
            {
                a[x+1] = tmp;
                break;
            }
            else
            {
                a[x+1] = a[x];
                if(x==0) a[x] = tmp;
            }
    }
}

//O(nlogn)
//stable
void BinaryInsertSort(int *a, int len)
{
    int n = 0, x = 0;
    int left = 0, mid = 0, right = len-1;
    int tmp = 0, k;

    for(n=0; n<len; n++)
    {
        tmp = a[n];
        left = 0;
        right = n-1;

        while(left <= right)
        {
            mid = (right + left) / 2;
            if(a[mid] > a[n])
                right = mid - 1;
            else
                left = mid + 1;
        }

        for(k=n-1; k>=left; k--) a[k+1] = a[k];
        a[left] = tmp;
    }
}

//O(n1.25)
//unstable
void ShellInsertSort(int *a, int len)
{
    int gap = len;
    int x = 0;
    int n = 0;
    int tmp = 0;
    int m = 0;

    while(1)
    {
        gap = (gap%2==0) ? gap/2 : (gap+1)/2;

        for(x=0; x<gap; x++)
        {
            while(x+n*gap < len)
            {
                if(n != 0)
                {
                    tmp = a[x+n*gap];
                    for(m=1; m<=n; m++)
                    {
                        if(tmp < a[x+(n-m)*gap])
                        {
                            a[x+(n-m+1)*gap] = a[x+(n-m)*gap];
                            if(m == n) a[x+(n-m)*gap] = tmp;
                        }
                        else
                        {
                            a[x+(n-m+1)*gap] = tmp;
                            break;
                        }
                    }
                }
                n++;
            }
            n = 0;
        }

        if(gap == 1) break;
    }
}

//O(n2) : worst, O(n) : best
//stable
//swap flag
void BubbleSwapSort(int *a, int len)
{
    int n = 0;
    int m = 0;
    int tmp = 0;
    int swap = 0;

    for(n=len-1; n>=0; n--)
    {
        for(m=1; m<=n; m++)
        {
            if(a[len-m-1] > a[len-m])
            {
                tmp = a[len-m];
                a[len-m] = a[len-m-1];
                a[len-m-1] = tmp;
                swap = 1;
            }
        }
        if(swap == 0)
            break;
        else
            swap = 0;
    }
}

//very good sort algorithm.
//O(nlogn)
//O(n2) : worst
//unstable
//when n is big, this algorithm is well-performed. when n is small or most
//element of the array is in order, it's worse than others.
void QuickSwapSort(int *a, int len)
{
    int tmp = 0;
    int x = 0;
    int n = 0;
    int off = 1;

    if(len<=1) return;
    if(len==2 && a[0] > a[1])
    {
        tmp = a[1];
        a[1] = a[0];
        a[0] = tmp;
    }

    x = a[0];

    for(n=1; n<len; n++)
    {
        if(a[n] < x)
        {
            if(n!=off)
            {
                tmp = a[n];
                a[n] = a[off];
                a[off] = tmp;
            }
            off++;
        }
    }

    tmp = a[off-1];
    a[off-1] = a[0];
    a[0] = tmp;

    QuickSwapSort(a,off-1);
    QuickSwapSort(&a[off],len-off);
}

//O(n2)
//unstable
//this algorithm did not use the intermediate result
void DirectSelectSort(int *a, int len)
{
    int n = 0;
    int m = 0;

    int min = 999;
    int min_pos = -1;

    int tmp = 0;

    for(n=0; n<len; n++)
    {
        for(m=n; m<len; m++)
        {
            if(a[m] < min)
            {
                min = a[m];
                min_pos = m;
            }
        }

        if(min_pos != n && min_pos != -1)
        {
            tmp = a[n];
            a[n] = a[min_pos];
            a[min_pos] = tmp;
        }

        min = 999;
        min_pos = -1;
    }
}

#include <iostream>
#include <bitset>
#include <memory>

using namespace std;

#define LV 4
#define LV1 8
#define NUM 16

class Node
{
public:
    int d;
    int p;

    Node()
    {
        d = -1;
        p = -1;
    }

    void reset()
    {
        d = -1;
        p = -1;
    }

    void set(int _d, int _p)
    {
        d = _d;
        p = _p;
    }

    const Node& operator = (const Node &node)
    {
        d = node.d;
        p = node.p;

        return *this;
    }
};

int cal(Node *arr1, int n1)
{
    bitset<LV> bs1 = n1;
    bs1 <<= 1;
    int m1 = (int)bs1.to_ulong();

    if(arr1[m1].d == -1 && arr1[m1+1].d == -1)
        arr1[n1].reset();
    else if(arr1[m1].d == -1)
        arr1[n1] = arr1[m1+1];
    else if(arr1[m1+1].d == -1)
        arr1[n1] = arr1[m1];
    else
        if(arr1[m1].d <= arr1[m1+1].d)
            arr1[n1] = arr1[m1];
        else
            arr1[n1] = arr1[m1+1];

    bs1 = n1;
    bs1 >>= 1;
    bs1.set(bs1.size()-1);

    return (int)bs1.to_ulong();
}

//O(nlogn) better DirectSelectSort
//stable
void TournamentSort(int *a, int len)
{
    int n = 0;
    int m = 0;

    Node *arr = new Node[NUM-1];

    for(n=0; n<len; n++)
        arr[n].set(a[n],n);

    for(n=LV1; n<NUM-1; n++)
        cal(arr,n);

    for(n=0; n<len; n++)
    {
        a[n] = arr[NUM-2].d;
        m = arr[NUM-2].p;
        arr[m].reset();

        bitset<LV> bs = m;
        bs >>= 1;
        bs.set(bs.size()-1);
        m = (int)bs.to_ulong();

        while(m<=NUM-2)
            m = cal(arr, m);
    }

    delete[] arr;
}

int main(int argc, char* argv[])
{
    int n = 0;
    int a[LEN] = {21,25,49,25,16,8};

    //DirectInsertSort(a, LEN);  //直接插入排序
    //BinaryInsertSort(a, LEN);  //折半插入排序
    //ShellInsertSort(a, LEN);   //希爾排序
    //BubbleSwapSort(a, LEN);    //冒泡排序
    //QuickSwapSort(a, LEN);     //快速排序
    //DirectSelectSort(a, LEN);  //直接選擇排序
    //TournamentSort(a, LEN);  //錦標賽排序

    for(n=0; n<LEN; n++)
        printf("%d ", a[n]);

    printf("\n");

    return 0;
}