1. 冒泡排序

算法介绍

冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。

它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果顺序(如从大到小、首字母从从Z到A)错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换,也就是说该元素列已经排序完成。

这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端(升序或降序排列),就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样,故名“冒泡排序”。

程序实现

#include <iostream>
using namespace std;

template <typename T>
void bubble_sort(T arr[], int size)
{
    T temp;
    for (int i = 0; i < size - 1; i++)
        for (int j = 0; j < size - i - 1; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
}

int main()
{
    int testdata[10] = {23, 1, 34, 65, 0, 21, 32, 45, 31, 25};
    bubble_sort(testdata, sizeof(testdata) / sizeof(int));
    for (int i = 0; i < 10; i++)
        cout << testdata[i] << ' ';
    cout << endl;
    return 0;
}

运行结果

2. 选择排序

算法介绍

选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理是:第一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,然后再从剩余的未排序元素中寻找到最小(大)元素,然后放到已排序的序列的末尾。以此类推,直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

实现流程

  • 线性搜索数列并找到最小值
  • 将最小值替换为列中左端的数字并进行排序(如果最小值已经在左端,则不进行任何操作)
  • 重复12,直到所有数字都被排序

程序实现

#include <iostream>
using namespace std;

template <typename T>
void selection_sort(T arr[], int size)
{
    T temp;
    for (int i = 0; i < size - 1; i++) // 从最左端开始选择,每次选择最左端为最小值
    {
        int min = arr[i], min_index = i;
        for (int j = i + 1; j < size; j++)
        {
            if (min > arr[j])
            {
                min = arr[j];
                min_index = j;
            }
        }
        if (min == arr[i])
            continue;
        else
        {
            temp = arr[i];
            arr[i] = arr[min_index];
            arr[min_index] = temp;
        }
    }
}

int main()
{
    int testdata[10] = {23, 1, 34, 65, 0, 21, 32, 45, 31, 25};
    selection_sort(testdata, sizeof(testdata) / sizeof(int));
    for (int i = 0; i < 10; i++)
        cout << testdata[i] << ' ';
    cout << endl;
    return 0;
}

运行结果

3. 插入排序

算法介绍

插入排序(Insertion sort)是一种简单直观且稳定的排序算法。如果有一个已经有序的数据序列,要求在这个已经排好的数据序列中插入一个数,但要求插入后此数据序列仍然有序,这个时候就要用到一种新的排序方法——插入排序法,插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据,算法适用于少量数据的排序,时间复杂度为O(n^2)。是稳定的排序方法。插入算法把要排序的数组分成两部分:第一部分包含了这个数组的所有元素,但将最后一个元素除外(让数组多一个空间才有插入的位置),而第二部分就只包含这一个元素(即待插入元素)。在第一部分排序完成后,再将这个最后元素插入到已排好序的第一部分中。

插入排序的基本思想是:每步将一个待排序的记录,按其关键码值的大小插入前面已经排序的文件中适当位置上,直到全部插入完为止。

程序实现

4. 堆排序

5. 归并排序

算法介绍

归并排序法(Merge Sort,以下简称MS)是分治法思想运用的一个典范。其主要算法操作可以分为以下步骤:

Step 1:将n个元素分成两个含n/2元素的子序列

Step 2:用MS将两个子序列递归排序(最后可以将整个原序列分解成n个子序列)

Step 3:合并两个已排序好的序列

易知,MS的关键在于Merge过程。对于这一过程的理解,算法导论中给出了一个形象的模型。

即假设桌面上有两堆已排序好的的牌,且每一堆都正面朝下放置。然后我们分别从两堆牌中选取顶上的一张牌(选取之后,堆顶端又会露出新的顶牌),选取较小的一张,放入输出堆,另一张放回。

重复这一步骤,最后直到一堆牌为空。由于两堆牌都是已排序,所以可知,只要将剩下的那堆牌盖到输出堆即完成整个排序过程。

程序实现

#include <iostream>
using namespace std;

void Merge(int a[], int s, int m, int e, int tmp[])
{
    //将数组a的局部a[s, m]和a[m+1, e]合并到tmp,并保证tmp有序,然后拷回a[s, m]
    //操作复杂度O(e-m+1),即O(n)
    int pb = 0;
    int p1 = s, p2 = m + 1;
    while (p1 <= m && p2 <= e)
    {
        if (a[p1] < a[p2])
            tmp[pb++] = a[p1++];
        else
            tmp[pb++] = a[p2++];
    }
    while (p1 <= m)
        tmp[pb++] = a[p1++];
    while (p2 <= e)
        tmp[pb++] = a[p2++];
    for (int i = s; i <= e; i++)
        a[i] = tmp[i - s];
}

void MergeSort(int a[], int s, int e, int tmp[])
{
    if (s < e) //否则不需要做任何事情
    {
        int m = (s + e) / 2;
        MergeSort(a, s, m, tmp);
        MergeSort(a, m + 1, e, tmp);
        Merge(a, s, m, e, tmp);
    }
}

int main()
{
    int a[] = {13, 27, 19, 2, 8, 12, 2, 8, 30, 89, 14, 2342, 192, 273, 2, 4, 1, 27};
    int b[1000];
    int size = sizeof(a) / sizeof(int);

    MergeSort(a, 0, size - 1, b);

    for (int i = 0; i < size; i++)
        cout << a[i] << ' ';
    cout << endl;
    return 0;
}

运行结果

MxXdNF.png

6. 快速排序

算法介绍

快速排序(Quicksort)是对冒泡排序的一种改进。 [1]

快速排序由C. A. R. Hoare在1960年提出。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。 [1]

程序实现

#include <iostream>
using namespace std;

void swap(int &a, int &b)
{
    int tmp = a;
    a = b;
    b = tmp;
}

void QuickSort(int a[], int s, int e)
{
    if (s >= e)
        return;
    int k = a[s];
    int i = s, j = e;
    while (i != j)
    {
        while (i < j && a[j] >= k)
            j--;
        swap(a[i], a[j]);
        while (i < j && a[i] <= k)
            ++i;
        swap(a[i], a[j]);
    }
    QuickSort(a, s, i - 1);
    QuickSort(a, i + 1, e);
}

int main()
{
    int a[] = {12, 32, 52, 23, 24, 13, 75, 234, 312, 230, 42};
    int size = sizeof(a) / sizeof(int);
    QuickSort(a, 0, size - 1);
    for (int i = 0; i < size; i++)
        cout << a[i] << ' ';
    cout << endl;
    return 0;
}

运行结果

Last modification:March 22nd, 2020 at 07:06 pm