排序(2010)-归并

归并排序+归并排序求逆序对（例题P1908）归并排序（merge sort)顾名思义，这是⼀种排序算法，时间复杂度为O(nlogn)，时间复杂度上和快排⼀样归并排序是分治思想的应⽤，我们先将n个数不断地⼆分，最后得到n个长度为1的区间，显然，这n个⼩区间都是单调的，随后合并相邻的两个区间，得到n/2个单增（减）的区间，随后我们继续合并相邻的两个区间，得到n/4个单增（减）的区间....每次合并操作的总时间复杂度为O(n)，logn次合并⽤时O(logn)，故总时间复杂度为O(nlogn)合并操作⽐较好理解，就像下图这样⼆分区间即可（红线代表分割线）：然后，我们要如何实现O(n)的复杂度实现区间合并呢？我们另开⼀个⼤⼩和原数组a⼤⼩⼀样的数组alt，存储需要合并的两个区间的数，⽅便起见，我们⽤pos代表alt数组的当前指向的位置，⽤i表⽰左区间当前所指的位置，⽤j表⽰右区间当前所指的位置，如下图所⽰：记此时我们合并形成的区间为[l,r]，按升序排序，那么我们枚举这⼀区间中的pos，每次⽐较alt[i]和alt[j]，如果alt[i] < alt[j] 那么令a[pos] = alt[i]，同时pos++,i++ ，否则令a[pos] = alt[j] ，同时pos++,j++，如果左区间的数已经全部遍历，那么将右区间剩下的数依次加⼊pos位置，反之同理，操作过程如下图所⽰：⾄此，区间[l,r]这⼀段区间已经完成排序，这就是归并排序的合并过程归并排序代码#include<iostream>#include<cstdio>#include<algorithm>#include<cstring>#include<queue>#include<string>#include<fstream>#include<vector>#include<stack>#include <map>#include <iomanip>#define bug cout << "**********" << endl#define show(x, y) cout<<"["<<x<<","<<y<<"] "#define LOCAL = 1;using namespace std;typedef long long ll;const int inf = 1e9 + 7;const ll mod = 1e9 + 7;const int Max = 5e5 + 10;int n;ll sum;int alt[Max];void merge(int a[], int l, int r){for(int i= l; i <= r; i ++){alt[i] = a[i];}int mid = (l + r) >> 1;int i = l, j = mid + 1;for (int pos = l; pos <= r; pos++){if (i == mid + 1){a[pos] = alt[j];j++;}else if (j == r + 1){a[pos] = alt[i];i++;}else if (alt[i] > alt[j]){a[pos] = alt[j];j++;}else{a[pos] = alt[i];i++;}}}void merge_sort(int a[], int l, int r){if (l == r)return;int mid = (l + r) >> 1;merge_sort(a, l, mid);merge_sort(a, mid + 1, r);merge(a, l, r);}int a[Max];int main(){#ifdef LOCAL// freopen("input.txt", "r", stdin);// freopen("output.txt", "w", stdout);#endifsum = 0;scanf("%d", &n);for (int i = 0; i < n; i++)scanf("%d", a + i);merge_sort(a, 0, n - 1);for(int i = 0 ;i < n ;i ++)printf("%d%c",a[i],i == n-1?'\n':'');return0;}View Code利⽤归并排序求逆序对我们注意到在归并排序过程中，我们有⼀步判断：if(alt[i] > alt[j]) ,如果判断为真，那么显然，j 和 区间[i,mid]每⼀个点都形成逆序对，⼀共mid-i+1个，⽽且只在这个地⽅会出现形成逆序对的情况，那么情况就很简单了，我们将原数组进⾏归并排序，并在if(alt[i] > alt[j] ) 为真的时候，统计⼀下逆序对的个数即可。

计算机专业基础综合数据结构（排序）历年真题试卷汇编1(总分：72.00，做题时间：90分钟)一、单项选择题(总题数：15，分数：30.00)1.下列序列中，( )是执行第一趟快速排序后所得的序列。

【福州大学1998一、9(2分)】A.[68，11，18，69] [23，93，73]B.[68，11，69，23] [18，93，73]C.[93，73][68，11，69，23，18] √D.[68，11，69，23，18] [93，73]枢轴是73。

