插入排序、冒泡排序、希尔排序

C语言_插入排序代码及实现

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
typedef struct
{
    int key;//关键字
}JD;

void sreaisort(JD r[])
{
    int i,j;
    for(int i = 2; i<=10; i++)
    {
        r[0] = r[i];//暂存r[i],r[0]作为岗哨
        j = i-1;//从后向前遍历
        while(r[0].key < r[j].key)
        {
            r[j+1] = r[j];//后移
            j--;
        }
        r[j+1] = r[0];
    }
}
void output(JD r[])
{
    for(int i=1; i<=10; i++)
        printf("%-2d", r[i].key);
    printf("\n");
}

void input(JD r[])
{
    srand(time(NULL));//生成随机数
    for(int i=1; i<=10; i++)
        r[i].key = rand()%9+1;
}

int main()
{
    JD r[11];
    input(r);
    output(r);
    sreaisort(r);
    output(r);
    return 0;
}

项目	Value
平均时间复杂度	O(N²）
最坏时间复杂度	O(N²）
最好时间复杂度	O(N）
空间复杂度	O(1)
稳定性	稳定
复杂性	简单

分析：数据越接近有序，比较次数越少，性能越好。

冒泡排序代码及实现

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

typedef struct
{
    int key;
}RecData;

void input(RecData r[])
{
    srand(time(NULL));
    for(int i=0; i<10; i++)
        r[i].key = rand()%9+1;
}
void output(RecData r[])
{
    for(int i=0; i<10; i++)
        printf("%-2d", r[i]);
    printf("\n");
}
void Bubblesort(RecData r[])
{
    int flag;
    RecData vis;
    for(int i=1; i<10; i++)
    {
        flag = 0;
        for(int j=0; j<10-i; j++)
        {
            if(r[j].key > r[j+1].key)
            {
                flag = 1;
                vis = r[j];
                r[j] = r[j+1];
                r[j+1] = vis;
            }
        }
        if(flag == 0)
            return ;
    }
}

int main()
{
    RecData r[10];
    input(r);
    output(r);
    Bubblesort(r);
    output(r);
    return 0;
}

希尔排序代码及实现

基本思想：将数据序列分为多个子文件，再对多个子文件分别进行插入排序，最终达到整体有序。

#include <stdio.h>
#include <stdlib.h>
#include<time.h>
#define max 2000
void input(int a[])
{
    int i;
    srand(time(NULL));//生成随机数
    for(i=0; i<max; i++)
        a[i]=rand()%999+1;
}

void output(int a[])
{
    int i;
    for(i=0; i<max; i++)
    {
        printf("%-4d",a[i]);//左对称
    }
      printf("\n");
}

void ShellSort(int a[])
{
    /* 希尔排序 - 用d增量序列 */
    int di,dj;
    int tmp;//暂存，类似岗哨
    int d[] = {929, 505, 209, 109, 41, 19, 5, 1};//目前最快的增量
    int i,j;
    for(di=0; d[di]>=max; di++ );
    //初始的增量d[di]不能超过待排序列长度
    for(dj=d[di]; dj>=1; dj=d[++di])
    {
        for(i=dj; i<max; i++)
        {
            tmp = a[i];
            for(j=i-dj; j>=0&&tmp<a[j]; j=j-dj)
            {
                a[j+dj] = a[j];
            }
            a[j+dj] = tmp;
        }
            output(a);
        if(dj == 1)
            return ;
    }
}

int main()
{
    int a[max];
    input(a);
    output(a);
    ShellSort(a);
  //  output(a);
}

项目	Value
最坏时间复杂度	O（nlogn）~ O(N²）
平均时间复杂度	O（nlogn）~ O(N²）
空间复杂度	O（1）
稳定性	不稳定
复杂性	较复杂

分析：适用于较大的数据序列