算法整理2——冒泡排序_快速排序_归并排序

1. 冒泡排序

解：冒泡排序是一种很经典的排序，它的思路就是不断遍历数组，每一次遍历，都用当前数字和后一位数字比较，假设升序排序，如果前者大于后者，就将这两者进行交换。这样每一次遍历，都可以将最大的数字沉到底，换一种想法，就好像把最小的数字冒到最上面。因为要这一位和后一位进行比较，所以第一次遍历，到n-2为止，不然会数组越界。再者每一次遍历都会将最大的数字沉到底，所以下一次遍历不用再理会这个数字，所以遍历的次数就应该少一次。时间复杂度是O(n^2)下面给出C++实现代码：

#include<iostream>
using namespace std;
int num[1009];
int main(){
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
        cin>>num[i];
    for(int i=0;i<n-1;i++){
        for(int j=0;j<n-1-i;j++){
            if(num[j]>num[j+1]){
                int temp = num[j];
                num[j] = num[j+1];
                num[j+1] = temp;
            }
        }
    }
    for(int i=0;i<n;i++)
        cout<<num[i]<<" ";
    cout<<endl;
    return 0;
}

2. 归并排序

解：归并排序（也可以叫合并排序）的思路比较好理解。首先将一个数组一分为二，分别将这两部分进行排序，之后再讲这两部分合并起来。那么分到什么时候为止呢？答案是当分的数组长度为1时就停止。那么如何合并呢？很简单，定义两个变量i和j，i指向前一部分的开头，j指向后一部分的开头，开辟一个临时数组temp。比较i和j所指的数字，谁小，谁放在前面，谁大谁放在后面，都保存到temp数组中。无论i到头还是j到头都结束比较。之后，看一下是i到了头，还是j到了头，把没到头的那个数组的后面的部分全部原样保存到temp数组中。最后，temp数组只是一个临时数组，还要保存回被分的那个数组中，结束。时间复杂度是O(nlog2(n))。下面给出C++实现代码：

#include<iostream>
using namespace std;
int num[1009];
int temp[1009];
void Merge(int l, int mid, int r){
    int i = l;
    int j = mid+1;
    int k = 0;
    while(i<=mid&&j<=r){
        if(num[i]<=num[j]){
            temp[k++] = num[i++];
        }
        else
            temp[k++] = num[j++];
    }
    while(i<=mid)
        temp[k++] = num[i++];
    while(j<=r)
        temp[k++] = num[j++];
    for(int i=0;i<10;i++)

    for(int i=l;i<=r;i++){
        num[i] = temp[i-l];
    }
}
void MergeSort(int l, int r){
    if(l == r)
        return ;
    int mid = (l+r) / 2;
    MergeSort(l, mid);
    MergeSort(mid+1, r);
    Merge(l, mid, r);
}
int main(){
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
        cin>>num[i];
    MergeSort(0, n-1);
    for(int i=0;i<n;i++)
        cout<<num[i]<<" ";
    cout<<endl;
    return 0;
}

3. 快速排序

解：假设升序排序。快速排序的思想是在数组中随机挑选一个数字x，作为标准，之后定义i和j分别指向数组的头和尾。j向前走，i向后走，j找到一个数字停下，i找到一个数字停下，i和j所指数字进行交换。那么j和i停下的标准是什么呢？j是要找一个比x小的数字，i是要找一个比x大的数字。之后，j继续向前走，i继续向后走……直到i和j指向同一个位置时停止，假设现在i和j所指的数字是y。比较一下标准数x和y的大小，如果x比y大，则二者交换，否则直接进入下一步。下一步就是以y为标准，将这个数组划分，从0–(y-1)为一个数组，(y+1)–(n-1)为一个数组，进行递归，重复上述操作，递归结束条件是数组长度为1。这个算法中，有一点需要注意，如果你每次都挑选数组的第一个数字作为标准数x，那么一定要让j先走，再让i走，这样j才能限制住i的位置，不然会出错，读者可以自行模拟体会一下。时间复杂度是O(nlog2(n))。

#include<iostream>
using namespace std;
int num[1009];
int cnt = 0;
void QuickSort(int l, int r){
    if(l>=r)
        return ;
    int s = num[l];
    int i = l;
    int j = r;
    while(i!=j){
        while(num[j]>=s&&i<j)
            j--;
        while(num[i]<=s&&i<j)
            i++;
        if(i<j){
            int temp = num[i];
            num[i] = num[j];
            num[j] = temp;
        }
    }
    if(s>num[i]){
        num[l] = num[i];
        num[i] = s;
    }
    QuickSort(l, i-1);
    QuickSort(i+1, r);
}
int main(){
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
        cin>>num[i];
    QuickSort(0, n-1);
    for(int i=0;i<n;i++)
        cout<<num[i]<<" ";
    cout<<endl;
    return 0;
}

PS：此篇博客重点在于给出实现代码，对于问题的描述以及解题思路的讲解可能不够详细全面，敬请谅解。