第48课 - 冒泡排序和希尔排序

1、冒泡排序

        冒泡排序的基本思想 

            －每次从后向前进行（假设为第i次），j = n-1, n-2, ... , i,

                两两比较V[j-1]和V[j]的关键字；如果发生逆序，则交换 

                V[j-1]和V[j]。

        第i次冒泡排序示例

                

                

            

扫描二维码关注公众号，回复： 1084570 查看本文章

2、编程实验 

冒泡排序的实现 Sort::Bubble 

template < typename T>
    static void Bubble(T array[],int len,bool min2max=true)
    {
        bool exchange = true;
        for(int i=0;i<len && exchange ;i++) //如果exchange = false后面已经排序好，不需要排序
        {
            exchange = false;

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

main.cpp

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

using namespace std;
using namespace DTLib;



int main()
{
    int array[] = {7,9,4,6,2};

    Sort::Bubble(array,5);

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

    cout<<endl;

    Sort::Bubble(array,5,0);

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

    cout<<endl;

    return 0;
}

                        

3、希尔排序（划时代意义）

            希尔排序的基本思想

                －将待排序列划分为若干组，在每—组内进行插入排序，以使 

                    整个序列基本有序，然后再对整个序列进行插入排序。 

            希尔排序示例 

                    例如：将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。 

            

                 

                

4、编程实验 

希尔排序的实现     Sort::Shell 

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

        do
        {
            d = d / 3 + 1;  //实践证明这样效果更好，也可以d--

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

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

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

        }while(d > 1);
    }

main.cpp

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

using namespace std;
using namespace DTLib;



int main()
{
    int array[] = {7,9,4,6,2};

    Sort::Shell(array,5);

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

    cout<<endl;

    Sort::Shell(array,5,0);

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

    cout<<endl;

    return 0;
}

                        

4、小结 

            冒泡排序每次从后向前将较小的元素交互到位 

            冒泡排序是—种稳定的排序法，其复杂度为O(n²）

            希尔排序通过分组的方式进行多次插入排序 

            希尔排序是—种 不稳定的排序法，其复杂度为 O(n^3/2)