9 排序

1. 排序

   1. 内部排序 （不需要访问外存）
   2. 外部排序 （排序数量大 不可能在内存完成）

2. 插入排序

   1. 直接插入排序
   2. 折半插入 （二分）
   3. 表插入 （链表存储）
   4. 希尔排序 shell （基于逐趟缩小增量）

3. 快速排序

   1. 冒泡排序

   2. 一趟快速排序

   3. 快速排序

      void quick_sort(int a[],int l,int r)
      {
          if(l>=r) return;
          int x = a[(l+r)/2]; // int x = a[l+r >> 1];
          int i = l-1;
          int j = r+1;
          while(i<j)
          {
              do i++;
              while(a[i]<x);
              
              do j--;
              while(a[j]>x);
              
              if(i<j) swap(a[i],a[j]);
          }
          quick_sort(a,l,j);
          quick_sort(a,j+1,r);
      }
      

4. 堆排序

   1. 堆排序

   #include 
   #include 
   
   priority_queue<int,vector<int>,greater<int>> heap;//小根堆
   priority_queue<int,vector<int<,less<int>> heap1;//大根堆
   
   heap.push(x);//入堆
   heap.top();//堆顶
   heap.pop();//删除堆顶
   

   2. 简单选择排序

5. 归并排序

   void merge_sort(int a[],int l,int r)
   {
       if(l>=r) return;
       
       int mid = (l+r) / 2; // int mid = (l+r) >> 1;
       merge_sort(a,l,mid);
       merge_sort(a,mid+1,r);
       
       int k = 0;
       int i = l;
       int j = mid+1;
       
       while(i<=mid && j<=r)
       {
           if(a[i]<a[j]) temp[k++] = a[i++];
           else temp[k++] = a[j++];
       }
       
       while(i<=mid) temp[k++] = a[i++];
       
       while(j<=r) temp[k++] = a[j++];
       
       for(i=l,j=0;i<=r;i++,j++)
       {
           a[i] = temp[j];
       }
   }
   

6. 基数排序

   1. 多关键字的排序
      1. 最高位优先MSD法
      2. 最低位优先LSD法
   2. 链式基数排序

7. 利用结构体实现多关键字的排序

   struct R
   {
       string name;//姓名
       int age,id;//年龄 工号
       bool operator<(const R&t) const
       {
           if(age != t.age) return age < t.age;//先按照年龄从小到大排序
           else
           {
               if(name != t.name) return name < t.name;//年龄相同则按照姓名字典序排序
               else return id < t.id;//年龄姓名相同则按照工号从小到大排序
           }
       }
   }r[N];
   

8. 各种排序比较

   1. 时间复杂度：

      O（nlogn）	O(n^2)	O(n)
      快速排序	直接插入排序	基数排序
      堆排序	冒泡排序	若有序：直接插入排序
      归并排序	简单选择排序	若有序：冒泡排序
      	若有序：快速排序

   2. 空间复杂度

      O（1）	O（logn）	O(n)	O（rd）
      所有的简单排序方法：（3个）	快速排序	归并排序	链式基数排序
      直接插入
      冒泡
      简单选择
      堆排序

   3. 稳定性

      -稳定概念：对于两个关键字相等的记录，它们在序列中的相对位置，在排序之前和经过排序之后，没有改变

      -不稳定的有：快速排序 堆排序 shell希尔排序

9. 外部排序：多路归并