堆排序和选择排序

选择排序的执行过程为每次循环遍历数组找出最小（或最大）的数，将其放在数组的有序数列的最后面，每次第i次遍历查找要执行N-i个单位时间，然后要执行N次，故时间复杂度为O（N^2），很简单，比较适合较小的数列的排序。

选择排序的代码selection_sort.cpp会在下面的完整代码中呈现。

而堆排序是对于选择排序的优化排序，它利用率了最大（最小）堆顶的数最大（最小）的性质，使得找到一个数组找到最大（最小）的元素的操作不需要像选择排序一样消耗N-i的时间。其时间复杂度为O（nlogn），空间复杂度为O（1）。

在介绍堆排序的执行过程前，先要了解几个公式：

对于一个根节点 i，其左子树为 2*i+1，其右子树为 2*i+2 ，而最后一个有子树的根节点 a 的位置小于等于 N/2，N是待排序数组的长度。

本文中有关堆排序的介绍图片都是转自下面的作者的博客：

作者： dreamcatcher-cx

出处： <http://www.cnblogs.com/chengxiao/>

其执行过程如下：

1.先建立最大（最小）堆（build_heap）

1.1 将数组导入一颗完全二叉树；

1.2 从倒数第一个有子树的根节点开始建立堆（heapify）（操作就是通过比较和变换使得根节点的大小大于（小于）子树的大小。），然后对前面一个根节点做同样的循环操作，直到堆顶也操作结束，则完成建立整个堆。

在heapify的过程中，我们要在改变了一个子树跟根节点位置后，再向下调整其子树的子树和其子树的位置，直至最后一个子树。

这部分代码如下：

void heap_sort::heapify(int Array[],int i,int n)//最大堆
{    
    int child;
    for (; Lchild(i) < n; i = child)//这个for循环可以看出，heapify的思想是通过自顶向下的方法调整最大堆，
    {                               //并且只调整改变过位置的堆，这就要求下面的已经是最大（小）堆。
        child = Lchild(i);          //因为假如下面的树不符合堆的话，若上面的树已经形成堆了那么下面的就不会再作调整。
        if (child + 1 < n&&Array[child] < Array[child + 1])//最终可能无法得出整个堆。
            child++;
        if (Array[i] < Array[child])
        {
            int temp = Array[i];
            Array[i] = Array[child];
            Array[child] = temp;
        }
        else
            break;
    }

}
void heap_sort::build_heap(int Array[], int n)
{
    for (int i = n / 2; i >= 0; i--)//从最后的（往往是从没有子树的根节点开始，差不了多少）有子树的根节点开始。
    {
        heap_sort::heapify(Array, i, n);
    }
}

2. 交换堆顶与堆末尾的数值，并且调整堆的长度后，重新调整成最大（最小）堆，一直循环直至堆中只剩一个堆顶元素。这个过程实际上大部分人已经能理解了。如下图所示：

最终得到图如下：

这部分代码如下：

void heap_sort::sort_heap(int Array[], int n)
{
    heap_sort::build_heap(Array, n);
    for (int i = n - 1; i > 0; i--)
    {
        int temp = Array[i];
        Array[i] = Array[0];
        Array[0] = temp;
        heap_sort::heapify(Array, 0, i);//因为下面的已经是堆，所以上面经过变换后变成无序树后只需要自顶向下调整即可。
    }

}

完整的工程代码如下：

Sort.h

