排序——数据结构课程作业

 (╥╯^╰╥)

/*
请设计直接插入排序算法函数void insertSort(int a[],int n)，对a[1]..a[n]进行升序排序。
并测试在不同数据规模下的排序效率。
*/
#include "Arrayio.h"
#define N 10000     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/

/*请将本函数补充完整，并进行测试*/
void insertSort(int a[],int n)
{
    /*直接插入排序*/
    int i;
    for(i=2; i<=n; i++)
    {
        if(a[i]<a[i-1])
        {
            int j = i-1;
            int tmp = a[i];
            while(tmp<a[j])
            {
                a[j+1] = a[j];
                j--;
            }
            a[j+1] = tmp;
        }
    }
}

int  main()
{
    int a[N+1],n;                     /*数据存储在a[1]...a[N]中*/
    printf("数据初始化...
");
    n=readData(a,N,"data1.txt");      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
    printf("%d个数据排序中...
",n);
    insertSort(a,n);
    saveData(a,n,"out.txt");          /*排序结果存放在out.txt文件中*/
    printf("排序结束，排序结果保存在out.txt文件中。
");
    return 0;
}

/*
请设计二分插入排序算法函数void binInsertSort(int a[],int n)，对a[1]..a[n]进行升序排序。
并测试在不同数据规模下的排序效率。
*/
#include "Arrayio.h"
#define N 10000     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/
#include <algorithm>

using namespace std;


/*请将本函数补充完整，并进行测试*/
void insertSort(int a[],int n)
{
    /*直接插入排序*/
    for(int i=2; i<=n; i++)
    {
        if(a[i]<a[i-1])
        {
            int j = i-1;
            int tmp = a[i];
            while(tmp<a[j])
            {
                a[j+1] = a[j];
                j--;
            }
            a[j+1] = tmp;
        }
    }
}

void binInsertSort(int a[],int n)
{
    for(int i=2;i<=n;i++) {
        if(a[i]<a[i-1]) {
            int pos = lower_bound(a+1,a+i,a[i]) - a;
            for(int j=i-1;j<=pos+1;j--)
                a[j+1] = a[j];
            a[pos+1] = a[i];
        }
    }
}

int  main()
{
    int a[N+1],n;                     /*数据存储在a[1]...a[N]中*/
    printf("数据初始化...
");
    n=readData(a,N,"data1.txt");      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
    printf("%d个数据排序中...
",n);
    insertSort(a,n);
    saveData(a,n,"out.txt");          /*排序结果存放在out.txt文件中*/
    printf("排序结束，排序结果保存在out.txt文件中。
");
    return 0;
}

/*
请设计shell排序算法函数void shellSort(int a[],int n)，对a[1]..a[n]进行升序排序。
并测试在不同数据规模下的排序效率。
*/
#include "Arrayio.h"
#define N 10000     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/

/*请将本函数补充完整，并进行测试*/
void shellSort(int a[],int n)
{
    for(int d=n/2;d>=1;d=d/2)
    {
        for(int i=d+1;i<=n;i++) {
            int tmp = a[i];
            int j;
            for(j=i-d;j>0&&tmp<a[j];j=j-d) {
                a[j+d] = a[j];
            }
            a[j+d] = tmp;
        }
    }

}

int  main()
{
    int a[N+1],n;                     /*数据存储在a[1]...a[N]中*/
    printf("数据初始化...
");
    n=readData(a,N,"data1.txt");      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
    printf("%d个数据排序中...
",n);
    shellSort(a,n);
    saveData(a,n,"out.txt");          /*排序结果存放在out.txt文件中*/
    printf("排序结束，排序结果保存在out.txt文件中。
");
    return 0;
}

/*
请设计简单选择排序算法函数void selectSort(int a[],int n)，对a[1]..a[n]进行升序排序。
并测试在不同数据规模下的排序效率。
*/
#include "Arrayio.h"
#define N 10000     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/
#include <algorithm>

using namespace std;

/*请将本函数补充完整，并进行测试*/
void selectSort(int a[],int n)
{
    for(int i=1;i<n;i++) {
        int k = i;
        for(int j=i+1;j<=n;j++) {
            if(a[j]<a[k])
                k = j;
        }
        if(k!=i)
        {
            swap(a[i],a[k]);
        }
    }
}

int  main()
{
    int a[N+1],n;                     /*数据存储在a[1]...a[N]中*/
    printf("数据初始化...
");
    n=readData(a,N,"data1.txt");      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
    printf("%d个数据排序中...
",n);
    selectSort(a,n);
    saveData(a,n,"out.txt");          /*排序结果存放在out.txt文件中*/
    printf("排序结束，排序结果保存在out.txt文件中。
");
    return 0;
}

/*
请设计筛选函数void sift(int a[],int k,int n)，对a[k] 进行筛选，
并利用其设计堆排序算法函数void heapSort(int a[],int n)，
对a[1]..a[n]进行升序排序。并测试在不同数据规模下的排序效率。（详见lab10_05.c）
*/
#include "Arrayio.h"
#define N 10000     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/

/*请将本函数补充完整，并进行测试*/
void sift(int a[],int k,int n)
{
    int i,j,finished;
    i=k;
    j=2*i;
    a[0]=a[k];
    finished=0;
    while((j<=n)&&(!finished))
    {
        if((j<n)&&(a[j+1]>a[j]))
            j++;
        if(a[0]>=a[j])
            finished=1;
        else
        {
            a[i]=a[j];
            i=j;
            j=2*j;
        }
    }
    a[i]=a[0];
}

void heapSort(int a[],int n)
{
    int i;
    for (i=n/2; i>=1; i--)
        sift(a,i,n);
    for (i=n; i>1; i--)
    {
        a[0]=a[i];
        a[i]=a[1];
        a[1]=a[0];
        sift(a,1,i-1);
    }
}

int  main()
{
    int a[N+1],n;                     /*数据存储在a[1]...a[N]中*/
    printf("数据初始化...
");
    n=readData(a,N,"data1.txt");      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
    printf("%d个数据排序中...
",n);
    heapSort(a,n);
    saveData(a,n,"out.txt");          /*排序结果存放在out.txt文件中*/
    printf("排序结束，排序结果保存在out.txt文件中。
");
    return 0;
}

/*
请设计冒泡排序算法函数void bubbleSort(int a[],int n)，对a[1]..a[n]进行升序排序。
并测试在不同数据规模下的排序效率。
*/
#include "Arrayio.h"
#define N 10000     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/
#include <algorithm>

using namespace std;

/*请将本函数补充完整，并进行测试*/
void bubbleSort(int a[],int n)
{
    for(int i=1;i<=n-1;i++) {
        bool flag = true;
        for(int j=1;j<=n-i;j++) {
            if(a[j]>a[j+1]) {
                swap(a[j],a[j+1]);
                flag = false;
            }
        }
        if(flag) return ;
    }
}

int  main()
{
    int a[N+1],n;                     /*数据存储在a[1]...a[N]中*/
    printf("数据初始化...
");
    n=readData(a,N,"data1.txt");      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
    printf("%d个数据排序中...
",n);
    bubbleSort(a,n);
    saveData(a,n,"out.txt");          /*排序结果存放在out.txt文件中*/
    printf("排序结束，排序结果保存在out.txt文件中。
");
    return 0;
}

/*
请设计快速排序算法函数void quickSort(int a[],int low,int right)，对a[low]..a[right]进行升序排序。
并测试在不同数据规模下的排序效率。
*/
#include "Arrayio.h"
#define N 10000     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/

/*请将本函数补充完整，并进行测试*/
void quickSort(int a[],int low,int right )
{
    int i = low, j = right;
    int tmp = a[low];
    if(low<right)
    {
        while(i<j)
        {
            while(i<j&&a[j]>=tmp)
                j--;

            if(i<j)
            {
                a[i] = a[j];
                i++;
            }

            while(i<j&&a[i]<=tmp)
                i++;

            if(i<j)
            {
                a[j] = a[i];
                j--;
            }
        }
        a[i] = tmp;
        quickSort(a,low,j-1);
        quickSort(a,j+1,right);
    }
}

int  main()
{
    int a[N+1],n;                     /*数据存储在a[1]...a[N]中*/
    printf("数据初始化...
");
    n=readData(a,N,"data1.txt");      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
    printf("%d个数据排序中...
",n);
    quickSort(a,1,n);
    saveData(a,n,"out.txt");          /*排序结果存放在out.txt文件中*/
    printf("排序结束，排序结果保存在out.txt文件中。
");
    return 0;
}