「这是我参与2022首次更文挑战的第24天，活动详情查看：2022首次更文挑战」。

排序算法

冒泡排序

冒泡排序的基本思想：两两比较相邻记录，如果反序则交换，直到没有反序的记录为止。
冒泡排序的步骤:

1. 从无序区R[1…n]的底部向上依次比较相邻的两个记录R[j+1]与R[j]，若R[j+1].key<R[j].key，则交换R[j+1]和R[j]的内容。经过一趟排序后，关键字最小的记录被放在了R[1]中，无序区缩小为R[2…n].
2. 重复进行1步骤，直到全部记录都在有序区。 一趟冒泡排序可以确定一个记录的最终位置，共经过n-1趟排序

冒泡排序运行实例

冒泡排序算法描述

void BubbleSort(SeqList R){ 
       int i, j;
       //共比较n-1趟
       for(i = 1; i < n; i++){ 
            //第i趟比较
            for(j = n-1; j >= i; j--)             
                  if (R[j+1].key < R[j].key){
	             R[0]=R[j+1];
	             R[j+1]=R[j];
	             R[j]=R[0];
                 } 
      }
}

快速排序

快速排序的基本思想：选一个轴值，将待排序记录划分成两部分，左侧记录均小于或等于轴值，右侧记录均大于或等于轴值，然后分别对这两部分重复上述过程，直到整个序列有序。

排序算法运行实例

快速排序算法描述

int Partition(SeqList r, int first, int last){	
    int i = first, j = last, temp;     
    while (i < j){
     //右侧扫描
    while (i < j && r[i] <= r[j]) j--；                            
        if (i < j) { 
            temp = r[i]; r[i] = r[j]; r[j] = temp; i++; 
        }
     //左侧扫描
     while (i < j && r[i] <= r[j]) i++；                           
        if (i < j) {
            temp = r[i]; r[i] = r[j]; r[j] = temp;  j--; 
        }
   }
   //i为轴值记录的最终位置
    retutn i;                                                                    
}

希尔排序

希尔排序的基本思想：将待排序序列分割成若干个子序列，在子序列内分别进行直接插入排序，待序列基本有序时，对全体记录进行直接插入排序。

希尔排序运行实例

希尔排序算法描述

//希尔排序中的一趟排序，d为当前增量
void ShellPass(SeqList R, int d){  
        //将R[d+1... n]分别插入各组当前的有序区
       for(i = d+1; i < = n; i++)         
       if(R[i].key < R[i-d].key){
             //R[0]只是暂存单元，不是哨兵
             R[0] = R[i]; 
             j = i - d; 
             do{     
                    R[j+d] = R[j];
                    j=j-d；                       
             }while(j > 0 && R[0].key < R[j].key);
             //插入R[i]到正确的位置上
             R[j+d] = R[0];                   
      }
}