【数据结构】48_冒泡排序和希尔排序

冒泡排序

冒泡排序的基本思想

每次从后向前进行 （假设为第 i 次），j = n-1, n-2,...,i;两两比较 V[j-1] 和 V[j] 的关键字；如果发生逆序，则交换 V[j-1] 和 V[j]。

第 i 次冒泡排序示例

分解：

动图

编程实验：冒泡排序的实验

文件：Sort.h

#ifndef SORT_H
#define SORT_H

#include "Object.h"

namespace DTLib
{

class Sort : public Object
{
public:
    template <typename T>
    static void Select(T array[], int len, bool min2max = true)  // O(n*n)
    {
        for (int i=0; i<len; ++i)
        {
            int min = i;
            for (int j=i+1; j<len; ++j)
            {
                if ((min2max ? (array[min] > array[j]) : (array[min] < array[j])))
                {
                    min = j;
                }
            }

            if (min != i)
            {
                Swap(array[i], array[min]);
            }
        }
    }

    template <typename T>
    static void Insert(T array[], int len, bool min2max = true)  // O(n*n)
    {
        for (int i=1; i<len; ++i)
        {
            T e = array[i];
            int k = i;

            for (int j=i-1; (j>=0) && (min2max ? (e < array[j]) : (e > array[j])); --j)
            {
                array[j+1] = array[j];
                k = j;
            }

            if (i != k)
            {
                array[k] = e;
            }
        }
    }

    template <typename T>
    static void Bubble(T arrar[], int len, bool min2max = true)
    {
        bool exchange = true;

        for (int i=0; (i<len) && exchange; ++i)
        {
            exchange = false;

            for (int j=len-1; j>i; --j)
            {
                if (min2max ? (arrar[j] < arrar[j-1]) : (arrar[j] > arrar[j-1]))
                {
                    Swap(arrar[j], arrar[j-1]);
                    exchange = true;
                }
            }
        }
    }

private:
    Sort();
    Sort(const Sort&);
    Sort &operator= (const Sort&);

    template <typename T>
    static void Swap(T &a, T &b)
    {
        T c(a);
        a = b;
        b = c;
    }
};

}

#endif // SORT_H

文件：main.cpp

#include <iostream>
#include "Sort.h"

using namespace std;
using namespace DTLib;

int main()
{
    int a[5] = {3, 4, 1, 0, 2};

    Sort::Bubble(a, 5);

    for (int i=0; i<5; ++i)
    {
        cout << a[i] << " ";
    }

    cout << endl;

    Sort::Bubble(a, 5, false);

    for (int i=0; i<5; ++i)
    {
        cout << a[i] << " ";
    }

    return 0;
}

输出:

0 1 2 3 4
4 3 2 1 0

希尔排序

希尔排序的基本思想

将待排序列分为若干组，在每一组内进行插入排序，以使整个序列基本有序，然后对整个序列进行插入排序。

希尔排序示例

例如：将 n 个元素分为 d 个子序列

{R[1], R[1+d], r[1+2d],...,R[1+kd]}
{R[2], R[2+d], r[2+2d],...,R[2+kd]}
.....
{R[d], R[2d], r[3d],...,R[kd], R(k+1)d}

其中，d 为增量，它的值在排序过程中从大到小逐渐减小，直至最后一趟排序减为1。

分解：

编程实验：希尔排序的实现

文件：Sort.h

#ifndef SORT_H
#define SORT_H

#include "Object.h"

namespace DTLib
{

class Sort : public Object
{
public:
    template <typename T>
    static void Select(T array[], int len, bool min2max = true)  // O(n*n)
    {
        for (int i=0; i<len; ++i)
        {
            int min = i;
            for (int j=i+1; j<len; ++j)
            {
                if ((min2max ? (array[min] > array[j]) : (array[min] < array[j])))
                {
                    min = j;
                }
            }

            if (min != i)
            {
                Swap(array[i], array[min]);
            }
        }
    }

    template <typename T>
    static void Insert(T array[], int len, bool min2max = true)  // O(n*n)
    {
        for (int i=1; i<len; ++i)
        {
            T e = array[i];
            int k = i;

            for (int j=i-1; (j>=0) && (min2max ? (e < array[j]) : (e > array[j])); --j)
            {
                array[j+1] = array[j];
                k = j;
            }

            if (i != k)
            {
                array[k] = e;
            }
        }
    }

    template <typename T>
    static void Bubble(T arrar[], int len, bool min2max = true)
    {
        bool exchange = true;

        for (int i=0; (i<len) && exchange; ++i)
        {
            exchange = false;

            for (int j=len-1; j>i; --j)
            {
                if (min2max ? (arrar[j] < arrar[j-1]) : (arrar[j] > arrar[j-1]))
                {
                    Swap(arrar[j], arrar[j-1]);
                    exchange = true;
                }
            }
        }
    }

    template <typename T>
    static void Shell(T array[], int len, bool min2max = true)
    {
        int d = len;

        do
        {
            d = d / 3 +1;  // 实践证明此递减方式最高效！

            for (int i=d; i<len; i+=d)
            {
                T e = array[i];
                int k = i;

                for (int j=i-d; (j>=0) && (min2max ? (e < array[j]) : (e > array[j])); j-=d)
                {
                    array[j+d] = array[j];
                    k = j;
                }

                if (i != k)
                {
                    array[k] = e;
                }
            }

        }while (d > 1);
    }

private:
    Sort();
    Sort(const Sort&);
    Sort &operator= (const Sort&);

    template <typename T>
    static void Swap(T &a, T &b)
    {
        T c(a);
        a = b;
        b = c;
    }
};

}

#endif // SORT_H

文件：main.cpp

#include <iostream>
#include "Sort.h"

using namespace std;
using namespace DTLib;

int main()
{
    int a[5] = {3, 4, 1, 0, 2};

    Sort::Shell(a, 5);

    for (int i=0; i<5; ++i)
    {
        cout << a[i] << " ";
    }

    cout << endl;

    Sort::Shell(a, 5, false);

    for (int i=0; i<5; ++i)
    {
        cout << a[i] << " ";
    }

    return 0;
}

输出：

0 1 2 3 4
4 3 2 1 0

小结

• 冒泡排序每次从后向前将较小的元素交换到位
• 冒泡排序是一种稳定的排序法，其时间复杂度为O(n*n)
• 希尔排序通过分组的方式进行多次插入排序
• 希尔排序是一种不稳定的排序法，其时间复杂度为 O(n3/2)

以上内容整理于狄泰软件学院系列课程，请大家保护原创！