//自己编写的各种排序算法的头文件。
#ifndef _SORT_H
#define _SORT_H
//冒泡排序
class bubble_sort{
private:
    int *Array,Length;
public:
    bubble_sort(int *Array1,int Length);
    int *sort_bubble();

};
//归并排序
class merge_sort{
public:
     static void sort_merge(int Array1[], int Array2[], int Left, int Rightend, int Right,int recursion);
     static void Merge(int Array1[], int Array2[], int Left, int Rightend);//递归方法
     static void Merge_pass(int Array1[], int Array2[], int ordered_len,int Length);
     static void Merge1(int Array1[], int Array2[], int Length);//非递归方法
};
//快速排序
class quick_sort{
public:
    static void sort_quick(int Array1[],int Left,int right);
    
};
//插入排序
class insertion_sort{
public:
    static void sort_insertion(int Array[], int n);
};
//堆排序
class heap_sort{
public:
    static void sort_heap(int Array[], int n);
    static void build_heap(int Array[], int n);
    static void heapify(int Array[], int i, int n);
};
//选择排序
class selection_sort{
public:
    static void sort_selection(int Array[], int n);

};
#endif

heap_sort.cpp

#include "Sort.h"
#define Lchild(i) (2*i+1)//定义对于传入的根节点算出相应的左子节点
void heap_sort::heapify(int Array[],int i,int n)//最大堆
{    
    int child;
    for (; Lchild(i) < n; i = child)//这个for循环可以看出，heapify的思想是通过自顶向下的方法调整最大堆，
    {                               //并且只调整改变过位置的堆，这就要求下面的已经是最大（小）堆。
        child = Lchild(i);          //因为假如下面的树不符合堆的话，若上面的树已经形成堆了那么下面的就不会再作调整。
        if (child + 1 < n&&Array[child] < Array[child + 1])//最终可能无法得出整个堆。
            child++;
        if (Array[i] < Array[child])
        {
            int temp = Array[i];
            Array[i] = Array[child];
            Array[child] = temp;
        }
        else
            break;
    }

}
void heap_sort::build_heap(int Array[], int n)
{
    for (int i = n / 2; i >= 0; i--)//从最后的（往往是从没有子树的根节点开始，差不了多少）有子树的根节点开始。
    {
        heap_sort::heapify(Array, i, n);
    }
}
void heap_sort::sort_heap(int Array[], int n)
{
    heap_sort::build_heap(Array, n);
    for (int i = n - 1; i > 0; i--)
    {
        int temp = Array[i];
        Array[i] = Array[0];
        Array[0] = temp;
        heap_sort::heapify(Array, 0, i);//因为下面的已经是堆，所以上面经过变换后变成无序树后只需要自顶向下调整即可。
    }

}

selection_sort.cpp

#include "Sort.h"
void selection_sort::sort_selection(int Array[], int n)
{
    for (int i = 0; i < n; i++)
    {
        int min_location = i;
        
        for (int j = n - 1; j >i; j--)
        {
            if (Array[j] < Array[min_location])
                min_location = j;
        }
        int temp;
        temp = Array[min_location];
        Array[min_location] = Array[i];
        Array[i] = temp;
    }
}

main.cpp

#include <iostream>
#include "Sort.h"
using namespace std;
void main()
{
    int Array[] = { 7, 5, 2, 1, 3, 7,93, 6,5, 10, 100, 98, 44, 66, 23 };
    int Array2[] = { 7, 5, 2, 1, 3, 7, 93, 6, 5, 10, 100, 98, 44, 66, 23 };
    int n = sizeof(Array) / sizeof(int);
    int n2 = sizeof(Array2) / sizeof(int);
    heap_sort::sort_heap(Array, n);
    selection_sort::sort_selection(Array2, n2);
    cout << "堆排序：" << endl;
    for (int i = 0; i < n; i++)
    {
        cout << Array[i] << endl;
    }
    cout << "选择排序：" << endl;
    for (int i = 0; i < n; i++)
    {
        cout << Array2[i] << endl;
    }
    system("pause");
}

运行结果如下：

到此介绍结束，欢迎交流。

作者：十面埋伏但莫慌

出处： <https://www.cnblogs.com/leo-lv/>

转载请注明出处及原文链接，谢谢！

来源：oschina

链接：https://my.oschina.net/u/4411125/blog/4296468

标签

c++

Bubble