基础排序算法

冒泡排序

冒泡排序（Bubble Sort）一种交换排序，它的基本思想是：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。

以下代码是改进的冒泡算法，在排序好了之后可以直接跳出循环，避免有没必要的循环出现呢。

/* 对顺序表 L 改进冒泡算法 */
void BubbleSort2(SqList *L)
{
    int i, j;
    Status flag = TRUE;    /* flag 用来作为标记 */
    for (i = 1; i < L->length && flag; i++)  /* 若 flag 为 true 则退出循环 */
    {
        flag = FALSE;           /* 初始为 false */
        for (j = L->length - 1; j >= i; j--)
        {
            if (L->r[j] > L->r[j + 1])
            {
                swap(L, j, j + 1); /* 交换 L->r[j]与 L->r[j + 1]的值 */
                flag = TRUE;    /* 如果有数据交换，则 flag 为 true */
            }
        }
    }
}

简单排序

简单选择排序法（Simple Selection Sort）就是通过 n - i 次关键字间的比较，从 n - i + 1 个记录中选出关键字最小的记录，并和第 i（1≤i≤n）个记录交换之。

/* 对顺序表 L 作简单选择排序 */
void SelectSort(SqList *L)
{
    int i, j, min;
    for (i = 1; i < L->length; i++)
    {
        min = i;                       /* 将当前下标定义为最小值下标 */
        for (j = i + 1; j <= L->length; j++) /* 循环之后的数据 */
        {
            if (L->r[min] > L->r[j])    /* 如果有小于当前最小值的关键字 */
                min = j;                 /* 将此关键字的下标赋值给 min */
        }
        if (i!= min)                    /* 若 min 不等于 i，说明找到最小值，交换 */
            swap(L, i, min);            /* 交换 L->r[i]与 L->r[min]的值 */
    }
}

直接排序

直接插入排序（Straight Insertion Sort）的基本操作是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增1的有序表。

/* 对顺序表 L 作直接插入排序 */
void InsertSort(SqList *L)
{
    int i, j;
    for (i = 2; i <= L->length; i++)
    {
        if (L->r[i] < L->r[i - 1])  /* 需将 L->r[i]插入有序子表 */
        {
            L->r[0] = L->r[i];      /* 设置哨兵 */
            for (j = i - 1; L->r[j] > L->r[0]; j--)
                L->r[j + 1] = L->r[j];  /* 记录后移 */
            L->r[j + 1] = L->r[0];      /* 插入到正确位置 */
        }
    }
}

希尔排序

希尔排序是对直接排序算法的优化，在面对基本有序的数据和较少的数据时，直接排序算法是比较高效的，希尔排序就是将一组数据先进行一些操作使其达到基本有序状态，最后再进行一次直接排序。

/* 对顺序表 L 作希尔排序 */
void ShellSort(SqList *L)
{
    int i, j;
    int increment = L->length;
    do
    {
        increment = increment / 3 + 1;  /* 增量序列 */
        for (i = increment + 1; i <= L->length; i++)
        {
            if (L->r[i] < L->r[i - increment])
            {
                /* 需将 L->r[i]插入有序增量子表 */
                L->r[0] = L->r[i];    /* 暂存在 L->r[0] */
                for (j = i - increment; j > 0 && L->r[0] < L->r[j]; j -= increment)
                    L->r[j + increment] = L->r[j]; /* 记录后移，查找插入位置 */
                L->r[j + increment] = L->r[0]; /* 插入 */
            }
        }
    } while (increment > 1);
}

堆排序

堆是具有下列性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。

堆排序（Heap Sort）就是利用堆（假设利用大顶堆）进行排序的方法。它的基本思想是，将待排序的序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根结点。将它移走（其实就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值），然后将剩余的 n - 1 个序列重新构造成一个堆，这样就会得到 n 个元素中的次小值。如此反复执行，便能得到一个有序序列了。

/* 对顺序表 L 进行堆排序 */
void HeapSort(SqList *L)
{
    int i;
    for (i = L->length / 2; i > 0; i--)  /* 把 L 中的 r 构建成一个大顶堆 */
        HeapAdjust(L, i, L->length);
    for (i = L->length; i > 1; i--)
    {
        swap(L, 1, i); /* 将堆顶记录和当前未经排序子序列的最后一个记录交换 */
        HeapAdjust(L, 1, i - 1); /* 将 L->r[1..i - 1]重新调整为大顶堆 */
    }
}

