数据结构--排序

----------------

排序

----------------

冒泡排序思想：

“比较相邻的元素。如果第一个比第二个大,就交换他们两个。 对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。 针对所有的元素重复以上的步骤,除了最后一个。 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。”

 

选择排序思想：

“从头至尾扫描序列,找出最小的一个元素,和第一个元素交换,接着从剩下的元素中继续这种选择和交换方式,最终得到一个有序序列。

 

直接插入排序思想：

“直接插入排序的基本操作是将一个记录插到已排队好的有序表中，从而得到一个新的，记录增1的有序表。（第一个有序表可认为是第一个元素）“

 

希尔排序思想：

  先取一个小于n的整数d₁作为第一个增量，把文件的全部记录分成d₁个组。所有距离为d_l的倍数的记录放在同一个组中。先在各组内进行直接插人排序；然后，取第二个增量d₂<d₁重复上述的分组和排序，直至所取的增量d_t=1(d_t<d_t-l<…<d₂<d₁)，即所有记录放在同一组中进行直接插入排序为止。
    　该方法实质上是一种分组插入方法。

 

堆排序思想：

待实现

 

归并排序思想：

待实现

 

快速排序思想;

 

测试主函数

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


int main()
{
    ArrayList numlist;
    PtArrayList pt_arraylist;
    pt_arraylist = &numlist;
    while(True){
        Init_Data(pt_arraylist);
        show((char *)"排序前 ", pt_arraylist);
        
//        BubbleSort_Low(pt_arraylist);
//        BubbleSort_Mid(pt_arraylist);
//        BubbleSort_Mid_Opt(pt_arraylist);
//        SelectSort_Asc(pt_arraylist);    
//        SelectSort_Desc(pt_arraylist);    
//        InsertSort(pt_arraylist);
//        ShellSort(pt_arraylist);
//        QuickSort(pt_arraylist, 0, pt_arraylist->len-1);
        QuickSort_Opt(pt_arraylist, 0, pt_arraylist->len-1);
        show((char *)"排序后 ", pt_arraylist);
    } 

    
    return 0;
}

测试头文件

//sort.h
#define True 1 
#define False 0
#define NUMSIZE 20
typedef struct {
    int array[NUMSIZE];
    int len;
}ArrayList, *PtArrayList; 

void swap(int * first, int * second);
void show(char * info, PtArrayList * pt_arraylist); 
void Init_Data(PtArrayList pt_arraylist); 
void BubbleSort_Low(PtArrayList * pt_arraylist);
void BubbleSort_Mid(PtArrayList * pt_arraylist);
void BubbleSort_Mid_Opt(PtArrayList pt_arraylist);
void SelectSort_Asc(PtArrayList pt_arraylist);
void SelectSort_Desc(PtArrayList pt_arraylist);
void InsertSort(PtArrayList pt_arraylist);
void ShellSort(PtArrayList pt_arraylist);
int FindPos(PtArrayList pt_arraylist, int low, int high);
void QuickSort(PtArrayList pt_arraylist, int low, int high);

#include "sort_function.cpp"

 函数具体实现