2.适合并行处理的排序算法是( )。

【西安电子科技大学2005一、8(1分)】【电子科技大学2005一、8(1分)】A.选择排序B.快速排序√C.希尔排序D.基数排序3.一组记录的关键字为(46，79，56，38，40，84)，则利用快速排序的方法，以第一个记录为基准得到的一次划分结果为( )。

【北京交通大学2005一、8(2分)【燕山大学2001一、4(2分)】A.(38，40，46，56，79，84)B.(40，38，46，79，56，84)C.(40，38，46，56，79，84) √D.(40，38，46，84，56，79)如何对一趟快速排序的结果在最短的时间内做出正确判断，这里给出建议：首先84应该不动，所以D排除了；接着40应调到序列首，所以A排除了；接着79应调到移走40的空位上，B排除了。

选择答案C，不必再继续做了(假定确有唯一正确答案)。

4.下列排序算法中，( )算法可能会出现下面的情况：初始数据有序时，花费的时间反而最多。

【中南大学2005一、4(2分)】A.快速排序√B.堆排序C.希尔排序D.冒泡排序5.将一组无序的数据重新排列成有序序列，其方法有：( )。

【武汉理工大学2004一、8(3分)】A.拓扑排序B.快速排序√C.堆排序√D.基数排序√6.就平均性能而言，目前最好的内排序方法是( )排序法。

【西安电子科技大学1998一、9(2分)】A.冒泡B.希尔插，AC.交换D.快速√7.如果只想得到1000个元素组成的序列中第5个最小元素之前的部分排序的序列，用( )方法最快。

数据结构期末复习题1（0907）一、基本要求1．数据结构基本概念（1）数据、数据对象和数据结构（逻辑、物理结构、基本操作）（2）抽象数据类型（3）算法的特征及评价的标准2．线形结构（1）顺序表的特点及存储结构（2）链表的特点及存储结构（3）栈的特点及基本操作（4）队列的特点及基本操作（5）顺序串和链串的存储结构（6）二维数组的地址计算（7）特殊矩阵的概念及存储结构（对称、三角、对角、稀疏）（8）广义表的概念及存储结构（9）线性表的排序（简单插入、选择和交换）（10）线性表的查找（顺序、折半和分块索引）3．树形结构（1）二叉树的性质及存储结构（顺序、二叉链表、三叉链表）（2）二叉树的遍历（3）线索二叉树（4）树的存储结构（双亲、孩子-双亲、孩子-兄弟链表）（5）树、二叉树与森林的转化方法（6）哈夫曼树（7）二叉排序树及平衡化（8）堆排序树（9）树的等价类划分4．图形结构（1）图的定义及存储结构（2）图的深度优先和广度优先遍历。

（3）图的连通性（4）最小（代价）生成树（5）拓扑排序（6）关键路径（7）最短路径（单源、顶点对）5．查找表（1）散列表的概念（2）散列表解决散列冲突的方法（开放地址法、链地址法）（3）散列表的插入和删除（4）B_树的概念、存储结构及基本操作（查找、插入、删除）6．排序方法（1）希尔排序（2）快速排序（3）二路归并排序（4）基数排序（链式、计数）（5）排序方法比较和分析（时间性能、空间性能、稳定性）二、单选题1．要求具有同一逻辑结构的数据元素具有相同的特性，其含义为A. 数据元素具有同一的特点B.数据元素其对应的数据个数及数据项的类型要一致C. 每个数据元素都一样D. 仅需要数据元素包含的数据项的个数相同2．在一个单链表中，已知*q结点是*p结点的前驱结点，若在*q 和*p之间插入结点*s，则执行操作A. s->next=p->next;p->next=s;B. s->next=p;p->next=sC. q->next=s;s->next=p;D. p->next=s;s->next=q;3．设指针p指向双链表的某一结点，则双链表结构的对称性可以用下面的操作来反映A. p->prior->next=p->next->next;B. p->prior->prior=p->next->prior;C. p->prior->next=p-> next->prior;D. p->next->next= p->prior->prior;4．表达式a*(b+c)--d的后缀表达式是A．abcd*+- B．abc+*d-C．abc*+d- D．-+*abcd5．设一个栈的输入序列为A，B，C，D，则借助一个栈所得到的输出序列不可能是A．A，B，C，D B．D，C，B，AC. A，C，D，BD. D，A，B，C6．设有一个顺序栈的入栈序列是a、b、c，则3个元素都出栈的可能不同排列个数为A．4 B．5 C. 6 D. 77．若已知一个栈的入栈序列是1，2，3，…，n，其输出序列为pl，p2，p3，…，pn，若pl是n，则pi是A．i B．n-i C．n-i+1 D．不确定8．已知广义表LS=((a，b，c)，(d，e，f))，运算head和tail函数取出元素e的运算是A．head(tail(LS))B．tail(head(LS))C．head(tail(head(tail(LS))))D．head(tail(tail(head(LS))))9．二维数组A的每个元素是由6个字符组成的串，其行下标i=0，l，…，8，列下标为j=1，2．…．10。

