排序

#include <iostream>、
using namespace std;

//插入排序
void insert_sort(int data[],int n)
{
    int i, j,tmp;
    for (int i = 1; i < n; i++)//进行n-1趟
    {
        tmp = data[i];
        for (j = i; j > 0; j--)
        {
            if (data[j - 1] > tmp)
                data[j] = data[j - 1];
            else
                break;
        }
        data[j] = tmp;
    }
}
//希尔排序
void shell_sort(int data[], int n)
{
    int i, j, increment=n/2,tmp;
    for(increment=n/2;increment>0;increment/=2)
        for (i = increment; i < n; i+=increment)
        {
            tmp = data[i];
            for (j = i; j > 0; j -= increment)
            {
                if (data[j - increment] > tmp)
                    data[j] = data[j - increment];
                else
                    break;
            }
            data[j] = tmp;
        }
}
//堆排序
typedef struct heap_record
{
    int capacity;
    int size;
    int *array;
}*Heap;
Heap initialize(int cap)
{
    Heap H=(Heap)malloc(sizeof(heap_record));
    if (!H) return NULL;
    H->capacity = cap;
    H->size = 0;
    H->array = (int*)malloc(sizeof(int)*(cap+1));
    H->array[0] = -1;//array[0]不用，作为标记
    return H;
}
bool isempty(Heap H)
{
    return H->size == 0;
}
bool isfull(Heap H)
{
    return H->size == H->capacity;
}
void insert(Heap H,int x)
{
    int i;
    if (isfull(H))
        return;
    for (i=++H->size; i != 0&&H->array[i / 2] > x;i/=2)
        H->array[i] = H->array[i / 2];
    H->array[i] = x;
}
int delete_min(Heap H)
{
    if (isempty(H))
        cout<<"堆为空"<<endl;
    int i, child,tmp=H->array[H->size],delete_num=H->array[1];
    --H->size;
    for (i = 1; 2*i <= H->size; i =child)
    {
        child = 2*i;
        if (child<H->size&&H->array[child+1] < H->array[child ])
            child++;
        if(tmp>H->array[child])
            H->array[i] = H->array[child];
        else
            break;
    }
    H->array[i] = tmp;
    return delete_num;
}
Heap heap_sort(int data[], int n)
{
    Heap H;
    int delete_num;
    H = initialize(n);
    for (int i = 0; i < n; i++)
        insert(H, data[i]);//创建堆
    for (int i = 0; i < n; i++)
    {
        delete_num = delete_min(H);
        H->array[n - i] = delete_num;
    }
    return H;
}
//归并排序
void merge(int A[],int Tmp[],int lpos,int rpos,int rend)//归并操作
{//lpos是左边部分的第一个位置，rpos是右边部分的第一个位置，rend是右边的最后的位置
    int tmpos, lend;
    tmpos = lpos; lend = rpos - 1;
    int num = rend - lpos + 1;
    while (lpos <= lend && rpos <= rend)
    {
        if (A[lpos] < A[rpos])
        {
            Tmp[tmpos] = A[lpos];
            tmpos++; lpos++;
        }
        else
        {
            Tmp[tmpos] = A[rpos];
            tmpos++; rpos++;
        }
    }
    while (lpos <= lend)
    {
        Tmp[tmpos] = A[lpos];
        lpos++; tmpos++;
    }
    while (rpos <= rend)
    {
        Tmp[tmpos] = A[rpos];
        rpos++; tmpos++;
    }
    for (int i = 0; i < num; i++)//将排好序的数组拷贝回原来的A数组
        A[i] = Tmp[i];
 }
void divide(int A[],int Tmp[],int left,int right)
{//将数组分成小块排序，用递归实现
    int center;
    if (left < right)
    {
        center = (left + right) / 2;
        divide(A, Tmp, left, center);
        divide(A, Tmp, center + 1, right);
        merge(A, Tmp, left, center + 1, right);
    }
}
void merge_sort(int A[], int n)
{
    int *Tmp;
    Tmp = (int*)malloc(sizeof(int)*n);
    divide(A, Tmp, 0, n - 1);
    free(Tmp);
}
//快速排序
int partition(int A[],int low,int high)
{//将大于pivot的元素置于其右边，小于pivot的元素置于其左边
    int pivotkey;
    pivotkey = A[low];//用第一个元素做枢纽元
    while (low < high)
    {
        while (low < high&&A[high] >= pivotkey) { high--; }
        A[low] = A[high];
        while (low < high&&A[low] <= pivotkey) { low++; }
        A[high] = A[low];
    }
    A[low] = pivotkey;
    return low;//返回pivot位置
}
void quick_sort(int A[], int low, int high)
{
    int pivot;
    if (low < high)//当元素个数大于1时
    {
        pivot = partition(A, low, high);
        quick_sort(A, low, pivot - 1);
        quick_sort(A, pivot + 1, high);
    }
}
//用快速排序解决快速选择问题
int quick_select(int A[], int k, int low, int high)
{//找出一组数据中第k个最小元
    int pivot;
    pivot = partition(A, low, high);
    if (k - 1 == pivot)//如果枢纽元处的元素恰好是第k个元素，则返回该元素
        return A[k - 1];
    if (k - 1 < pivot)//如果第k个位置在枢纽元前面，则在前面的数据中找
        return quick_select(A, k, low, pivot - 1);
    if (k - 1 > pivot)//如果第k个位置在枢纽元后面，则在后面的数据中找
        return quick_select(A, k, pivot + 1, high);
}
int main()
{
    //插入排序
    int data0[] = { 34,8,64,51,32,21 };
    insert_sort(data0, 6);
    for (int i = 0; i < 6; i++)
        cout << data0[i] << " ";
    cout << endl;
    //希尔排序
    int data1[] = { 81,94,11,96,12,35,17,95,28,58 };
    shell_sort(data1, 10);
    for (int i = 0; i < 10; i++)
        cout << data1[i] << " ";
    cout << endl;
    //堆排序
    int data2[] = { 32,7,62,49,21,19 };
    Heap H=heap_sort(data2, 6);
    for (int i = 6; i > 0; i--)
        cout << H->array[i] << " ";
    cout << endl;
    //归并排序
    int data3[] = { 13,1,26,24,2,15,38,27 };
    merge_sort(data3, 8);
    for (int i = 0; i <8; i++)
        cout << data3[i] << " ";
    cout << endl;
    //快速排序
    int data4[] = { 49,38,65,97,76,13,27,49 };
    quick_sort(data4, 0, 7);
    for (int i = 0; i < 8; i++)
        cout << data4[i] << " ";
    cout << endl;
    int a=quick_select(data4, 1, 0, 7);
    cout << a << endl;
    system("pause");
    return 0;
}

运行结果：