内部排序-C语言

一、前言

1.内部排序与外部排序

  根据排序时数据所占用存储器的不同，可将内存分为两类。一类是整个排序过程完全在内存中进行，称为内部排序；另一类是由于待排序记录数据量太大，内存无法容纳全部数据，排序需要借助外部存储设备才能完成，称为外部排序。

2.主关键字与次关键字

  关键字可以是记录的主关键字，也可以是次关键字，甚至可以是记录中若干数据项的组合。若K是主关键字，则任何一个无序的记录序列经排序后得到的有序序列是唯一的；若K是次关键字或是记录中若干数据项的组合，得到的排序结果可能是不唯一的，因为待排序记录的序列中存在两个或两个以上关键字相等的记录。

3.排序的稳定性

  假设在待排序中存在多个具有相同关键字的记录。设K(i)=K(j)( 1 <= i <= n , 1 <= j <= n,i != j )，若在排序前的序列中R(i)领先于R(j)(即I<j)，经过排序后得到的序列中R(i)仍领先于R(j)，则称所用的排序方法是稳定的；反之，若相同关键字的领先关系在排序过程中发生变化，则称所用的排序方法是不稳定的。无论是稳定的还是不稳定的排序方法，均能排好序。

二、插入类排序

  插入排序的基本思想：在一个已排好序的记录子集的基础上每一步将下一个待排序的记录插入到已排好序的记录子集中，直到将所有待排记录全部插入为止。

1.直接插入排序

直接插入排序算法的执行过程：

【算法描述】直接插入排序

#include <stdio.h>
#include <string.h>
void InsSort(int a[],int length)
{
    int num;
    int i,j;
    for(i=1;i<length;i++)
    {
        num=a[i];
        j=i-1;
        while(j>=0&&num<a[j])
        {
            a[j+1]=a[j];
            j=j-1;
        }
        a[j+1]=num;
    }
}
int main()
{
    int n,i;
    int a[100];
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    InsSort(a,n);
    for(i=0;i<n;i++)
    {
        printf("%d ",a[i]);
    }
    return 0;
}

[算法分析] 直接插入排序算法简便，比较适用于待排序记录数目较少且基本有序的情况。直接插入排序方法是稳定的排序方法。在直接插入排序算法中，由于待插入元素的比较是从后向前进行的，循环 while(j>=0&&num<a[j]) 的判断条件就保证了后面出现的关键字不可能插入到前面相同的关键字之前，因此保证了直接插入排序方法的稳定性。

2.折半插入排序

【算法描述】折半插入排序

#include <stdio.h>
#include <string.h>
void BinSort(int a[],int length)
{
    int num;
    int i,j,low,high,mid;
    for(i=1;i<length;i++)
    {
        num=a[i];
        low=0;
        high=i-1;
        while(low<=high)
        {
            mid=(low+high)/2;
            if(num<a[mid])
            {
                high=mid-1;
            }
            else
            {
                low=mid+1;
            }
        }
        for(j=i-1;j>=low;j--)
        {
            a[j+1]=a[j];
        }
        a[low]=num;
    }
}
int main()
{
    int n,i;
    int a[100];
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    BinSort(a,n);
    for(i=0;i<n;i++)
    {
        printf("%d ",a[i]);
    }
    return 0;
}

[算法分析] 采用折半插人排序法，可减少关键字的比较次数。每插人一个元素，需要比较的次数最大为折半判定树的深度，如插人第i个元素时，设 i=2^j ，则需进行log(2)i次比较，因此插人n-1个元素的平均关键字的比较次数为nlog(2)n。当n较大时，折半插入排序法的比较次数比直接播人排序的最差情况要好很多，但比其最好情况要差。虽然折半插人排序法与直接插入排序法相比较，改善了算法中比较次数的数量级，但其并未改变移动元素的时间耗费。

3.希尔排序

希尔排序算法的执行过程：

【算法描述】希尔排序

#include <stdio.h>
void ShellSort(int a[],int length)
{
    int i,j,delta;
    int data;
    for(delta=length/2;delta>=1;delta=delta/2)
    {
        for(i=delta;i<length;i++)
        {
            if(a[i]<a[i-delta])
            {
                data=a[i];
                for(j=i-delta;j>=0&&data<a[j];j-=delta)
                {
                    a[j+delta]=a[j];
                }
                a[j+delta]=data;
            }
        }
    } //for
} //ShellSort
int main()
{
    int n,i;
    int a[100];
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    ShellSort(a,n);
    for(i=0;i<n;i++)
    {
        printf("%d ",a[i]);
    }
    return 0;
}

