数据结构——7种排序——示例

#include 

#define MAXSIZE 10

typedef struct 
{
    int r[MAXSIZE];
    int length;
}SqList;

void swap(SqList *L, int i, int j)
{
    int temp = L -> r[i];
    L -> r[i] = L -> r[j];
    L -> r[j] = temp;
}

void BubbleSort0(SqList *L)//普通冒泡
{
    int i,j;
    for(i = 1; i < L -> length; i++)
    {
        for(j = i + 1; j <= L -> length; j++)
        {
            if(L -> r[i] > L -> r[j])
            {
                swap(L,i,j);
            }
        }
    }
}

void BubbleSort1(SqList *L)//正宗冒泡
{
    int i,j;
    for(i = 1; i < L -> length; i++)
    {
        for(j = L -> length - 1; j >= i; j--)
        {
            if(L -> r[j] > L -> r[j + 1])
            {
                swap(L,j,j+1);
            }
        }
    }
}

void BubbleSort2(SqList *L)//优化冒泡
{
    int i,j;
    int flag = 1;
    for(i = 1; i < L -> length && flag == 1; i++)
    {
        flag = 0;
        for(j = L -> length - 1; j >= i; j--)
        {
            if(L -> r[j] > L -> r[j + 1])
            {
                swap(L,j,j+1);
                flag = 1;
            }
        }
    }
}

void InsertSort(SqList *L)//插入排序
{
    int i,j;
    for(i = 2; i <= L -> length; i++)
    {
        if(L -> r[i] < L -> r[i - 1])
        {
            L -> r[0] = L -> r[i];
            for(j = i - 1; j > 0 && L -> r[j] > L -> r[0]; j--)
            {
                L -> r[j+1] = L -> r[j];
            }
            L -> r[j + 1] = L -> r[0];
        }
    }
}

void ShellSort(SqList *L)//希尔排序
{
    int i,j;
    int increment = L -> length;
    do
    {
        increment = increment / 3 + 1;
        for(i = increment + 1;i <= L -> length; i++)
        {
            if(L -> r[i] < L -> r[i - increment])
            {
                L -> r[0] = L -> r[i];
                for(j = i - increment; j > 0 && L -> r[j] > L -> r[0]; j -= increment)
                {
                    L -> r[j + increment] = L -> r[j];
                }
                L -> r[j + increment] = L -> r[0];
            }
        }
    }while(increment > 1);
}

void HeapAdjust(SqList *L, int s, int m)
{
    int temp = L -> r[s];
    int j;
    for(j = 2 * s; j <= m; j *= 2)
    {
        if(j < m && L -> r[j] < L -> r[j + 1])
            ++j;
        if(temp >= L -> r[j])
            break;
        L -> r[s] = L -> r[j];
        s = j;
    }
    L -> r[s] = temp;
}

void HeapSort(SqList *L)//堆排序
{
    int i;
    for(i = L -> length / 2; i > 0; i--)
        HeapAdjust(L, i, L -> length);
    for(i = L -> length; i > 1; i--)
    {
        swap(L,1,i);
        HeapAdjust(L, 1, i - 1);
    }
}

int Partition(SqList *L, int low, int high)
{
    int pivotkey = L -> r[low];
    while(low < high)
    {
        while(low < high && L -> r[high] >= pivotkey)
            high--;
        swap(L,low,high);
        while(low < high && L -> r[low] <= pivotkey)
            low++;
        swap(L,low,high);
    }
    return low;
}

void QSort(SqList *L, int low, int high)//快排
{
    int pivot;
    if(low < high)
    {
        pivot = Partition(L, low, high);
        QSort(L, low, pivot - 1);
        QSort(L, pivot + 1, high);
    }
}

int Partition1(SqList *L, int low, int high)
{
    int mid = low + (high - low) / 2;
    if(L -> r[low] > L -> r[high])
        swap(L,low,high);
    if(L -> r[mid] > L -> r[high])
        swap(L,mid,high);
    if(L -> r[low] < L -> r[mid])
        swap(L,low,mid);
    int pivotkey = L -> r[low];
    L -> r[0] = pivotkey;
    while(low < high)
    {
        while(low < high && L -> r[high] >= pivotkey)
            high--;
        L -> r[low] = L -> r[high];
        while(low < high && L -> r[low] <= pivotkey)
            low++;
        L -> r[high] = L -> r[low];
    }
    L -> r[low] = L -> r[0];
    return low;
}

void QSort1(SqList *L, int low, int high)//快排优化
{
    int pivot;
    while(low < high)
    {
        pivot = Partition(L, low, high);
        QSort(L, low, pivot - 1);
        low = pivot + 1;
    }
}

void Merge(SqList *L, int left, int mid, int right, int *tmp)
{
    int i = left;
    int j = mid + 1;
    int k = 1;
    while(i <= mid && j <= right)
    {
        if(L -> r[i] > L -> r[j])
            tmp[k++] = L -> r[j++];
        else
            tmp[k++] = L -> r[i++];
    }
    while(i <= mid)
        tmp[k++] = L -> r[i++];
    while(j <= right)
        tmp[k++] = L -> r[j++];
    k = 1;
    for(i = left; i <= right; i++)
    {
        L -> r[i] = tmp[k++];
    }
}

void MergeSort(SqList *L, int left, int right, int *tmp)
{
    if(left >= right)
        return;
    int mid = (left + right) / 2;
    MergeSort(L,left,mid,tmp);
    MergeSort(L,mid + 1,right,tmp);
    Merge(L,left,mid,right,tmp);
}

void SelectSort(SqList *L)//选择排序
{
    int i,j,min;
    for(i = 1; i < L -> length; i++)
    {
        min = i;
        for(j = i + 1; j <= L -> length; j++)
        {
            if(L -> r[min] > L -> r[j])
                min = j;
        }
        if(i != min)
            swap(L,i,min);
    }
}

void TraverseList(SqList *L)
{
    int i;
    for(i = 1; i <= L -> length; i++)
    {
        printf("%d ",L -> r[i]);
    }
    printf("\n");
}

int main()
{
    SqList L;
    int n,i,action;
    int tmp[MAXSIZE + 1];
    while(1)
    {
        printf("\t\t    1.bubble0   2.bubble1   3.bubble2   4.select    5.insert    6.shell\n");
        printf("\t\t    7.heap      8.pivot     9.pivot1    10.merge    11.print    12.exit\n");
        printf("Please input action:\n");
        scanf("%d",&action);
        if(action == 12)
            break;
        printf("Please input num:");
        scanf("%d",&n);
        L.length = n;
        for(i = 1; i <= n; i++)
        {
            printf("Please inut value:");
            scanf("%d",&L.r[i]);
        }
        switch(action)
        {
            case 1:BubbleSort0(&L);break;
            case 2:BubbleSort1(&L);break;
            case 3:BubbleSort2(&L);break;
            case 4:SelectSort(&L);break;
            case 5:InsertSort(&L);break;
            case 6:ShellSort(&L);break;
            case 7:HeapSort(&L);break;
            case 8:QSort(&L,1,n);break;
            case 9:QSort1(&L,1,n);break;
            case 10:MergeSort(&L,1,n,tmp);break;
            case 11:TraverseList(&L);break;
        }
        TraverseList(&L);
    }
    return 0;
}