排序

计数排序
#include<iostream>
#include<assert.h>
using namespace std;
//void countSort(int *a, size_t size)
//{
//        assert(a);
//        int max = a[0]; 
//        int min = a[0];
//        for (size_t i = 1; i < size; i++)
//        {
//            if (a[i] < min)
//            {
//                min = a[i];
//            }
//            else if (a[i] > max)
//            {
//                max = a[i];
//            }
//        }
//        int range = max - min + 1;
//        int *countArray = new int[range];
//        //memset(countArray, 0, sizeof(int)*range);
//        for (size_t i = 0; i < range; i++)
//        {
//            countArray[i]=0;
//        }
//        for (size_t i = 0; i < size; i++)
//        {
//            countArray[a[i] - min]++;
//        }
//        size_t index = 0;
//        for (size_t i = 0; i < range; i++)
//        {
//            while (countArray[i]--> 0)
//            {
//                a[index++] = i + min;
//            }
//        }
//}
void PrintArray(int *a, size_t size)
{
    assert(a);
    for (size_t i = 0; i<size; i++)
    {
        cout<<a[i]<<" ";
    }
    cout << endl;      
}

基数排序
int GetMaxDigit(int *a, size_t size)
{
    int digit = 1;
    int max = 10;
    for (size_t i = 0; i < size; i++)
    {
        while (a[i] >= max)
        {
            ++digit;
            max *= 10;
        }
    }
    return digit;
}
void DigitSortLSD(int*a, size_t size)
{
    assert(a);
    int MaxBit = GetMaxDigit(a, size);
    int *bucket = new int[size];
    int count[10]; int start[10];
    int bit = 1;
    int digit = 1;
    while (bit<=MaxBit)
    {
        memset(count, 0, sizeof(int) * 10);
        memset(start, 0, sizeof(int) * 10);
        for (size_t i = 0; i < size; i++)
        {
            int num = (a[i] / digit) % 10;
            count[num]++;
        }
        start[0] = 0;
        for (size_t i = 1; i < size; i++)
        {
            start[i] = start[i - 1] + count[i - 1];

        }
        for (size_t i = 0; i < size; i++)
        {
            int num = (a[i] / digit) % 10;
            bucket[start[num]++]=a[i];
        }
        memcpy(a, bucket, sizeof(int) * 10);
        digit *= 10;
        ++bit;
    }

}
void  main()
{
    int  br[] = { 20, 80, 90, 589, 998, 965, 852, 123, 456, 789 };
    int len = sizeof(br) / sizeof(int);
    cout << "原数据如下：" << endl;
    PrintArray(br, len);
    cout << "排序后数据如下：" << endl;
    //countSort(br, len);
    DigitSortLSD(br, len);
    PrintArray(br, len);
    system("pause");
}
    


希尔排序
#include<iostream>
#include<assert.h>
using namespace std;
void ShellSort(int *a,size_t size)
{
    assert(a);
    int gap = size;
    while (gap > 1)
    {
        gap = gap / 3 + 1;
        for (int i = gap; i < size; ++i)
        {
            int index = i;
            int tmp = a[index];
            int end = index - gap;
            while (end>=0&&a[end] > tmp)
            {
                a[end + gap] = a[end];
                end -= gap;
            }
            a[end + gap] = tmp;
        }
    }
}
void Print(int *a, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        cout << a[i] << " ";
    }
    cout << endl;
}
void main()
{
    int a[10] = { 2,5,4,9,3,6,8,7,1,0 };
    Print(a, 10);
    ShellSort(a, 10);
    Print(a, 10);
    system("pause");
}

归并排序

#include<iostream>
#include<assert.h>
using namespace std;

void mergearray(int *a, int first, int mid, int last, int *temp)
{
    int i = first, j = mid + 1;
    int m = mid, n = last;
    int k = 0;
    while (i <= m && j <= n)
    {
        if (a[i] <= a[j])
            temp[k++] = a[i++];
        else
            temp[k++] = a[j++];
    }

    while (i <= m)
        temp[k++] = a[i++];

    while (j <= n)
        temp[k++] = a[j++];

    for (i = 0; i < k; i++)
        a[first + i] = temp[i];
}
void mergesort(int *a, int first, int last, int *temp)
{
    if (first < last)
    {
        int mid = (first + last) / 2;
        mergesort(a, first, mid, temp);     
        mergesort(a, mid + 1, last, temp);  
        mergearray(a, first, mid, last, temp);  
    }
}

