排序2（c++实现）

目录

一、引言

二、交换排序

1）冒泡排序

2）快速排序

三、归并排序

---

一、引言

        话接上题，介绍了插入排序以及他的优化希尔排序，还有堆排序。这篇博客继续来讨论一下交换排序和归并排序，这里我引用acwing的几道题目来作为我们讲解的模板。

二、交换排序

1）冒泡排序

        

        冒泡排序，为什么叫冒泡排序，就是因为这种排序算法在操作过程中，会不断地比较相邻的两个元素，如果它们的顺序错误就将它们交换位置。这样，每一轮遍历后，最大（或最小）的元素就会像气泡一样“浮”到序列的一端。

        说白了，就是每次循环都会选出一个最大或者最小的数放在整个数组的一端。然后再排列数组中的剩下来的其他的数。

        给出整体性的代码——

#include <iostream>

using namespace std;
int n;
const int N = 1010;
int q[N];
void bubble_sort()
{
    for(int i = 0;i<n-1;i++)
    {
        for(int j = 0;j<n-1-i;j++)
        {
            if(q[j]>q[j+1])
            swap(q[j],q[j+1]);
        }
    }
}
int main()
{
    scanf("%d",&n);
    for(int i = 0;i<n;i++)
    {
        scanf("%d",&q[i]);
    }
    bubble_sort();
    for(int i = 0;i<n;i++) printf("%d ",q[i]);
    return 0;
    
}

        这个排序比较简单，复杂度是O(n^2)，是一种非常常用的排序算法，相信不少同志第一个接触到的排序就是冒泡排序。

2）快速排序

        

        快排能被称为快排，自然是因为他很快。他的时间复杂度是O(n*logn)，我们的希尔排序和堆排序的时间复杂度也都是O(n*logn)。

        那我们就可能发出疑问了，既然他们时间复杂度都是一样的，那他们的排序的速度一样了吗？

        其实并不是，大多数情况下，快速排序的效率还是更优的。

        那我们先来介绍一下快速排序的原理。

本图来自《啊哈，算法》，这本书的电子版我会放到评论区

        首先，我们需要认识到基准数和递归排序（当然，并不是说快排只能用递归来做，只是说这样写的话，会比较方便）。

        这里的基准数和递归就是我们从整个数组中挑选一个数，把这个数作为标准，比这个数小的数，全部放到左边，比这个数大的全部放到右边，再从左边和右边挑选一个基准数，进行下一层的递归。

        而这个基准数我们一般会选择第一个，最后一个，或者中间的那一个。但是值得一提的是，这里也有一个三数取中的做法，可能会有人觉得他没啥用，其实快速排序是一个不稳定的排序，假如说，我们这个数组本身就是一个降序的数组（其实只要是有序的），我们要把它排成一个升序的数组，那么快速排序的时间复杂度就会变大。其效率可能还不如直接插入排序。所以有一个三数取中的做法，帮助我们。

        下面给出一个整体性的代码:

#include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>

using namespace std;
int n;
const int N = 100010;
int q[N];
void quick_sort(int l,int r)
{
    if(l>=r)return ;
    int i = l-1,j = r+1,x = q[(l+r)>>1];
    while(i<j)
    {
        while(q[++i]<x);
        while(q[--j]>x);
        if(i<j)
        {
            swap(q[i],q[j]);
        }
    }
    quick_sort(l,j);
    quick_sort(j+1,r);
}
int main()
{
    scanf("%d",&n);
    for(int i = 0;i<n;i++)
    {
        scanf("%d",&q[i]);
    }
    quick_sort(0,n-1);
    for(int i = 0;i<n;i++)
    {
        printf("%d ",q[i]);
    }
    return 0;
}

三、归并排序

#include <iostream>

using namespace std;
int n;
const int N = 100010;
int q[N],temp[N];

void merge_sort(int l,int r)
{
    if(l>=r)return;
    int mid = (l+r) >> 1;
    merge_sort(l,mid),merge_sort(mid+1,r);
    int i = l,j = mid+1,k = 0;
    while(i<=mid&&j<=r)
    {
        if(q[i]<=q[j])temp[k++] = q[i++];
        else temp[k++] = q[j++];
    }
    while(i<=mid)temp[k++] = q[i++];
    while(j<=r)temp[k++] = q[j++];
    
    for(i = l,j = 0;i<=r;i++,j++)
    {
        q[i] = temp[j];
    }
}
int main()
{
    scanf("%d",&n);
    for(int i = 0;i<n;i++)
    {
        scanf("%d",&q[i]);
    }
    merge_sort(0,n-1);
    for(int i = 0;i<n;i++)
    {
        printf("%d ",q[i]);
    }
    return 0;
}

        我觉得读者最好可以举一个例子，按照上边的代码，一步一步的走，好好的理解一下。

        这段代码就是我们假定这个merge_sort排序的时候以中间的元素作为一个基准，左右两边都是有序的，我们就直接把他们按照大小放到一个新的数组里，最后再把新的数组放回到数组中完成排序。
       

        好，接下来，我们继续来谈论一下归并排序的原理，

我们以输入样例为例，先画出一个这样的结构。

        我用了三个字母，l，r，m表示每个区间的下标的左，右，中，每次向下递归，直到碰到“叶子”，然后开始回溯。回溯的过程中不断的进行归并，最后形成一个有序的数组。

        我们要按照升序排序的话，就要较小的数放到前面，较大的数留到后边。

        就像这样：

        最后会剩下一个10，也就是说右区间会有剩余的元素。

        事实上，到最后会有两种情况：

        左区间有剩余，或者右区间有剩余，但是他们只会有一个有剩余，我们只需要

        while(i<=mid)temp[k++] = q[i++];
        while(j<=r)temp[k++] = q[j++];

        这样处理一下就可以了。

        可以说归并的这种思路，再合并链表的时候也很常见，比如说：

力扣第21题

. - 力扣（LeetCode）

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 

示例 1：

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

示例 2：

输入：l1 = [], l2 = []
输出：[]

示例 3：

输入：l1 = [], l2 = [0]
输出：[0]

        这里我们只给出代码，不做过多的谈论，因为它本质上还是一个归并的过程，只要我们搞懂了归并，理解这个做法其实并不困难。

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        ListNode* cur1 = list1,*cur2 = list2;
        ListNode* dummay = new ListNode(-1);
        ListNode* head = new ListNode();
        dummay->val = -1;
        dummay= head;
        while(cur1&&cur2)
        {
            if(cur1->val <= cur2->val)
            {
                head->next = cur1;
                head = head->next;
                cur1 = cur1->next;
            }
            else{
                head->next = cur2;
                head = head->next;
                cur2 = cur2->next;
            }
        }
        if(cur1)head->next = cur1;
        if(cur2)head->next = cur2;
        head = dummay->next;
        delete dummay;
        dummay = NULL;
        return head;
    }
};