各类基础排序代码（简单插入，希尔，快速，堆，归并）

 

目录

简单插入排序：

希尔排序（SHELL）改进的简单插入排序：

快速排序：

堆排序：

 归并排序：

---

简单插入排序：

无需递归等调用嵌套两层循环，从数组的第二项开始往前插入。

代码：

• //直接插入排序
  void InsertSort(int A[], int n){
      int i,j;
      //A[0]是用作存储单元
      for(i = 2; i<=n; i++){
          if(A[i] < A[i-1]){
              A[0] = A[i];
              for(j=i-1;A[0]<A[j];--j){
                  A[j+1]=A[j];
              }
              A[j+1] = A[0];
          }
      }
  }

---

希尔排序（SHELL）改进的简单插入排序：

dk表示将原数组分成若干数组序列的偏移量，注意，对于分成的不同数组序列，调用简单插入排序，并不是一个序列完成后进行另一个序列，而是在原数组序列中不断加1，进行不同数组序列的切换。

代码：

• //希尔（SHELL）排序
  void ShellSort(int A[], int n){
      int dk;
      int j;
      for (dk=n/2; dk>=1; dk=dk/2){
          //对于不同的数组交叉排序
          for(int i = 1+dk; i<=n; i++){
              if(A[i]<A[i-dk]){
                  A[0] = A[i];
                  for(j=i-dk; j>0 && A[j]<=A[0]; j=j-dk){
                      A[j+dk] = A[j];
                  }
                  A[j+dk] = A[0];
              }
          }
      }
  }

---

快速排序：

快速排序正如其名，事件复杂度低，但是不稳定，需要递归，存在两个函数主体。

代码：

• //快排
  //进行一次排序，返回一次排序后固定的位置
  int Partition(int A[], int low, int high){
      int pivot = A[low];//设置中枢
      while(low < high){
          while(low < high && A[high] >= pivot){
              high--;
          }
          while(low < high && A[low] <= pivot){
              low++;
          }
      }
      A[low] = pivot;
      return low;
  }
  //快排递归主体
  void QuickSort(int A[]; int low; int high){
      if(low < high){
          int pivot = Partition(A,low,high);
          QuickSort(A,low,pivot-1);
          QuickSort(A,pivot+1,high);
      }
  }

---

堆排序：

堆排序无需递归，事件复杂度也比较低，也是不稳定的算法。通过三个函数主体构成。一个用来调整以规定头节点为根节点的堆。一个用来整体调整堆。一个用来进行堆排序。

代码：

• //堆排
  //调整堆(对于选中节点k为根节点)
  //大根堆
  void HeadAdjust(int A[], int k, int len){
      A[0] = A [k];
      for(int i=2*k; i<=len; i*=2){
          if(i<len && A[i]<A[i+1]){
              i++;
          }
          if(A[i]<=A[0]){
              break;
          }
          else{
              A[i]=A[0];
              k=i;
          }
      }
  }
  //对整体堆进行调整
  void BuildMaxHeap(int A[], int len){
      for(int i = len/2; i>0; i--){
          HeadAdjust(A,i,len);
      }
  }
  //元素下坠调整堆
  void HeapSort(int A[]; int len){
      BuildMaxHeap(A, len);
      for(int i=len; i>1; i--)
      {
          swap(A[i],A[1]);
          HeadAdjust(A,1,i-1);
      }
  }

---

 归并排序：

归并排序我认为是比较难理解的了，它有两个函数主体，并且一个函数为递归调用，需要一个辅助数组。将原数组分成若干归并段，两两归并。

代码：

• //归并排序
  //需要一个额外的辅助数组，与待排数组大小相同
  //是原数组中的元素个数，创建了一个新的数组存放A中相同的元素
  int *B= (int*)malloc((n+1)*sizeof(int));
  void Merge(int A[], int low, int high, int mid){
      int i, j, k;
      //将A中元素复制到B辅助数组中
      for(int k=low;k<=high;k++){
          B[k]=A[k];
      }
      for(i = low, j=mid+1, k=i; i< mid && j<=high; k++){
          if(B[i]<=B[j]){
              A[k] = B[i];
              i++;
          }
          else{
              A[k]=B[j];
              j++;
          }
      }
      while (i<=mid)
      {
          A[k++]=B[i++];
      }
      while (j<=high)
      {
          A[k++]=B[j++];
      } 
  }
  //归并排序主体函数
  //递归调用
  void MergeSort(int A[], int low, int high){
      if(low<high){
          int mid = (low+high)/2;
          //递归调用让归并段减小
          MergeSort(A,low,mid);
          MergeSort(A,mid+1,high);
          Merge(A,low,high,mid);
      }
  }