bool MergeSort(int *a, int n)
{
    int *p = new int[n];
    if (p == NULL)
        return false;
    mergesort(a, 0, n - 1, p);
    delete[] p;
    return true;
}

void printArray(int *a, int len)
{
    for (int i = 0; i<len; i++)
        cout << a[i] << " ";
    cout << endl;
}

int main()
{
    int a[] = { 49, 38, 65, 97, 76, 13, 27, 49 };
    int len = sizeof(a) / sizeof(int);
    printArray(a, len);
    MergeSort(a, len);
    printArray(a, len);
    system("PAUSE");
    return 0;
}

//void mergearray(int *a, int begin1, int end1, int begin2,int end2, int *temp)
//{
//    assert(a);
//    int index = begin1;
//    while (begin1 <= end1&& begin2<= end2)
//    {
//        if (a[begin1] <=a[begin2])
//            temp[index++] = a[begin1++];
//        else
//            temp[index++] = a[begin2++];
//    }
//
//    while (begin1 <= end1)
//    {
//        temp[index++] = a[begin1++];
//    }
//
//    while (begin2 <= end2)
//    {
//        temp[index++] = a[begin2++];
//
//    }
//
//    for (int i = 0; i < index; i++)
//    { 
//        a[begin1 + i] = temp[i];
//    }
//    
//}
//void mergesort(int *a, int first, int last, int *temp)
//{
//    assert(a);
//    if (first < last)
//    {
//        int mid = first +(last-first) / 2;
//        mergesort(a, first, mid, temp);     
//        mergesort(a, mid + 1, last, temp);  
//        mergearray(a, first, mid,mid+1, last, temp);  
//        //memcpy(a + first, temp + first, (last - first - 1)*sizeof(int));
//    }
//}
//bool MergeSort(int *a, int n)
//{
//    int *p = new int[n];
//    if (p == NULL)
//        return false;
//    mergesort(a, 0, n - 1, p);
//    delete[] p;
//    return true;
//}
//void printArray(int *a, int len)
//{
//    for (int i = 0; i<len; i++)
//        cout << a[i] << " ";
//    cout << endl;
//}
//
//int main()
//{
//    int a[] = { 49, 38, 65, 97, 76, 13, 27, 49 };
//    int len = sizeof(a) / sizeof(int);
//    printArray(a, len);
//    MergeSort(a, len);
//    printArray(a, len);
//    system("PAUSE");
//    return 0;
//}

插入排序

#include<assert.h>
#include<iostream>
using namespace std;
void InsertSort(int *a, size_t size)
{
    assert(a);
    for (int i = 1; i < size; ++i)
    {
        int index = i;
        int tmp = a[index];
        int end = index - 1;
        while (end >= 0 && a[end]>tmp)
        {
            a[end + 1] = a[end];
            --end;
        }
        a[end + 1] = tmp;
    }
}
void PrintArray(int *a, size_t size)
{
    assert(a);
    for (int i = 0; i < size; ++i)
    {
        cout << a[i] << " ";
    }
    cout << endl;
}
void TestInsertSort()
{
    int a[10] = { 2, 5, 4, 9, 3, 6, 8, 7, 1, 0 };
    PrintArray(a, 10);
    InsertSort(a, 10);
    PrintArray(a, 10);
}


堆排序

#include<assert.h>
#include<iostream>
using namespace std;
void AdjustDown(int *a,size_t size,int root)
{
    assert(a);
    int child = 2 * root + 1;
    while (child < size)
    {
        if (child + 1 < size&&a[child + 1] > a[child])
        {
            ++child;
        }
        if (a[child]>a[root])
        {
            swap(a[child], a[root]);
            root = child;
            child = 2 * root + 1;
        }
        else
        {
            break;
        }
    }
}
void HeapSort(int *a, size_t size)
{
    assert(a);
    for (int i = (size-2)/2; i >=0; --i)
    {
        AdjustDown(a,size,i);
    }
    for (size_t i = size - 1; i > 0; --i)
    {
        swap(a[0], a[i]);
        AdjustDown(a, i, 0);
    }
}
void PrintArray(int *a, size_t size)
{
    assert(a);
    for (int i = 0; i < size; ++i)
    {
        cout << a[i] << " ";
    }
    cout << endl;
}
void TestHeapSort()
{
    int a[10] = { 2, 5, 4, 9, 3, 6, 8, 7, 1, 0 };
    PrintArray(a, 10);
    HeapSort(a, 10);
    PrintArray(a, 10);
}
int main()
{
    TestHeapSort();
    system("pause");
    return 0;
}