使用模板实现一个堆排序算法

已于 2024-03-28 22:48:54 修改
阅读量145 收藏
点赞数 3
分类专栏： C++ 文章标签： c++
于 2024-03-28 19:04:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50696729/article/details/137121236
版权
本文介绍了使用C++模板编写的HeapSort排序算法，支持用户自定义比较器，分别对整数数组和Point结构体对象进行排序，并提供了堆调整和打印功能。
摘要由CSDN通过智能技术生成

使用模板的框架如下：

template <typename T, typename Compare = std::less<T>> 
class HeapSort 
{ 
public:  
    HeapSort(T *arr, size_t size);  
    void heapAdjust(size_t ,size_t);  
    void sort();
    void print(); ​ 
private:  
    vector<T> _vec;
    Compare _cmp;
};
#include <math.h>
#include <iostream>
#include <vector>
#include <ostream>

using std::cout;
using std::cin;
using std::endl;
using std::vector;

template<typename T>
void swap(T &lhs, T &rhs)
{
    auto temp = lhs;
    lhs = rhs;
    rhs = temp;
}

class Point
{
public:
    Point(int ix = 0, int iy = 0)
    : _ix(ix)
    , _iy(iy)
    {
    }

    ~Point()
    {
    }

    void print() const
    {
        cout << "(" << _ix 
            << ", " << _iy 
            << ")" << endl;
    }

    double getDistance() const
    {
        return hypot(_ix, _iy);
    } 

    int getX() const
    {
        return _ix;
    }

    int getY() const
    {
        return _iy;

    }

    friend std::ostream & operator<<(std::ostream &os, const Point &rhs);
private:
    int _ix;
    int _iy;
};

std::ostream & operator<<(std::ostream &os,const Point &rhs)
{
    os << "(" << rhs._ix
       << ", " <<rhs._iy
       << ")";
    return os;
}