三、交换类排序

1.冒泡排序

冒泡排序算法的执行过程：

2.快速排序

快速排序算法的执行过程：

【算法描述】快速排序

#include <stdio.h>
void Swap(int *, int *); //函数声明, 交换两个变量的值
void QuickSort(int *, int, int); //函数声明, 快速排序
int main(void)
{
    int i; //循环变量
    int a[] = {800, 4, -25, 3, 34, 5, 25, 7, 32, 4, 43, 9, 1, 56, 8,-70, 635, -234, 532, 543, 2500};
    QuickSort(a, 0, 20);
    printf("最终排序结果为:\n");
    for (i=0; i<21; ++i)
    {
        printf("%d ", a[i]);
    }
    printf("\n");
    return 0;
}
void QuickSort(int *a, int low, int high)
{
    int i = low;
    int j = high;
    int key = a[low];
    if (low >= high) //如果low >= high说明排序结束了
    {
        return ;
    }
    while (low < high) //该while循环结束一次表示比较了一轮
    {
        while (low < high && key <= a[high])
        {
            --high; //向前寻找
        }
        if (low < high)
        {
            a[low]=a[high];
            //Swap(&a[low], &a[high]);
            ++low;
        }
        while (low < high && key >= a[low])
        {
            ++low; //向后寻找
        }
        if (low<high)
        {
            a[high]=a[low];
            //Swap(&a[low], &a[high]);
            --high;
        }
    }
    a[low]=key;
    QuickSort(a, i, low-1); //用同样的方式对分出来的左边的部分进行同上的做法
    QuickSort(a, low+1, j); //用同样的方式对分出来的右边的部分进行同上的做法
}

四、选择类排序

1.简单选择排序

简单选择排序算法的执行过程：

【算法描述】简单选择排序

#include <stdio.h>
void SelectSort(int *a,int length);
int main()
{
    int i;
    int array[]={90,100,30,50,1,5,9,3,2,70,40,30,50,-1};
    //计算数组的长度
    int lengths=sizeof(array)/sizeof(array[0]);
    //使用简单排序算法对数组排序
    SelectSort(array,lengths);
    for(i=0;i<lengths;i++){
        printf("%d ",array[i]);
    }
    return 0;
}
void SelectSort(int *a,int length)
{
    int i,j,k,n;
    for(i=0;i<length;i++)
    {
        k=i;
        for(j=i+1;j<length;j++)
        {
            if(a[k]>a[j])
            {
                k=j;
            }
        }
        if(k!=i)
        {
            n=a[i];
            a[i]=a[k];
            a[k]=n;
        }
    }
}

五、归并排序

归并排序算法的执行过程：

【算法描述】归并排序

#include <stdio.h>
#include <string.h>
void Merge(int a[],int l,int r,int mid)
{
    int i,j,k;
    int aux[r-l+1];
    for(k=l;k<=r;k++)
    {
        aux[k-l]=a[k];
    }
    i=l;
    j=mid+1;
    for(k=l;k<=r;k++)
    {
        if(i>mid)
        {
            a[k]=aux[j-l];
            j++;
        }
        else if(j>r)
        {
            a[k]=aux[i-l];
            i++;
        }
        else if(aux[i-l]>aux[j-l])
        {
            a[k]=aux[j-l];
            j++;
        }
        else
        {
            a[k]=aux[i-l];
            i++;
        }
    }
}
void MSort(int a[],int l,int r)
{
    if(l>=r)
        return ;
    int  mid=(l+r)/2;
    MSort(a,l,mid);
    MSort(a,mid+1,r);
    Merge(a,l,r,mid);
}
void MergeSort(int a[],int l,int length)
{
    MSort(a,l,length-1);
}

int main()
{
    int n,i;
    int a[100];
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    MergeSort(a,0,n);
    for(i=0;i<n;i++)
    {
        printf("%d ",a[i]);
    }
    return 0;
}

六、时间复杂度