归并排序

归并排序（Merging Sort）就是利用归并的思想实现的排序方法。它的原理是假设初始序列含有 n 个记录，则可以看成是 n 个有序的子序列，每个子序列的长度为 1，然后两两归并，得到很多个个长度为 2 或 1 的有序子序列；再两两归并，……，如此重复，直至得到一个长度为 n 的有序序列为止，这种排序方法称为 2 -路归并排序。

/* 将 SR[s..t]归并排序为 TR1[s..t] */
void MSort(int SR[], int TR1[], int s, int t)
{
    int m;
    int TR2[MAXSIZE + 1];
    if (s == t)
        TR1[s] = SR[s];
    else
    {
        m = (s + t) / 2; /* 将 SR[s..t]平分为 SR[s..m]和 SR[m + 1..t] */
        MSort(SR, TR2, s, m); /* 递归将 SR[s..m]归并为有序的 TR2[s..m] */
        MSort(SR, TR2, m + 1, t); /* 递归将 SR[m + 1..t]归并为有序 TR2[m + 1..t] */
        Merge(TR2, TR1, s, m, t); /* 归并到 TR1[s..t] */
    }
}

利用迭代实现非递归的归并排序

/* 对顺序表 L 作归并非递归排序 */
void MergeSort(SqList *L)
{
    int *TR = (int *)malloc(L->length * sizeof(int)); /* 申请额外空间 */
    int k = 1;
    while (k < L->length)
    {
        MergePass(L->r, TR, k, L->length);
        k = 2 * k;                   /* 子序列长度加倍 */
        MergePass(TR, L->r, k, L->length);
        k = 2 * k;                   /* 子序列长度加倍 */
    }
}

快速排序

快速排序（Quick Sort）的基本思想是：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分继续进行排序，以达到整个序列有序的目的。

/* 对顺序表 L 中的子序列 L->r[low..high]作快速排序 */
void QSort(SqList *L, int low, int high)
{
    int pivot;
    if (low < high)
    {
        pivot = Partition(L, low, high); /* 将 L->r[low..high]一分为二， */
                                          /* 算出枢轴值 pivot */
        QSort(L, low, pivot - 1);        /* 对低子表递归排序 */
        QSort(L, pivot + 1, high);       /* 对高子表递归排序 */
    }
}

算法进阶指南例题（解题主要思路不在如何实现排序）

比较简单的一个排序题，但是因为数据点相差很大，所以要用一下离散化，就是把无限空间中有限的个体映射到有限的空间中去，以此提高算法的时空效率。 通俗的说，离散化是在不改变数据相对大小的条件下，对数据进行相应的缩小。

#include<bits/stdc++.h>
using namespace std;
const int N=200005;
unordered_map<int,int> m1;//统计用映射
int n,m,a[N],b[N],c[N],ans=-1;//ans 记录答案下标
int main(){
	cin>>n;
	for(int i=0;i<n;i++) cin>>a[i],m1[a[i]]++;//统计珂学家 
	cin>>m;
	for(int i=0;i<m;i++) cin>>b[i];
	for(int i=0;i<m;i++) cin>>c[i];
	ans=0;
	for(int i=0;i<m;i++){
		if(m1[b[i]]>m1[b[ans]]) ans=i;
		else if(m1[b[i]]==m1[b[ans]]&&m1[c[i]]>m1[c[ans]]) ans=i;
	}
	cout<<ans+1;//因为是下标，所以要加一
	return 0;
}

只能说为啥我没早做这题，昨天的测试题有一个跟这个逻辑几乎是一样的，今天早上才把它写出来。当仓库往右移动一个单位，仓库左边的商店距离会集体+1，右边的商店集体-1。所以很容易看出，商店建在最中间是距离之和最小的时候。所以我只要将商店按距离排好序，找到最中间的商店即可，若商店为双数，则在仓库可建在最中间的两个商店之间的任意位置。然后求和即可。

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, ans, a[maxn];
int main() {
	cin >> n;
	for (int i = 1; i <= n; i++) cin >> a[i];
	sort(a + 1, a + n + 1);
	for (int i = 1; i <= n / 2; i++)
		ans += (a[n - i + 1] - a[i]);
	cout << ans;
	return 0;
}