数据结构排序算法笔记（1）

目录：

1.直接插入排序

2.冒泡排序

3.快速排序

 4.简单选择排序

---

1.直接插入排序

直接插入排序---采用顺序查找法查找插入位置

 方法1：（1）复制插入元素  x=a[i];

                 (2)记录后移，查找插入位置  for(j=i-1;j>=0&&x<a[j];j--)

                 (3)插入到正确的位置  a[j+1]=x;

方法2：直接插入排序，使用“哨兵”

            （1）复制哨兵   L.r[0]=L.r[i];

               

               (2)记录后移，查找插入位置    for(j=i-1;L.r[0].key<L.r[j].key;--j)

                                                                          L.r[j+1]=L.r[j];

                (3)插入到正确位置    L.r[j+1]=L.r[0];

直接插入排序算法：

void InsertSort(SqList &L){
    int i,j;
    for(i=2;i<=L.length;++i){
      if(L.r[i].key<L.r[i-1].key){//若"<"，需将L.r[i]插入有序子表
         L.r[0]=L.r[i];//复制为哨兵
         for(j=i-1;L.r[0].key<L.r[j].key;--j){
             L.r[j+1]=L.r[j];//记录后移
            }
           L.r[j+1]=L.r[0];//插入到正确位置
          }
}

时间复杂度结论

原始数据越接近有序，排序速度越快。

最坏情况下（输入数据是逆有序的）Tw(n)=O(n^2)

平均情况下，耗时差不多是最坏情况的一半 Te(n)=O(n^2)

2.冒泡排序

基本思想：每趟不断将记录两两比较，并按"前小后大"规则交换。

优点：每趟结束时，不仅能挤出一个最大值到最后面位置，还能同时部分理顺其他元素。

例如：6个记录   21，25，49，25*，16，08

第一趟结束：21，25，25*，16，08，49

第二趟结束：21，25，16，08，25*，49

第三趟结束：21，16，08，25，25*，49

第四趟结束：16，08，21，25，25*，49

第五趟结束：08，16，21，25，25*，49

n个记录，总共需要n-1趟

第m趟需要比较n-m次

冒泡排序算法：

void bubble_sort(SqList &L){//改进的冒泡排序算法（没改进之前是没有flag）
   int m,i,j,flag=1;RedType x;//flag作为是否有交换的标记
   for(m=1;m<n-1&&flag==1;m++){
    flag=0;
     for(j=1;j<=n-m;j++){
         if(L.r[j].key>L.r[j+1].key){//发生逆序
             flag=1;//发生交换，flag置为1，若本趟没发生交换，flag保持为0
             x=L.r[j];L.r[j]=L.r[j+1];L.r[j+1]=x;//交换
      }//endif
     }
 }//for
}

3.快速排序

基本思想：第一个元素为主元（pivot:枢轴、中心点）。

所有比它小的元素一律前放，比它大的元素一律后放，形成左右两个子表。

对各子表重新选择中心元素并依此规则调整，直到每个子表的元素只剩一个。（递归思想）

具体实现：选定一个直接数作为参考，所有元素与之比较，小的调到其左边，大的调到其右边。

（枢轴）中间数：可以是第一个数、最后一个数、最中间一个数。

最后排序后的8个数字依次为：13，27，38，49，49’，65，76，97

 快速排序算法：

void main(){
  QSort(L,1,L.length);}
void QSort(SqList &L,int low,int high){//对顺序表L快速排序
     if(low<high){//长度大于1
       pivotloc=Partition(L,low,high);
       //将L.r[low...high]一分为二，pivotloc为枢轴元素排好序的位置
      QSort(L.low,pivotloc-1);//对低子表递归排序
      QSort(L,pivotloc+1,high);//对高子表递归排序
      }//endif
}//QSort
int Partition (SqList &L,int low,int high){
  L.r[0]=L.r[low];pivotkey=L.r[low].key;
  while(low<high){
      while(low<high&&L.r[high].key>=pivotkey) --high;
      L.r[low]=L.r[high];
      while(low<high&&L.r[low].key<=pivotkey) ++low;
      L.r[high]=L.r[low];
    }
   L.r[low]=L.r[0];
   return low;
}

 注意：快速排序不适于对原本有序或基本有序的记录序列进行排序。

 4.简单选择排序

基本思想：在待排序的数据中选出最大（小）的元素放在其最终的位置。

基本操作：1.首先通过n-1次关键字比较，从n个记录中找出关键字最小的记录，将它与第一个记录交换。

2.再通过n-2次比较，从剩余的n-1个记录中找到关键字最小的记录，将它与第二个记录交换。

3.重复上述操作，共进行n-1趟排序后，排序结束。

 

简单选择排序算法：

void SelectSort(SqList &L){
     for(i=1;i<L.length;++i){
       k=i;
       for(j=i+1;j<=L.length;j++){
           if(L.r[j].key<L.r[k].key) k=j;
           }//记录最小值位置
      if(k!=i) L.r[i]<-->L.r[k];//两个数进行交换
      }
}