算法—4.归并排序（⾃顶向下）1.基本思想将两个有序的数组归并成⼀个更⼤的有序数组，很快⼈们就根据这个操作发明了⼀种简单的递归排序算法：归并排序。

要将⼀个数组排序，可以先(递归地)将它分成两半分别排序，然后将结果归并起来。

你将会看到，归并排序最吸引⼈的性质是它能够保证将任意长度为N的数组排序所需时间和NlogN成正⽐；它的主要缺点则是它所需的额外空间和N成正⽐。

简单的归并排序如下图所⽰：原地归并的抽象⽅法：实现归并的⼀种直截了当的办法是将两个不同的有序数组归并到第三个数组中，实现的⽅法很简单，创建⼀个适当⼤⼩的数组然后将两个输⼊数组中的元素⼀个个从⼩到⼤放⼊这个数组中。

public void merge(Comparable[] a, int lo, int mid, int hi){int i = lo, j = mid+1;//将a[lo..hi]复制到aux[lo..hi]for (int k = lo; k <= hi; k++) {aux[k] = a[k];}//归并回到a[lo..hi]for (int k = lo; k <= hi; k++) {if(i > mid){a[k] = aux[j++];}else if(j > hi){a[k] = aux[i++];}else if(less(aux[j], aux[i])){a[k] = aux[j++];}else{a[k] = aux[i++];}}}以上⽅法会将⼦数组a[lo..mid]和a[mid+1..hi]归并成⼀个有序的数组并将结果存放在a[lo..hi]中。

在归并时（第⼆个for循环）进⾏了4个条件判断：左半边⽤尽（取右半边的元素）、右半边⽤尽（取左半边的元素）、右半边的当前元素⼩于左半边的当前元素（取右半边的元素）以及右半边的当前元素⼤于等于左半边的当前元素（取左半边的元素）。

2.具体算法/*** ⾃顶向下的归并排序* @author huazhou**/public class Merge extends Model{private Comparable[] aux; //归并所需的辅助数组public void sort(Comparable[] a){System.out.println("Merge");aux = new Comparable[a.length]; //⼀次性分配空间sort(a, 0, a.length - 1);}//将数组a[lo..hi]排序private void sort(Comparable[] a, int lo, int hi){if(hi <= lo){return;}int mid = lo + (hi - lo)/2;sort(a, lo, mid); //将左半边排序sort(a, mid+1, hi); //将右半边排序merge(a, lo, mid, hi); //归并结果}} 此算法基于原地归并的抽象实现了另⼀种递归归并，这也是应⽤⾼效算法设计中分治思想的最典型的⼀个例⼦。

链表排序（冒泡、选择、插⼊、快排、归并、希尔、堆排序）这篇⽂章分析⼀下链表的各种排序⽅法。

以下排序算法的正确性都可以在LeetCode的这⼀题检测。

本⽂⽤到的链表结构如下（排序算法都是传⼊链表头指针作为参数，返回排序后的头指针）struct ListNode {int val;ListNode *next;ListNode(int x) : val(x), next(NULL) {}};插⼊排序（算法中是直接交换节点，时间复杂度O（n^2）,空间复杂度O（1））class Solution {public:ListNode *insertionSortList(ListNode *head) {// IMPORTANT: Please reset any member data you declared, as// the same Solution instance will be reused for each test case.if(head == NULL || head->next == NULL)return head;ListNode *p = head->next, *pstart = new ListNode(0), *pend = head;pstart->next = head; //为了操作⽅便，添加⼀个头结点while(p != NULL){ListNode *tmp = pstart->next, *pre = pstart;while(tmp != p && p->val >= tmp->val) //找到插⼊位置{tmp = tmp->next; pre = pre->next;}if(tmp == p)pend = p;else{pend->next = p->next;p->next = tmp;pre->next = p;}p = pend->next;}head = pstart->next;delete pstart;return head;}};选择排序（算法中只是交换节点的val值，时间复杂度O（n^2）,空间复杂度O（1））class Solution {public:ListNode *selectSortList(ListNode *head) {// IMPORTANT: Please reset any member data you declared, as// the same Solution instance will be reused for each test case.//选择排序if(head == NULL || head->next == NULL)return head;ListNode *pstart = new ListNode(0);pstart->next = head; //为了操作⽅便，添加⼀个头结点ListNode*sortedTail = pstart;//指向已排好序的部分的尾部while(sortedTail->next != NULL){ListNode*minNode = sortedTail->next, *p = sortedTail->next->next;//寻找未排序部分的最⼩节点while(p != NULL){if(p->val < minNode->val)minNode = p;p = p->next;}swap(minNode->val, sortedTail->next->val);sortedTail = sortedTail->next;}head = pstart->next;delete pstart;return head;}};快速排序1（算法只交换节点的val值，平均时间复杂度O（nlogn）,不考虑递归栈空间的话空间复杂度是O（1））这⾥的partition我们参考(选取第⼀个元素作为枢纽元的版本，因为链表选择最后⼀元素需要遍历⼀遍)，具体可以参考这⾥我们还需要注意的⼀点是数组的partition两个参数分别代表数组的起始位置，两边都是闭区间，这样在排序的主函数中：void quicksort(vector<int>&arr, int low, int high){if(low < high){int middle = mypartition(arr, low, high);quicksort(arr, low, middle-1);quicksort(arr, middle+1, high);}}对左边⼦数组排序时，⼦数组右边界是middle-1，如果链表也按这种两边都是闭区间的话，找到分割后枢纽元middle，找到middle-1还得再次遍历数组，因此链表的partition采⽤前闭后开的区间（这样排序主函数也需要前闭后开区间），这样就可以避免上述问题class Solution {public:ListNode *quickSortList(ListNode *head) {// IMPORTANT: Please reset any member data you declared, as// the same Solution instance will be reused for each test case.//链表快速排序if(head == NULL || head->next == NULL)return head;qsortList(head, NULL);return head;}void qsortList(ListNode*head, ListNode*tail){//链表范围是[low, high)if(head != tail && head->next != tail){ListNode* mid = partitionList(head, tail);qsortList(head, mid);qsortList(mid->next, tail);}}ListNode* partitionList(ListNode*low, ListNode*high){//链表范围是[low, high)int key = low->val;ListNode* loc = low;for(ListNode*i = low->next; i != high; i = i->next)if(i->val < key){loc = loc->next;swap(i->val, loc->val);}swap(loc->val, low->val);return loc;}};快速排序2（算法交换链表节点，平均时间复杂度O（nlogn）,不考虑递归栈空间的话空间复杂度是O（1））这⾥的partition，我们选取第⼀个节点作为枢纽元，然后把⼩于枢纽的节点放到⼀个链中，把不⼩于枢纽的及节点放到另⼀个链中，最后把两条链以及枢纽连接成⼀条链。

数据排列的方法有很多种，以下是一些常见的方法：
1. 冒泡排序：通过比较相邻元素的大小，每次循环可以让最大（或最小）的元素“冒泡”到序列的一端。

2. 选择排序：每次循环，从未排序的元素中选择最小（或最大）的元素，放到已排序序列的末尾。

3. 插入排序：将未排序的元素插入到已排序序列的合适位置。

4. 快速排序：通过选择一个基准元素，将数组分为两部分，一部分比基准小，一部分比基准大，然后对两部分继续进行快速排序。

5. 归并排序：采用分治策略，将大问题分解为小问题来解决，然后将小问题的解决结果合并来得到大问题的解决结果。

6. 堆排序：利用堆这种数据结构所设计的一种排序算法。

堆是一个近似完全二叉树的结构，并同时满足堆积的性质，即子节点的键值或索引总是小于（或大于）它的父节点。

这些排序方法有各自的优缺点，适用于不同的场景。

选择哪种排序方法取决于具体的需求和上下文。

二叉树的快速排序、归并排序方法一、快速排序快速排序采用的是分治法策略，其基本思路是先选定一个基准数（一般取第一个元素），将待排序序列抽象成两个子序列：小于基准数的子序列和大于等于基准数的子序列，然后递归地对这两个子序列排序。

1. 递归实现（1）选定基准数题目要求采用第一个元素作为基准数，因此可以直接将其取出。

（2）划分序列接下来需要将待排序序列划分成两个子序列。

我们定义两个指针 i 和 j，从待排序序列的第二个元素和最后一个元素位置开始，分别向左和向右扫描，直到 i 和 j 相遇为止。

在扫描过程中，将小于等于基准数的元素移到左边（即与左侧序列交换），将大于基准数的元素移到右边（即与右侧序列交换）。

当 i=j 时，扫描结束。

（3）递归排序子序列完成划分后，左右两个子序列就确定了下来。

接下来分别对左右两个子序列递归调用快速排序算法即可。

2. 非递归实现上述方法是快速排序的递归实现。

对于大量数据或深度递归的情况，可能会出现栈溢出等问题，因此还可以使用非递归实现。

非递归实现采用的是栈结构，将待排序序列分成若干子序列后，依次将其入栈并标注其位置信息，然后将栈中元素依次出栈并分割、排序，直至栈为空。

二、归并排序归并排序同样采用的是分治思想。

其基本思路是将待排序序列拆分成若干个子序列，直至每个子序列只有一个元素，然后将相邻的子序列两两合并，直至合并成一个有序序列。

1. 递归实现（1）拆分子序列归并排序先将待排序序列进行拆分，具体方法是将序列平分成两个子序列，然后递归地对子序列进行拆分直至每个子序列只剩下一个元素。

（2）合并有序子序列在完成子序列的拆分后，接下来需要将相邻的子序列两两合并为一个有序序列。

我们先定义三个指针 i、j 和 k，分别指向待合并的左侧子序列、右侧子序列和合并后的序列。

在进行合并时，从两个子序列的起始位置开始比较，将两个子序列中较小的元素移动到合并后的序列中。

具体操作如下：- 当左侧子序列的第一个元素小于等于右侧子序列的第一个元素时，将左侧子序列的第一个元素移动到合并后的序列中，并将指针 i 和 k 分别加 1。

关于堆排序、归并排序、快速排序的⽐较时间复杂度：堆排序归并排序快速排序最坏时间 O(nlogn) O(nlogn) O(n^2)最好时间 O(nlogn) O(nlogn) O(nlogn)平均时间 O(nlogn) O(nlogn) O(nlogn)辅助空间 O(1) O(n) O(logn)～O(n)从时间复杂度看堆排序最好有⼈说代码实现后，数据量⾜够⼤的时候，快速排序的时间确实是⽐堆排序短解释是，对于数组，快速排序每下⼀次寻址都是紧挨当前地址的，⽽堆排序的下⼀次寻址和当前地址的距离⽐较长。

⽹友解答：1#4种⾮平⽅级的排序：希尔排序，堆排序，归并排序，快速排序我测试的平均排序时间：数据是随机整数，时间单位是秒数据规模快速排序归并排序希尔排序堆排序1000万 0.75 1.22 1.77 3.575000万 3.78 6.29 9.48 26.541亿 7.65 13.06 18.79 61.31堆排序是最差的。

这是算法硬伤，没办法的。

因为每次取⼀个最⼤值和堆底部的数据（记为X）交换，重新筛选堆，把堆顶的X调整到位，有很⼤可能是依旧调整到堆的底部（堆的底部X显然是⽐较⼩的数，才会在底部），然后再次和堆顶最⼤值交换，再调整下来。

从上⾯看出，堆排序做了许多⽆⽤功。

⾄于快速排序为啥⽐归并排序快，我说不清楚。

2#算法复杂度⼀样只是说明随着数据量的增加，算法时间代价增长的趋势相同，并不是执⾏的时间就⼀样，这⾥⾯有很多常量参数的差别，即使是同样的算法，不同的⼈写的代码，不同的应⽤场景下执⾏时间也可能差别很⼤。

快排的最坏时间虽然复杂度⾼，但是在统计意义上，这种数据出现的概率极⼩，⽽堆排序过程⾥的交换跟快排过程⾥的交换虽然都是常量时间，但是常量时间差很多。

3#请问你的快快速排序是怎么写的，我写的快速排序，当测试数组⼤于5000的时候就栈溢出了。

其他的⼏个排序都对着，不过他们呢没有⽤栈。

这是快速排序的代码，win7 32位，vs2010.1int FindPos(double *p,int low,int high)2 {3double val = p[low];4while (low<high)5 {6while(low<high&&p[high]>=val)7 high--;8 p[low]=p[high];9while(low<high&&p[low]<val)10 low++;11 p[high]=p[low];12 }13 p[low]=val;14return low;15 }16void QuickSort(double *a,int low,int high)17 {18if (!a||high<low)19return;2021if (low<high)22 {23int pos=FindPos(a,low,high);24 QuickSort(a,low,pos-1);25 QuickSort(a,pos+1,high);26 }27 }……7#谁说的快排好啊？我⼀般都⽤堆的，我认为堆好。

计算机常见的32种算法
1.冒泡排序算法
2.选择排序算法
3.插入排序算法
4.希尔排序算法
5.归并排序算法
6.快速排序算法
7.堆排序算法
8.计数排序算法
9.桶排序算法
10.基数排序算法
11.贪心算法
12.动态规划算法
13.分治算法
14.回溯算法
15.图的深度优先算法（DFS）
16.图的广度优先算法（BFS）
17. Kruskal算法（最小生成树）
18. Prim算法（最小生成树）
19. Floyd-Warshall算法（最短路径）
20. Dijkstra算法（最短路径）
21.拓扑排序算法
22. 找出最大子数组的算法（Kadane算法）
23.最长公共子序列算法
24.最长递增子序列算法
25.最长回文子串算法
26.哈夫曼编码算法
27. Rabin-Karp算法（字符串匹配）
28. Boyer-Moore算法（字符串匹配）
29.KMP算法（字符串匹配）
30.后缀数组算法
31.基于哈希表的查找算法
32.基于二分查找的查找算法
需要注意的是，以上列举的只是计算机中常见的算法之一，实际上还存在着很多其他的算法。

每种算法都有其特定的应用场景和解决问题的方法。

对于每种算法的原理和具体实现细节，可以进一步深入学习和研究。

数据结构——排序——8种常⽤排序算法稳定性分析⾸先，排序算法的稳定性⼤家应该都知道，通俗地讲就是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。

在简单形式化⼀下，如果Ai = Aj, Ai原来在位置前，排序后Ai还是要在Aj位置前。

其次，说⼀下稳定性的好处。

排序算法如果是稳定的，那么从⼀个键上排序，然后再从另⼀个键上排序，第⼀个键排序的结果可以为第⼆个键排序所⽤。

基数排序就是这样，先按低位排序，逐次按⾼位排序，低位相同的元素其顺序再⾼位也相同时是不会改变的。

另外，如果排序算法稳定，对基于⽐较的排序算法⽽⾔，元素交换的次数可能会少⼀些(个⼈感觉，没有证实)。

回到主题，现在分析⼀下常见的排序算法的稳定性，每个都给出简单的理由。

(1)冒泡排序冒泡排序就是把⼩的元素往前调或者把⼤的元素往后调。

⽐较是相邻的两个元素⽐较，交换也发⽣在这两个元素之间。

所以，如果两个元素相等，我想你是不会再⽆聊地把他们俩交换⼀下的；如果两个相等的元素没有相邻，那么即使通过前⾯的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是⼀种稳定排序算法。

(2)选择排序选择排序是给每个位置选择当前元素最⼩的，⽐如给第⼀个位置选择最⼩的，在剩余元素⾥⾯给第⼆个元素选择第⼆⼩的，依次类推，直到第n-1个元素，第n个元素不⽤选择了，因为只剩下它⼀个最⼤的元素了。

那么，在⼀趟选择，如果当前元素⽐⼀个元素⼩，⽽该⼩的元素⼜出现在⼀个和当前元素相等的元素后⾯，那么交换后稳定性就被破坏了。

⽐较拗⼝，举个例⼦，序列5 8 5 2 9，我们知道第⼀遍选择第1个元素5会和2交换，那么原序列中2个5的相对前后顺序就被破坏了，所以选择排序不是⼀个稳定的排序算法。

(3)插⼊排序插⼊排序是在⼀个已经有序的⼩序列的基础上，⼀次插⼊⼀个元素。

当然，刚开始这个有序的⼩序列只有1个元素，就是第⼀个元素。

归并排序求逆序对什么是逆序对:设 A 为⼀个有 n 个数字的有序集 (n>1)，其中所有数字各不相同。

如果存在正整数 i, j 使得1 ≤ i < j ≤ n ⽽且 A[i] > A[j]，则 <A[i], A[j]> 这个有序对称为 A 的⼀个逆序对，也称作逆序数。

如果还是不懂请点怎么求逆序对：求逆序对就需要先介绍⼀种排序⽅法：归并排序:归并排序是利⽤归并的思想实现的排序⽅法，该算法采⽤经典的分治策略分治法将问题分成⼀些⼩的问题然后递归求解.举个例⼦：输⼊n个数，要求从⼤到⼩排序：【思路】：利⽤分治发（⼆分），从中间分开，再把左右依次分开，始终让⼩区间内的数从⼩到⼤，那么这是分治的思想（分⽽治之)图解（来⾃dreamcatcher-cs的博客）：让后利⽤⼀个新的数组把数据放过去，让后再放回来代码：#include<iostream>#include<cstdio>#include<algorithm>#include<cmath>#include<queue>#include<stack>#include<vector>#include<map>#include<string>#include<cstring>using namespace std;const int maxn=999999999;const int minn=-999999999;inline int read() {char c = getchar();int x = 0, f = 1;while(c < '0' || c > '9') {if(c == '-') f = -1;c = getchar();}while(c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar(); return x * f;}int n,a[100152],b[100250];void doit(int l,int mid,int r) {int i,j,k;int n1=mid-l+1;int n2=r-mid;int L[n1],R[n2];for (i=0; i<n1; i++)L[i]=a[l+i];for (j=0; j<n2; j++)R[j]=a[mid+j+1];i=0;j=0;k=l;while(i<n1&&j<n2) {if(L[i]<=R[j]) {a[k]=L[i];i++;} else {a[k]=R[j];j++;}k++;}while(i<n1) {a[k]=L[i];i++;k++;}while(j<n2) {a[k]=R[j];j++;k++;}}void my_sort(int l,int r) { //分if(l<r) {int mid=(l+r)/2;my_sort(l,mid);my_sort(mid+1,r);doit(l,mid,r);}}int main() {cin>>n;for(int i=0; i<n; ++i) {cin>>a[i];}my_sort(0,n-1);for(int i=0; i<n; ++i) {cout<<a[i]<<"";}return0;}接下来终于到逆序对了：放两个题⽬：【题⽬描述】Prince对他在这⽚⼤陆上维护的秩序感到满意，于是决定启程离开艾泽拉斯。

归并排序算法图⽂详解（模版使⽤）算法介绍引⽤百度百科的介绍。

归并排序（Merge Sort）是建⽴在操作上的⼀种有效，稳定的排序算法，该算法是采⽤（Divide and Conquer）的⼀个⾮常典型的应⽤。

将已有序的⼦合并，得到完全有序的序列；即先使每个⼦序列有序，再使⼦序列段间有序。

若将两个有序表合并成⼀个有序表，称为⼆路归并。

算法描述归并排序，采⽤是分治法，先将数组分成⼦序列，让⼦序列有序，再将⼦序列间有序，合并成有序数组。

算法描述：（1）把长度为n的输⼊序列分成长度 n/2的⼦序列；（2）对两个⼦序列采⽤归并排序；（3）合并所有⼦序列。

算法实现void mergeSortInOrder(int[] arr,int bgn,int mid, int end){int l = bgn, m = mid +1, e = end;//相当于对⼀个数组的前半部分和后半部分进⾏排序排序，从开始的只有两个数，到后⾯//因为基本有序，所以只需要进⾏合并就⾏int[] arrs = new int[end - bgn + 1];int k = 0;//进⾏有序合并while(l <= mid && m <= e){if(arr[l] < arr[m]){arrs[k++] = arr[l++];}else{arrs[k++] = arr[m++];}}//如果前半部分⼤的⽐较多，直接接在后⾯while(l <= mid){arrs[k++] = arr[l++];}//如果后半部分⼤的⽐较多，直接接在后⾯while(m <= e){arrs[k++] = arr[m++];}//对我们原来的数组进⾏值的覆盖for(int i = 0; i < arrs.length; i++){arr[i + bgn] = arrs[i];}}void mergeSort(int[] arr, int bgn, int end){//如果开始指针⼤于结束指针，结束if(bgn >= end){return;}//通过分治将我们的数组分成多个⼩数组int mid = (bgn + end) >> 1;mergeSort(arr,bgn,mid);mergeSort(arr,mid + 1, end);//对我们的⼩数组进⾏排序mergeSortInOrder(arr,bgn,mid,end);}算法分析稳定排序外排序（需要消耗额外的内存）时间复杂度O(nlogn)，空间复杂度为O(1)。

归并排序详解及应用归并排序（Merge sort）是一种基于分治策略的经典排序算法。

它将待排序数组分成两个子数组，分别对子数组进行排序，然后将已排序的子数组合并，最终得到完整的有序数组。

归并排序的详细步骤如下：1.分解：将待排序数组不断二分，直到最小单位为单个元素，即子数组长度为1。

2.合并：逐层对已排序的子数组进行合并操作，合并过程中将两个有序子数组合并为一个有序的大数组。

合并操作的具体步骤如下： a. 创建一个辅助数组，用于存放合并后的数组。

b. 定义三个指针，分别指向两个子数组的起始位置和辅助数组的起始位置。

c. 比较两个子数组的当前元素，将较小的元素放入辅助数组，并将相应指针后移。

d. 重复上述比较和放入操作，直到一个子数组的所有元素都放入了辅助数组。

e. 将另一个子数组剩余的元素放入辅助数组。

f. 将辅助数组中的元素复制回原数组对应的位置。

3.递归：不断重复分解和合并的过程，直到最终得到完整的有序数组。

归并排序的时间复杂度为O(nlogn)，其中n是待排序数组的长度。

由于归并排序是基于分治策略，它的稳定性和效率使其成为常用的排序算法之一。

归并排序除了基本的排序功能，还具有其他一些应用。

以下是一些常见的应用场景：1.外部排序：归并排序适用于需要对大规模数据进行排序的情况，它可以将数据分割为适合内存容量的块，分别进行排序，然后将排序好的块合并成最终的有序结果。

2.链表排序：与其他排序算法相比，归并排序对链表的排序更加适用。

由于归并排序只需要改变指针的指向来完成合并操作，对于链表而言操作较为高效。

3.并行计算：归并排序可以进行并行化处理，将待排序数组分割为多个部分，分别在不同的处理器或线程上进行排序，然后将排序好的部分合并。

4.大数据处理：在大数据处理中，归并排序可以结合MapReduce等分布式计算框架，将数据分割、排序和合并操作分布在多个计算节点上，加快处理速度。

总的来说，归并排序是一种高效、稳定的排序算法，它的优点在于适用于各种数据类型的排序，并且可以应用到一些特定的场景和算法问题中。