有关排序的代码

把学过的排序总结一下

堆排序：

#include<iostream>
using namespace std;
void insert(int arr[], int n) {   //在大根堆里面插入一个数
 while (n&&arr[(n - 1) / 2] < arr[n]) {
  swap(arr[(n - 1) / 2], arr[n]);
  n = (n - 1) / 2;
 }
}
void build(int arr[], int n) {   //建立一个大根堆
 for (int i = 1; i < n; i++) {
  insert(arr, i);
 }
}
void adjust(int arr[], int size) {   //对二叉树调整，使其保持大根堆的结构
 int n = 0;
 while (2 * n + 1 < size) {      //如果左孩子没有越界，进行调整
  int largest = 2 * n + 2 < size&&arr[2 * n + 2] > arr[2 * n + 1] ?
   2 * n + 2 :   //如果右孩子没有越界，并且右孩子大于左孩子，那么最大下标就等于右孩子的下标
   2 * n + 1;    //如果右孩子越界，或者左孩子大于等于右孩子，最大下标就等于左孩子的下标
  if (arr[largest] < arr[n]) {  //如果两个孩子都小于父亲，退出循环
   break;
  }
  swap(arr[largest], arr[n]);   //两个孩子有一个大于父亲的，就交换它和父亲的值
  n = largest;
 }
}
void sort(int arr[], int n) {       //堆排序
 build(arr, n);                  //将数组里面的元素建立为一个大根堆
 while (n) {
  swap(arr[0], arr[n - 1]);   //交换大根堆的根节点和最后一个元素
  adjust(arr, --n);           //调整大根堆，大根堆的节点数减1
 }
}
int main() {
 int n, a[100];
 cin >> n;
 for (int i = 0; i < n; i++) {     //输入
  cin >> a[i];
 }
 sort(a, n);                       //排序
 for (int i = 0; i < n; i++) {
  cout << a[i] << " ";          //输出
 }
 cout << endl;
 return 0;
}

并归排序：

#include<iostream>
using namespace std;
void merge(int arr[], int l, int m, int r) { //将数组的两个有序序列合并成一个有序序列
 int *p = new int[r - l + 1];  //申请一个辅助数组
 int p1 = l, p2 = m + 1,i=0;   //p1，p2分别代表左右两端序列的当前下标，i代表辅助数组的当前下标
 while (p1 <= m && p2 <= r) {  //p1,p2都没有越界时
  p[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++]; 
 } //把两端序列的当前值比较，较小的值放入辅助数组的当前位置，对应的下标加1
 while (p1 <= m) { //p1没有越界（说明p2越界了），把左边序列的值依次放入辅助数组
  p[i++] = arr[p1++];
 }
 while (p2 <= r) { //p2没有越界（说明p1越界了），把右边序列的值依次放入辅助数组
  p[i++] = arr[p2++];
 }
 for (int i = 0; i < r - l + 1; i++) { //把辅助数组的值复制回原来的数组中
  arr[l+i] = p[i];
 }
 delete[] p;  //释放内存
 p = NULL;
}
void sort(int arr[], int l, int r) { //对数组arr的l，r中间的序列排序
 if (l == r) { //如果这段序列只有一个值，返回
  return;
 }
 int mid = l + (r - l) / 2; //求出这段序列的中间下标
 sort(arr, l, mid);   //对这段序列的左边进行排序
 sort(arr, mid + 1, r);  //对这段序列的右边进行排序
 merge(arr, l, mid, r);  //对已经排好序的两端序列进行合并，得到有序序列
}
int main() {
 int n, a[99];
 cin >> n;
 for (int i = 0; i < n; i++) {
  cin >> a[i];
 }
 sort(a, 0, n - 1);
 for (int i = 0; i < n; i++) {
  cout << a[i] << " ";
 }
 cout << endl;
 return 0;
}

快速排序：

#include<iostream>
using namespace std;
int* partition(int arr[], int a, int b) {
 int less = a - 1;
 int more = b;
 while (a < more) {
  if (arr[a] < arr[b]) {
   swap(arr[a++], arr[++less]);
  }
  else if (arr[a] > arr[b]) {
   swap(arr[a], arr[--more]);
  }
  else {
   a++;
  }
 }
 swap(arr[more], arr[b]);
 return new int[2]{ less ,more++ };
}
void sort(int arr[], int a, int b) {        //快速排序
 if (a >= b) {
  return;
 }
 int *p;
 p = partition(arr, a, b);
 sort(arr, a, p[0] );
 sort(arr, p[1] , b);
}
int main() {
 int arr[99];
 int n;
 cin >> n;
 for (int i = 0; i < n; i++) {
  cin >> arr[i];
 }
 sort(arr, 0, n - 1);
 for (int i = 0; i < n; i++) {
  cout << arr[i] << " ";
 }
 cout << endl;
 return 0;
}

插入排序：

#include<iostream>
#include<vector>
using namespace std;
void sort(vector<int> &arr) {     //插入排序
 for (int i = 1; i < arr.size(); i++) {
  for (int j = i - 1; j >= 0 && arr[j]>arr[j + 1]; j--) {
   swap(arr[j], arr[j + 1]);
  }
 }
}
int main() {
 int a;
 cin >> a;
 vector<int> arr(a);
 for (int i = 0; i < a; i++) {
  cin >> arr[i];
 }
 sort(arr);
 for (int i = 0; i < a; i++) {
  cout << arr[i] << " ";
 }
 cout << endl;
 return 0;
}