namespace std
{   
//std命名空间中的less的特化，注意模板的特化
template<>
struct less<Point>
{
    bool operator()(const Point &lhs,const Point &rhs) const
    {
        if(lhs.getDistance() < rhs.getDistance())
        {
            return true;
        }
        else if(lhs.getDistance() == rhs.getDistance())
        {
            if(lhs.getX() < rhs.getX())
            {
                return true;
            }
            else if(lhs.getX() == rhs.getX())
            {
                if(lhs.getY() < rhs.getY())
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }
};   

}//end of namespace std

bool operator<(const Point &lhs, const Point &rhs)
{
    if(lhs.getDistance() < rhs.getDistance())
    {
        return true;
    }
    else if(lhs.getDistance() == rhs.getDistance())
    {
        if(lhs.getX() < rhs.getX())
        {
            return true;
        }
        else if(lhs.getX() == rhs.getX())
        {
            if(lhs.getY() < rhs.getY())
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }
    else
    {
        return false;
    }
}

//函数对象
struct ComparePoint
{
    bool operator()(const Point &lhs,const Point &rhs) const
    {
        if(lhs.getDistance() < rhs.getDistance())
        {
            return true;
        }
        else if(lhs.getDistance() == rhs.getDistance())
        {
            if(lhs.getX() < rhs.getX())
            {
                return true;
            }
            else if(lhs.getX() == rhs.getX())
            {
                if(lhs.getY() < rhs.getY())
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }
};   

namespace std
{   
//std命名空间中的greater的特化，注意模板的特化
template<>
struct greater<Point>
{
    bool operator()(const Point &lhs,const Point &rhs) const
    {
        if(lhs.getDistance() > rhs.getDistance())
        {
            return true;
        }
        else if(lhs.getDistance() == rhs.getDistance())
        {
            if(lhs.getX() > rhs.getX())
            {
                return true;
            }
            else if(lhs.getX() == rhs.getX())
            {
                if(lhs.getY() > rhs.getY())
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }
};   

}//end of namespace std

bool operator>(const Point &lhs, const Point &rhs)
{
    if(lhs.getDistance() > rhs.getDistance())
    {
        return true;
    }
    else if(lhs.getDistance() == rhs.getDistance())
    {
        if(lhs.getX() > rhs.getX())
        {
            return true;
        }
        else if(lhs.getX() == rhs.getX())
        {
            if(lhs.getY() > rhs.getY())
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }
    else
    {
        return false;
    }
}

template <typename T, typename Compare = std::less<T>>
class HeapSort
{
public:
    HeapSort(T *arr, size_t size,Compare);
    void heapAdjust(size_t ,size_t ,Compare&);
    void sort(Compare&);
    void print();

private:
    vector<T> vec;
};

template <typename T, typename Compare >
HeapSort<T, Compare>::HeapSort(T *arr, size_t size, Compare com)
{
    for (size_t i = 0; i < size; i++)
    {
        vec.push_back(arr[i]);
    }

    for (int i = size/2 - 1; i >= 0; i--)
    {
        heapAdjust(i, size,com);
    }
    swap(arr[0], arr[size - 1]);
    sort(com);
}

template <typename T, typename Compare >
void HeapSort<T, Compare>::heapAdjust(size_t adjustpos, size_t arrlen, Compare& com)
{
    size_t dad = adjustpos;
    size_t son= 2 * dad + 1;

    while(son < arrlen)
    {
        if(son + 1 < arrlen && com(vec[son], vec[son + 1]))
        {
            ++son;
        }
        if(com(vec[dad], vec[son]))
        {
            swap(vec[dad], vec[son]);
            dad = son;
            son= 2 * dad + 1;
        }
        else
        {
            break;
        }
    }
}

template <typename T, typename Compare >
void HeapSort<T, Compare>::sort(Compare& com)
{
    size_t size = vec.size();
    for (size_t i = size; i > 1; i--)
    {
        heapAdjust(0, i, com);
        swap(vec[0], vec[i - 1]);
    }
}

template <typename T, typename Compare>
void HeapSort<T,Compare>::print()
{
    for(auto &elem : vec)
    {
        cout<< elem << "  ";
    }
    cout << endl;
}

int main(int argc, char **argv)
{
    int arr[10] = {1, 2, 6, 3, 4, 8, 5, 7, 9, 10};
    HeapSort<int> hs(arr, 10, std::less<int>());
    hs.print();

    cout << endl;
    Point parr[5] = {{1,2}, {3,4}, {-1,2}, {4,5}, {2,5}};

    HeapSort<Point> hsPt(parr, 5, std::less<Point>());
    hsPt.print();

    return 0;
}

Wuatt08
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
使用C++模版实现堆排序算法
11-04 1506
合并排序具有较好的运行时间复杂度O(nlogn)，但却需要额外的O(n)的空间；插入排序不需要开辟新的空间，但其时间开销却维持在O(n^2)。这两种算法各有所长，但都不尽如人意，综合看来：不是用时间买空间，就是用空间换时间。有没有这样一种集众家所长的算法？既保持一个较好的时间复杂度，又不必开辟额外的空间。堆排序无疑是不二选择。    以下即是用模版实现的堆排序的算法。 #include
c++模板类实现算法堆排序
ssopp24的博客
04-06 855
假设为升序， 构建大堆 每次交换第一个和最后一个元素， 使最大元素沉底， 再对剩下元素进行建大堆 .h: #include //利用vector容器实现堆 template class HeapSort { public: HeapSort( ) //默认构造函数 {} HeapSort( T* a, size_t n )
堆排序，C++模板编程
weixin_33929309的博客
10-12 123
明天就要去参加百度的笔试了，现在来抱抱佛教。   理论来自：简明现代魔法 在程序设计相关领域，堆(Heap)的概念主要涉及到两个方面： 一种数据结构，逻辑上是一颗完全二叉树，存储上是一个数组对象（二叉堆）。 垃圾收集存储区，是软件系统可以编程的内存区域。 本文所说的堆，指的是前者。 堆排序的时间复杂度是O(nlgN)，与快速排序达到相同的时间复杂度。但是在实际应用中，我...
C++模板实现堆排序
luanzheng_365的博客
04-22 448
堆的概念我在之前的文章中已经有说明,这里不再赘述.本小结的内容仅包括堆排序部分.算法特点: 1.不稳定. 2.时间复杂度 O(nlog(n)) 3.空间复杂度 O(nlog(n))在堆删除节点的同时,正好可以巧妙的将该数据放置到数组被删掉的位置,最后得到排序好的数组(堆的根节点被弹出后,总是将最后节点重新放置到跟节点,这样,最后节点位置正好空出).//Heapsort //1. Not Sta
堆排序模板实现
weixin_30824277的博客
03-25 73
#pragma once #include<iostream> #include<vector> using namespace std; //仿函数定义。 template<class T> struct Big { bool operator()(T x, T y) return x > y; ...
排序算法之堆排序算法：用C++语言实现堆排序算法
最新发布
05-22
描述"排序算法之堆排序算法，用C++语言实现堆排序算法"进一步强调了我们将专注于堆排序的实际编程实现，使用C++语言的语法和特性。 标签" c++ 排序算法"明确了主题，暗示我们将深入理解C++如何处理排序问题，特别是...
堆排序、优先级队列（c++模板实现）
10-19
使用c++模板实现的堆排序、优先级队列，在vs2010下编译运行通过。压缩文件里为两个工程文件，如果有vs2010的话解压缩打开sln文件就可以了，没有的话，新建工程将文件复制过去就ok了。如果有问题可以留言。
sort-使用C++实现的排序算法之IntroSort.zip
03-10
堆排序是一种基于比较的排序算法，它将待排序的元素构造成一个大顶堆或小顶堆，然后逐步调整堆以达到排序的目的。堆排序的时间复杂度总是O(n log n)，但相比快速排序，其常数因子较大，效率较低。 C++标准库中的`...
C++ 数据结构 堆排序的实现
01-20
我将用c++实现一个堆来简单分析一下。 堆排序的基本思想为： 1、升序排列，保持大堆；降序排列，保持小堆； 2、建立堆之后，将堆顶数据与堆中最后一个数据交换，堆大小减一，然后向下调整；直到堆中只剩下一个有效值...
java-排序算法总结
02-27
本篇将深入探讨Java中实现的几种主要排序算法，并提供相关的范文、模板和素材。 1. 冒泡排序（Bubble Sort） 冒泡排序是最基础的排序算法之一，通过不断交换相邻的错误顺序元素来逐步排序。Java中实现冒泡排序，...
使用模板实现堆排序（三种方法自定义比较规则：重载比较运算符、命名空间进行扩展&模板的特化、自定义函数对象）
qq_43583123的博客
08-23 172
1、重载比较运算符2、命名空间进行扩展，模板的特化3、自定义函数对象。
【模板】堆排序
coderwait
04-17 340
理论 堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。如下图： 同时，我们对堆中的结点按层进行编号，将这种逻辑结构映射到数组中就是下面这样： 该数组从逻辑上讲就是一个堆结构，我们用简单的公式来描述一下堆的定义就是： 大顶堆：arr[i] >= arr[2i+1] &&am...
堆排序（模板）
blueoni的博客
01-12 122
up 往上调整。存储：一维数组：根节点 ：1；1.完全二叉树（除了最后一层节点 上面都是满的）2.每个结点都小于等于左右儿子：（根节点为最小值）基本操作：down 往下调整。//以上可以通过STL直接实现。4.删除任意一个元素。5.修改任意一个元素。模拟堆时：需要双映射。
堆排序模板
qq_31916715的博客
04-23 9721
堆排序原理： 本文中使用的堆为最大堆，堆顶元素为索引为0的元素。 1、将一个无序的数组构建成一个最大堆 2、交换0号元素和最后一个元素，则最后一个元素（索引假设为 lastIndex ）为最大的元素 3、将[0 ~ lastIndex - 1]的元素构建最大堆，则0号元素为最大元素 4、交换 0 和 lastIndex - 1的元素，则 lastInde - 1, lastIndex元素有序。 5...
堆排序模板（建议最小堆实现降序和最大堆实现升序）
ale_upcer的博客
03-08 920
#include <iostream> using namespace std; int h[10000]; int n; void siftdown(int i); int deletemin(); int main (){ cin>>n; int i; for(i=1;i<=n;i++){ cin>>h[i]; } for(i=n/2;i>=1;i--){ siftdown(i); .
C++模板之堆排序
hukaihx的博客
07-15 532
/*** 简单的堆排序模板 * 堆排序的一个限制：下标需要从1开始. 故只支持数组下标，不支持迭代器类型 * 数据对象需支持“<”操作符（内置类型及自定义类型）。不支持指针类型（如 char *） */template <typename T1> void heapSort(T1 *arrName, std::size_t begin, std::size_t end); template
[堆排序+模板] 堆排序
Y-puyu 的博客
10-22 601
文章目录0. 前言1. 堆排序 0. 前言 堆排序是一个不稳定的排序算法，对数据不敏感，时间复杂度稳定，主要分为两部分：建堆、堆排序。 其中建堆的时间复杂度是 O(n)O(n)O(n) 的，而排序选出一个最大、最小值的过程是 O(logn)O(logn)O(logn) 的，一共需要 n 次操作，故总共的时间复杂度是 O(nlogn)O(nlogn)O(nlogn) 的。 堆主要的两个操作，在此仅使用向下调整 down() 操作即可，至于另一个注意点就是堆排序的建堆时间复杂度计算了，和树的高度密切相关，通过
函数模板实现排序算法（冒泡、快排、堆排）
StuTan
12-24 2537
模板设计简介 冒泡排序：对一个一维数组进行两重循环，依次比较两个相邻的元素，如果顺序（如从大到小）错误就把他们交换过来，重复地进行直到没有相邻元素需要交换，则，该元素序列完成排序。 快速排序：首先对这个乱序的元素序列设定一个分界值（我设置的是该元素序列的第一位），将该数组分为左右两部分，然后将大于或等于分界值的元素集中到右边，将各元素小于或等于分界值的元素集中到左边，再递归对分界值两边的元素进行排...
用c++写一个堆排序算法模板
04-01
#include <stdio.h> #include <stdlib.h> void swap(int *a, int *b) { int temp = *a; *a = *b; *b = temp; } void heapify(int arr[], int n, int i) { int largest = i; int left = 2 * i + 1; int right = 2 * i + 2; if (left < n && arr[left] > arr[largest]) largest = left; if (right < n && arr[right] > arr[largest]) largest = right; if (largest != i) { swap(&arr[i], &arr[largest]); heapify(arr, n, largest); } } void heapSort(int arr[], int n) { for (int i = n / 2 - 1; i >= 0; i--) heapify(arr, n, i); for (int i = n - 1; i >= 0; i--) { swap(&arr[0], &arr[i]); heapify(arr, i, 0); } } void printArray(int arr[], int n) { for (int i = 0; i < n; i++) printf("%d ", arr[i]); printf("\n"); } int main() { int arr[] = {12, 11, 13, 5, 6, 7}; int n = sizeof(arr) / sizeof(arr[0]); heapSort(arr, n); printf("Sorted array is: \n"); printArray(arr, n); return 0; }

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wuatt08

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值