数据结构考研 - 排序（C语言）

1. 插入类排序

1.1 直接插入排序

void InsertSort(int R[ ], int n)
{
    int i, j;
    int temp;
    for (i=1;i<n;++i)
    {
        temp=R[i];  //将待插入关键字暂存于temp中
        j=i-1;
/* 下面这个循环完成了从待排关键词之前的关键词开始扫描*/
/* 如果大于待排关键词，则后移一位 */
        while (j>0 && temp<R[j])
        {
            R[j+1]=R[j];
            --j;
        }
        R[j+1]=temp; //找到插入位置，将temp中暂存的待排关键词插入
    }
}

1.2 折半插入排序

1.3 希尔排序

2. 交换类排序

2.1 气泡排序

void BubbleSort(int R[ ], int n)
{
    int i,j,flag; int temp;
    for(i=n-1;i>=1;--i)
    {
        flag=0; // 用于标记本躺排序是否发生了交换
        for(j=1;j<=i;++j)
            if(R[j-1]>R[j])
            {
                temp=R[j];
                R[j]=R[j-1];
                R[j-1]=temp;
                flag=1;
            }
        if(flag==0)
            return;
    }
}

2.2 快速排序

void QuickSort(int R[ ], int low, int high)
// 从R[low]到R[high]的关键词进行排序
{
    int temp;
    int i=low, j=high;
    if(low<high)
    {
        temp=R[low];
/* 下面循环完成了一趟排序，即将数组中小于temp的关键词放在左边，大于temp的关键词放在右边 */
        while(i<j)
        {
            while(j>i&&R[j]>=temp) --j;
            if(i<j)
            {
                R[i]=R[j];
                ++i;
            }
            while(i<j&&R[i]<temp) ++i;
            if(i<j)
            {
                R[j]=R[i];
                --j;
            }
        }
        R[i]=temp;
        QuickSort(R, low, i-1);
        QuickSort(R, i+1, high);
    }
}

3. 选择类排序

3.1 简单选择类排序

void SelectSort(int R[ ], int n)
{
    int i,j,k;
    int temp;
    for(i=0;i<n;++i)
    {
        k=i;
        /* 关键循环，从无序序列中挑出最小关键词 */
        for (j=i+1;j<n;++j)
            if(R[k]>R[j])
                k=j;
        temp=R[i];
        R[i]=R[k];
        R[k]=temp;
    }
}

4. 堆排序

/* 本函数完成在数组R[low]和R[high]的范围内对在位置low上的结点进行调整*/
void Sift(int R[],int low,int high) 
// 这里关键字的存储设定为从数组下标1开始
{
    int i=low, j=2*i;
    int temp=R[i];
    while(j<=high)
    {
        if(j<high&&R[j]<R[j+1])
            ++j;
        if(temp<R[j])
        {
            R[i]=R[j];
            i=j;
            j=2*i;
        }
        else
            break;
    }
    R[i]=temp;
}
/* 堆排序函数 */
void heapSort(int R[ ], int n)
{
    int i;
    int temp;
    for(i=n/2;i>=1;--i)
        Sift(R,i,n);
    for(i=n;i>=2;--i)
    {
        /*以下三句换成了根结点中的关键字，将其放入最终位置 */
        temp=R[1];
        R[1]=R[i];
        R[i]=temp;
        Sift(R,1,i-1);//在减少了1个关键字的无序序列中进行调整
    }
}

5. 二路归并排序

void mergeSort(int A[], int low, int high)
{
    if(low<high)
    {
        int mid=(low+high)/2
        mergeSort(A,low,mid); //归并排序前半段
        mergeSort(A,mid+1,high); //归并排序后半段
        merge(A,low,mid,high); //这里直接修改调用了线性表那一章的函数merge
    }
}