常见排序算法（C语言版）

简单排序算法：
一些常见的排序算法实现O(∩_∩)O~

• 插入排序：

  • 直接插入排序：最简单的排序方式，将一个数据插入到已经排好序的有序表中，得到一个新的，记录数增一的有序表。

  • 折半插入排序：由于插入排序是在一个有序表中进行查找和插入，则可知查找操作可以用折半查找来实现，也可极大地减少复杂度。

  • 希尔排序：又称为“缩小增量排序”。将整个待排序序列分割成若干个子序列分别进行插入排序，待整个序列中的的记录基本有序时，再对全体记录进行一次直接插入排序。

• 交换排序：

  • 冒泡排序：（假定排序规则为从小到大）首先第一个记录和第二个记录的关键字进行比较，若为逆序（L.r[1].key>L.r[2].key）这将两个记录交换，之后比较第二个和第三个记录，以此类推知道第n-1个和n比较完称之为一趟排序，此时第n个记录为最大的数。依次类推进行接下来的排序，直到全部排完。

  • 快速排序： 对冒泡排序的一种改进。基本思想是通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小（以枢轴为分界点），则可对这两部分记录继续进行排序，以达到整个序列有序。

• 选择排序：

  • 简单选择排序：在第i次排序时，通过n-i次关键字比较，在n-i+1个记录中选取关键字最小的记录作为有序序列中第i个记录。

直接插入排序

/*直接插入排序*/

#include<stdio.h>
#include<stdarg.h>

#define MAX_SIZE 20
#define OK 1
typedef int KeyType;
typedef char InfoTYpe;

typedef struct{
    KeyType key;
    InfoTYpe infoType;
}RedType;

typedef struct{
    RedType r[MAX_SIZE+1];
    int length;
}SqList;


int DecInsertSort(SqList *L){
    int i = 2;
    for(i;i<L->length;i++){
        //比较第i个元素和第i-1个元素的大小
        if(L->r[i].key<L->r[i-1].key){
            L->r[0] = L->r[i];
            L->r[i] = L->r[i-1];
            // 记录后移
            int j = 0;
            for(j = i-2;L->r[0].key<L->r[j].key;j--){
                L->r[j+1] = L->r[j];
            }
            L->r[j+1] = L->r[0];

        }


    }
    return OK;

}

showSqList(SqList list){
    int i = 1;
    for(i;i<list.length;i++){
        printf("数组第%d个元素是%d\n",i,list.r[i]);
    }
}

/*主函数*/
int main(){
    SqList list;
    list.r[8].key =1;
    list.r[7].key =2;
    list.r[6].key =3;
    list.r[5].key =10;
    list.r[4].key = 7;
    list.r[3].key = 4;
    list.r[2].key =5;
    list.r[1].key = 40;
    list.length = 9;
    DecInsertSort(&list);
    showSqList(list);
}

折半插入排序：

/*折半插入排序*/

int HalfInsertSort(SqList *list){
    int i = 2;
    int j;
    int low;
    int high;
    int medi;
    for(i;i<(*list).length;i++){
        (*list).r[0] = (*list).r[i];
        low = 1;
        high = i-1;
        while(low<=high){
            medi = (low+high)/2;
            if((*list).r[0].key<(*list).r[medi].key){
                high = medi-1;
            }else{
                low = medi+1;
            }
        }
        for(j = i-1;j>=high+1;j--){
            (*list).r[j+1] = (*list).r[j];
        }
        (*list).r[high+1] = (*list).r[0];
    }
}

希尔排序：

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

        }
    }

}

int ShellAllSort(SqList *L,int datas[],int t){
    int i = 0;
    for(i;i<t;i++){
        ShellSort(L,datas[i]);
    }
}

冒泡排序：

/*冒泡排序----从小到大*/
int PopSort(SqList *list){
    int i = 1;
    for(i;i<(*list).length;i++){
        int j = 1;
        for(j;j+1<=(*list).length-i;j++){
            if((*list).r[j].key>(*list).r[j+1].key){
                RedType temp;
                temp = (*list).r[j];
                (*list).r[j] = (*list).r[j+1];
                (*list).r[j+1] = temp;
            }
        }
        showSqList((*list));
        printf("***************\n");
    }

}

简单选择排序：

/*简单选择排序*/

/*获取关键字最小的记录*/
int SelectMinKey(SqList L,int k){

    int maxPos = k;
    RedType maxRed = L.r[k];

    for(k;k<L.length;k++){
        if(L.r[k].key<maxRed.key){
            maxRed = L.r[k];
            maxPos = k;
        }

        printf("temp的值为%d\tpos的值为%d\n",maxRed.key,maxPos);
    }
    return maxPos;
}

/*选择排序*/
int SelectSort(SqList *L){
    int i = 1;
    for(i;i<(*L).length;i++){
        int j;
        j = SelectMinKey((*L),i);
        if(i!=j){
            RedType temp = (*L).r[i];
            (*L).r[i] = (*L).r[j];
            (*L).r[j] = temp;
        }
        showSqList((*L));
        printf("\n");
    }
}