//sort_function.cpp
void Init_Data(PtArrayList pt_arraylist)
{
    char s[] = "请输入不大于20的序列长度";
    printf("%s___",s);
    while(!scanf("%d", &pt_arraylist->len) || (pt_arraylist->len > NUMSIZE))
    {
        printf("%s
",s);
        if(pt_arraylist->len > NUMSIZE)
        {
            printf("当前序列长度为%d 过长
", pt_arraylist->len);
            continue;
        }
        scanf("%*s");
    }
    
    srand(time(0)); //随机初始化rand()函数
    for(int i=0; i<pt_arraylist->len; i++)
    {
        pt_arraylist->array[i] = rand()%200-100;
    }
    
}

void QuickSort_Opt(PtArrayList pt_arraylist, int low, int high)
{
    //快速排序--尾递归优化 
    int pos;
    while(low<high)
    {
        pos = FindPos(pt_arraylist, low, high);
        QuickSort(pt_arraylist, low, pos-1);
        low = pos+1;    
    }
    
} 

void QuickSort(PtArrayList pt_arraylist, int low, int high)
{
    //快速排序 
    int pos;
    if(low<high)
    {
        pos = FindPos(pt_arraylist, low, high);
        QuickSort(pt_arraylist, low, pos-1);    
        QuickSort(pt_arraylist, pos+1, high);
    }
    
} 

int FindPos(PtArrayList pt_arraylist, int low, int high)
{
    if (low > NUMSIZE || low<0)
    {
        printf("退出,越界访问
");
        return -1;
    }
    
    int posval = pt_arraylist->array[low];
    //降序 
    while(low < high)
    {
        //确定pos的同时，对序列进行有序化 
        //=不能少,否则可能low和high永远不能相遇，死循环 
        while(low < high && posval>=pt_arraylist->array[high])
            high--;
        swap(&pt_arraylist->array[low], &pt_arraylist->array[high]);
        
        while(low < high && posval<=pt_arraylist->array[low])
            low++;
        swap(&pt_arraylist->array[low], &pt_arraylist->array[high]);
    }
    
    return low;
}

void ShellSort(PtArrayList pt_arraylist)
{
    //希尔排序 分组后进行插入排序，分组 
    int i,pos,tmp;
    int step = pt_arraylist->len;

    do{
        step /= 2; //step为1时 和插入排序一模一样 
        for(i=step; i<pt_arraylist->len; i++)
        {
            tmp = pt_arraylist->array[i];
            //与当前数据做比较，注意tmp 
            for(pos=i-step; pos>=0 && tmp<pt_arraylist->array[pos];pos-=step)
            {
                pt_arraylist->array[pos+step] = pt_arraylist->array[pos];
            }
            pt_arraylist->array[pos+step] = tmp;
        }
        
    }while(step>=1) ;

}

void InsertSort(PtArrayList pt_arraylist)
{
    //直接插入排序 
    int i, pos, tmp;
    for (i=1; i<pt_arraylist->len; i++)
    {
        tmp = pt_arraylist->array[i];//当前值得临时变量 腾出i位置空间 
        //前一个元素比当前大，右移（升序），必须为pos-- 
        for(pos = i-1; pos>=0 && pt_arraylist->array[pos]>tmp; pos--)
        {
            pt_arraylist->array[pos+1] = pt_arraylist->array[pos]; //右移
        }
        //通过pos标记位置,插入到空出来的位置 （不移动则直接插入到i位置） 
        pt_arraylist->array[pos+1] = tmp;

    }
    
}

void SelectSort_Asc(PtArrayList pt_arraylist)
{
    //选择排序，当前数字和其他当中最小的进行交换 (升序)
    int min;
    //最后一个数不用再做比较，所以len-1。其实不加在后续条件也不影响 
    for (int i=0; i<pt_arraylist->len-1; i++)
    {
        min = i;
        for (int j=i+1; j<pt_arraylist->len; j++)
        {
            //此处min不能为i，筛选出最小的值 
            if(pt_arraylist->array[min] > pt_arraylist->array[j]) 
            {
                min = j;
            }
        } 
    if(i!=min)
        swap(&pt_arraylist->array[i], &pt_arraylist->array[min]);
    } 
} 

void SelectSort_Desc(PtArrayList pt_arraylist)
{
    //选择排序，当前数字和其他当中最大的进行交换 (降序)
    int max;
    for (int i=0; i<pt_arraylist->len-1; i++)
    {
        max = i;
        for (int j=i+1; j<pt_arraylist->len; j++)
        {
            if(pt_arraylist->array[max] < pt_arraylist->array[j]) 
            {
                max = j;
            }
        } 
    if(i!=max)
        swap(&pt_arraylist->array[i], &pt_arraylist->array[max]);
    } 
} 

void BubbleSort_Mid_Opt(PtArrayList pt_arraylist)
{
    int flag = True;    
    //改进版
    for (int i=0; i<pt_arraylist->len && flag; i++)
    {
        //只有当第二层循环不出现一次True时，
        //才会有标志位False 
        flag = False; 
        for (int j=0; j<pt_arraylist->len-i-1; j++)
        {
            if(pt_arraylist->array[j] > pt_arraylist->array[j+1]) 
            {
                swap(&pt_arraylist->array[j], &pt_arraylist->array[j+1]);
                flag = True;
            }
        } 
    } 
}

void BubbleSort_Mid(PtArrayList pt_arraylist)
{
    //对当前数字和其下一个相邻数字比较，大于则交换
    //冒泡到最后一个数肯定是最大的，所以不需要比较，即len-1-i
    //i进行一次表明有i个数字已经排好 
    for (int i=0; i<pt_arraylist->len; i++)
    {
        for (int j=0; j<pt_arraylist->len-i-1; j++)
        {
            if(pt_arraylist->array[j] > pt_arraylist->array[j+1]) 
                swap(&pt_arraylist->array[j], &pt_arraylist->array[j+1]);
//            printf("num[%d] = %d num[%d] = %d
", j, pt_arraylist->array[j], j+1, pt_arraylist->array[j+1]);
        } 
    } 
}

void BubbleSort_Low(PtArrayList pt_arraylist)
{
    //依次将数字位与后续其他位比较，升序，大则交换 
    for (int i=0; i<pt_arraylist->len; i++)
    {
        for (int j=i+1; j<pt_arraylist->len; j++)
        {
            if(pt_arraylist->array[i] > pt_arraylist->array[j]) 
                swap(&pt_arraylist->array[i], &pt_arraylist->array[j]);
        } 
    } 
}

void show(char info[], PtArrayList pt_arraylist)
{
    printf("%s", info);
    for (int i=0; i<pt_arraylist->len; i++)
    {
        printf("%3d ", pt_arraylist->array[i]);
    } 
    putchar('
');    
}

void swap(int * first, int * second)
{
    int tmp;
    tmp = *first;
    *first = *second;
    *second = tmp;
    
}