二叉堆（c++实现）

最新推荐文章于 2024-02-05 23:58:17 发布
最新推荐文章于 2024-02-05 23:58:17 发布
阅读量824 收藏 9
点赞数
分类专栏： c++ 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41009689/article/details/106173327
版权
二叉堆的介绍

二叉堆是完全二元树或者是近似完全二元树，按照数据的排列方式可以分为两种：最大堆和最小堆。
最大堆：父结点的键值总是大于或等于任何一个子节点的键值；最小堆：父结点的键值总是小于或等于任何一个子节点的键值。示意图如下：
在这里插入图片描述
二叉堆一般都通过"数组"来实现。数组实现的二叉堆，父节点和子节点的位置存在一定的关系。有时候，我们将"二叉堆的第一个元素"放在数组索引0的位置，有时候放在1的位置。当然，它们的本质一样(都是二叉堆)，只是实现上稍微有一点点的区别。

假设"第一个元素"在数组中的索引为 0 的话，则父节点和子节点的位置关系如下：

  • 索引为i的左孩子的索引是 (2*i+1)
  • 索引为i的右孩子的索引是 (2*i+2)
  • 索引为i的父结点的索引是 floor((i-1)/2)

假设"第一个元素"在数组中的索引为 1 的话，则父节点和子节点的位置关系如下：

  • 索引为i的左孩子的索引是 (2*i)
  • 索引为i的右孩子的索引是 (2*i+1)
  • 索引为i的父结点的索引是 floor(i/2)
二叉堆的实现
1. 基本定义
template <typename T>
class MaxHeap{
    private:
        T *mHeap;                 // 数据
        int mCapacity;            // 总的容量
        int mSize;                // 实际容量

    private:
        // 最大堆的向下调整算法
        void filterdown(int start, int end);
        // 最大堆的向上调整算法(从start开始向上直到0，调整堆)
        void filterup(int start);
    public:
        MaxHeap();
        MaxHeap(int capacity);
        ~MaxHeap();

        // 返回data在二叉堆中的索引
        int getIndex(T data);
        // 删除最大堆中的data
        int remove(T data);
        // 将data插入到二叉堆中
        int insert(T data);
        // 打印二叉堆
        void print();
};

MaxHeap是最大堆的对应的类。它包括的核心内容是"添加"和"删除"，理解这两个算法，二叉堆也就基本掌握了。下面对它们进行介绍

2. 添加

假设在最大堆[90,80,70,60,40,30,20,10,50]种添加85，需要执行的步骤如下：
在这里插入图片描述
如图所示，当向最大堆中添加数据时：先将数据加入到最大堆的最后，然后尽可能把这个元素往上挪，直到挪不动为止！将85添加到[90,80,70,60,40,30,20,10,50]中后，最大堆变成了[90,85,70,60,80,30,20,10,50,40]。

在实现添加之前，先实现怎么将数据往上挪：

/*
最大堆的向上调整算法(从start开始向上直到0，调整堆)
注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
参数说明：
start -- 被上调节点的起始位置(一般为数组中最后一个元素的索引)
 */
template <typename T>
void MaxHeap<T>::filterup(int start)
{
    int c = start;            // 当前节点(current)的位置
    int p = (c-1)/2;          // 父(parent)结点的位置 
    T tmp = mHeap[c];         // 当前节点(current)的大小

    while(c > 0)
    {
        if(mHeap[p] >= tmp)
            break;
        else
        {
            mHeap[c] = mHeap[p];
            c = p;
            p = (p-1)/2;   
        }       
    }
    mHeap[c] = tmp;
}

下面实现添加：

/* 
将data插入到二叉堆中
返回值：
	0，表示成功
	-1，表示失败
 */
template <typename T>
int MaxHeap<T>::insert(T data)
{
    // 如果"堆"已满，则返回
    if(mSize == mCapacity)
        return -1;
 
    mHeap[mSize] = data;        // 将"数组"插在表尾
    filterup(mSize);            // 向上调整堆
    mSize++;                    // 堆的实际容量+1
    return 0;
}

insert(data)的作用：将数据data添加到最大堆中。当堆已满的时候，添加失败；否则data添加到最大堆的末尾。然后通过上调算法重新调整数组，使之重新成为最大堆。

3. 删除

假设从最大堆[90,85,70,60,80,30,20,10,50,40]中删除90，需要执行的步骤如下：
在这里插入图片描述
如上图所示，当从最大堆中删除数据时：先删除该数据，然后用最大堆中最后一个的元素插入这个空位；接着，把插入的数据依次往下挪，直到剩余的数据变成一个最大堆。
从[90,85,70,60,80,30,20,10,50,40]删除90之后，最大堆变成了[85,80,70,60,40,30,20,10,50]。

注意：考虑从最大堆[90,85,70,60,80,30,20,10,50,40]中删除60，执行的步骤不能单纯的用它的子节点来替换；而必须考虑到"替换后的树仍然要是最大堆"！
在这里插入图片描述
在实现删除之前首先实现怎么将数据往下挪：

/* 
 最大堆的向下调整算法
 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
 参数说明：
    start -- 被下调节点的起始位置(一般为0，表示从第1个开始)
    end   -- 截至范围(一般为数组中最后一个元素的索引)
 */
template <typename T>
void MaxHeap<T>::filterdown(int start, int end)
{
    int c = start;          // 当前(current)节点的位置
    int l = 2*c + 1;     // 左(left)孩子的位置
    T tmp = mHeap[c];    // 当前(current)节点的大小

    while(l <= end)
    {
        // "l"是左孩子，"l+1"是右孩子
        if(l < end && mHeap[l] < mHeap[l+1])
            l++;        // 左右两孩子中选择较大者，即mHeap[l+1]
        if(tmp >= mHeap[l])
            break;        //调整结束
        else
        {
            mHeap[c] = mHeap[l];
            c = l;
            l = 2*l + 1;   
        }       
    }   
    mHeap[c] = tmp;
}

接下来实现删除操作：

/*
删除最大堆中的data
返回值：
  0，成功
 -1，失败
 */
template <typename T>
int MaxHeap<T>::remove(T data)
{
    int index;
    // 如果"堆"已空，则返回-1
    if(mSize == 0)
        return -1;

    // 获取data在数组中的索引
    index = getIndex(data); 
    if (index==-1)
        return -1;

    mHeap[index] = mHeap[--mSize];    // 用最后元素填补
    filterdown(index, mSize-1);        // 从index位置开始自上向下调整为最大堆

    return 0;
}

下面为整个完整的最大堆的实现：

#include <iomanip>
#include <iostream>
using namespace std;

template <typename T>
class MaxHeap
{
    private:
        T *mHeap;         // 数据
        int mCapacity;    // 总的容量
        int mSize;        // 实际容量

        // 最大堆的向下调整算法
        void filterdown(int start, int end);
        // 最大堆的向上调整算法(从start开始向上直到0，调整堆)
        void filterup(int start);
    public:
        MaxHeap();
        MaxHeap(int capacity);
        ~MaxHeap();

        // 返回data在二叉堆中的索引
        int getIndex(T data);
        // 删除最大堆中的data
        int remove(T data);
        // 将data插入到二叉堆中
        int insert(T data);
        // 打印二叉堆
        void print();
};

/* 
 * 构造函数
 */
template <typename T>
MaxHeap<T>::MaxHeap()
{
    new (this)MaxHeap(30);
}

template <typename T>
MaxHeap<T>::MaxHeap(int capacity)
{
    mSize = 0;
    mCapacity = capacity;
    mHeap = new T[mCapacity];
}
/* 
 * 析构函数
 */
template <typename T>
MaxHeap<T>::~MaxHeap() 
{
    mSize = 0;
    mCapacity = 0;
    delete[] mHeap;
}

/* 
 * 返回data在二叉堆中的索引
 *
 * 返回值：
 *     存在 -- 返回data在数组中的索引
 *     不存在 -- -1
 */
template <typename T>
int MaxHeap<T>::getIndex(T data)
{
    for(int i=0; i<mSize; i++)
        if (data==mHeap[i])
            return i;

    return -1;
}

/* 
 * 最大堆的向下调整算法
 *
 * 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
 *
 * 参数说明：
 *     start -- 被下调节点的起始位置(一般为0，表示从第1个开始)
 *     end   -- 截至范围(一般为数组中最后一个元素的索引)
 */
template <typename T>
void MaxHeap<T>::filterdown(int start, int end)
{
    int c = start;             // 当前(current)节点的位置
    int l = 2*c + 1;           // 左(left)孩子的位置
    T tmp = mHeap[c];         // 当前(current)节点的大小

    while(l <= end)
    {
        // "l"是左孩子，"l+1"是右孩子
        if(l < end && mHeap[l] < mHeap[l+1])
            l++;        // 左右两孩子中选择较大者，即mHeap[l+1]
        if(tmp >= mHeap[l])
            break;        //调整结束
        else
        {
            mHeap[c] = mHeap[l];
            c = l;
            l = 2*l + 1;   
        }       
    }   
    mHeap[c] = tmp;
}

/*
 * 删除最大堆中的data
 *
 * 返回值：
 *      0，成功
 *     -1，失败
 */
template <typename T>
int MaxHeap<T>::remove(T data)
{
    int index;
    // 如果"堆"已空，则返回-1
    if(mSize == 0)
        return -1;

    // 获取data在数组中的索引
    index = getIndex(data); 
    if (index==-1)
        return -1;

    mHeap[index] = mHeap[--mSize];    // 用最后元素填补
    filterdown(index, mSize-1);        // 从index位置开始自上向下调整为最大堆

    return 0;
}

/*
 * 最大堆的向上调整算法(从start开始向上直到0，调整堆)
 *
 * 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
 *
 * 参数说明：
 *     start -- 被上调节点的起始位置(一般为数组中最后一个元素的索引)
 */
template <typename T>
void MaxHeap<T>::filterup(int start)
{
    int c = start;            // 当前节点(current)的位置
    int p = (c-1)/2;        // 父(parent)结点的位置 
    T tmp = mHeap[c];        // 当前节点(current)的大小

    while(c > 0)
    {
        if(mHeap[p] >= tmp)
            break;
        else
        {
            mHeap[c] = mHeap[p];
            c = p;
            p = (p-1)/2;   
        }       
    }
    mHeap[c] = tmp;
}

/* 
 * 将data插入到二叉堆中
 *
 * 返回值：
 *     0，表示成功
 *    -1，表示失败
 */
template <typename T>
int MaxHeap<T>::insert(T data)
{
    // 如果"堆"已满，则返回
    if(mSize == mCapacity)
        return -1;

    mHeap[mSize] = data;         // 将"数组"插在表尾
    filterup(mSize);             // 向上调整堆
    mSize++;                     // 堆的实际容量+1

    return 0;
}

/* 
 * 打印二叉堆
 *
 * 返回值：
 *     0，表示成功
 *    -1，表示失败
 */
template <typename T>
void MaxHeap<T>::print()
{
    for (int i=0; i<mSize; i++)
        cout << mHeap[i] << " ";
}
    
int main()
{
    int a[] = {10, 40, 30, 60, 90, 70, 20, 50, 80};
    int i, len=(sizeof(a)) / (sizeof(a[0])) ;
    MaxHeap<int>* tree=new MaxHeap<int>();

    cout << "== 依次添加: ";
    for(i=0; i<len; i++)
    {
        cout << a[i] <<" ";
        tree->insert(a[i]);
    }

    cout << "\n== 最 大 堆: ";
    tree->print();

    i=85;
    tree->insert(i);
    cout << "\n== 添加元素: " << i;
    cout << "\n== 最 大 堆: ";
    tree->print();

    i=90;
    tree->remove(i);
    cout << "\n== 删除元素: " << i;
    cout << "\n== 最 大 堆: ";
    tree->print();
    cout << endl; 

    return 0;
}

下面为二叉堆的最小堆实现：

#include <iomanip>
#include <iostream>
using namespace std;

template <typename T>
class MinHeap{
    private:
        T *mHeap;        // 数据
        int mCapacity;    // 总的容量
        int mSize;        // 实际容量
        
        // 最小堆的向下调整算法
        void filterdown(int start, int end);
        // 最小堆的向上调整算法(从start开始向上直到0，调整堆)
        void filterup(int start);
    public:
        MinHeap();
        MinHeap(int capacity);
        ~MinHeap();

        // 返回data在二叉堆中的索引
        int getIndex(T data);
        // 删除最小堆中的data
        int remove(T data);
        // 将data插入到二叉堆中
        int insert(T data);
        // 打印二叉堆
        void print();
};

/* 
 * 构造函数
 */
template <typename T>
MinHeap<T>::MinHeap()
{
    new (this)MinHeap(30);
}

template <typename T>
MinHeap<T>::MinHeap(int capacity)
{
    mSize = 0;
    mCapacity = capacity;
    mHeap = new T[mCapacity];
}
/* 
 * 析构函数
 */
template <typename T>
MinHeap<T>::~MinHeap() 
{
    mSize = 0;
    mCapacity = 0;
    delete[] mHeap;
}

/* 
 * 返回data在二叉堆中的索引
 *
 * 返回值：
 *     存在 -- 返回data在数组中的索引
 *     不存在 -- -1
 */
template <typename T>
int MinHeap<T>::getIndex(T data)
{
    for(int i=0; i<mSize; i++)
        if (data==mHeap[i])
            return i;

    return -1;
}

/* 
 * 最小堆的向下调整算法
 *
 * 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
 *
 * 参数说明：
 *     start -- 被下调节点的起始位置(一般为0，表示从第1个开始)
 *     end   -- 截至范围(一般为数组中最后一个元素的索引)
 */
template <typename T>
void MinHeap<T>::filterdown(int start, int end)
{
    int c = start;          // 当前(current)节点的位置
    int l = 2*c + 1;     // 左(left)孩子的位置
    T tmp = mHeap[c];    // 当前(current)节点的大小

    while(l <= end)
    {
        // "l"是左孩子，"l+1"是右孩子
        if(l < end && mHeap[l] > mHeap[l+1])
            l++;        // 左右两孩子中选择较小者，即mHeap[l+1]
        if(tmp <= mHeap[l])
            break;        //调整结束
        else
        {
            mHeap[c] = mHeap[l];
            c = l;
            l = 2*l + 1;   
        }       
    }   
    mHeap[c] = tmp;
}
 
/*
 * 删除最小堆中的data
 *
 * 返回值：
 *      0，成功
 *     -1，失败
 */
template <typename T>
int MinHeap<T>::remove(T data)
{
    int index;
    // 如果"堆"已空，则返回-1
    if(mSize == 0)
        return -1;

    // 获取data在数组中的索引
    index = getIndex(data); 
    if (index==-1)
        return -1;

    mHeap[index] = mHeap[--mSize];        // 用最后元素填补
    filterdown(index, mSize-1);    // 从index号位置开始自上向下调整为最小堆

    return 0;
}

/*
 * 最小堆的向上调整算法(从start开始向上直到0，调整堆)
 *
 * 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
 *
 * 参数说明：
 *     start -- 被上调节点的起始位置(一般为数组中最后一个元素的索引)
 */
template <typename T>
void MinHeap<T>::filterup(int start)
{
    int c = start;            // 当前节点(current)的位置
    int p = (c-1)/2;        // 父(parent)结点的位置 
    T tmp = mHeap[c];        // 当前节点(current)的大小

    while(c > 0)
    {
        if(mHeap[p] <= tmp)
            break;
        else
        {
            mHeap[c] = mHeap[p];
            c = p;
            p = (p-1)/2;   
        }       
    }
    mHeap[c] = tmp;
}
  
/* 
 * 将data插入到二叉堆中
 *
 * 返回值：
 *     0，表示成功
 *    -1，表示失败
 */
template <typename T>
int MinHeap<T>::insert(T data)
{
    // 如果"堆"已满，则返回
    if(mSize == mCapacity)
        return -1;
 
    mHeap[mSize] = data;        // 将"数组"插在表尾
    filterup(mSize);            // 向上调整堆
    mSize++;                    // 堆的实际容量+1

    return 0;
}
  
/* 
 * 打印二叉堆
 *
 * 返回值：
 *     0，表示成功
 *    -1，表示失败
 */
template <typename T>
void MinHeap<T>::print()
{
    for (int i=0; i<mSize; i++)
        cout << mHeap[i] << " ";
}

int main()
{
    int a[] = {80, 40, 30, 60, 90, 70, 10, 50, 20};
    int i, len=(sizeof(a)) / (sizeof(a[0])) ;
    MinHeap<int>* tree=new MinHeap<int>();

    cout << "== 依次添加: ";
    for(i=0; i<len; i++)
    {
        cout << a[i] <<" ";
        tree->insert(a[i]);
    }

    cout << "\n== 最 小 堆: ";
    tree->print();

    i=15;
    tree->insert(i);
    cout << "\n== 添加元素: " << i;
    cout << "\n== 最 小 堆: ";
    tree->print();

    i=10;
    tree->remove(i);
    cout << "\n== 删除元素: " << i;
    cout << "\n== 最 小 堆: ";
    tree->print();
    cout << endl; 

    return 0;
}

测试程序已经包含在相应的实现文件(MaxHeap.cpp)中了，下面只列出程序运行结果。

最大堆(MaxHeap.cpp)的运行结果：
== 依次添加: 10 40 30 60 90 70 20 50 80
== 最 大 堆: 90 80 70 60 40 30 20 10 50
== 添加元素: 85
== 最 大 堆: 90 85 70 60 80 30 20 10 50 40
== 删除元素: 90
== 最 大 堆: 85 80 70 60 40 30 20 10 50

zhangshen12356
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构实现 6.1：二叉堆_基于动态数组实现（C++版）
九霄星河的博客
11-14 363
数据结构实现 6.1：二叉堆_基于动态数组实现（C++版）1. 概念及基本框架1.1 满二叉树1.2 完全二叉树2. 基本操作程序实现2.1 增加操作2.2 删除操作2.3 查找操作2.4 其他操作3. 算法复杂度分析3.1 增加操作3.2 删除操作3.3 查找操作4. 完整代码 1. 概念及基本框架 二叉堆 是一种高级数据结构，这里我们通过 1.1 中的 动态数组 来实现。 因为二分搜索树操作的...
二叉堆的构建、插入、删除等操作
暖心~的博客
06-20 2146
共享内存就是两个或者多个进程共享的一块区域。只要一个进程改变了这块地址中的内容的时候，其他进程便会察觉到改变的内容。 （1）创建共享内存 int shmget(key_t key, int size, int shmflg) （2）将共享内存映射到自己的内存空间 void* shmat(int shmid, const void* shmaddr, int shmflg) shmi...
二叉堆的实现
04-18
二叉堆的C++实现，包含二叉堆的构造，插入，删除，销毁等操作
二叉堆：最小堆
07-08
使用c++实现最小堆。提供常见操作，如堆化数组，插入，删除，堆排序，遍历堆。
深入浅出：用C++实现二叉堆的艺术
最新发布
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
02-05 1351
在探索数据结构的宏伟宇宙中，二叉堆占据了其独特的一席之地。作为优先队列的基石，它在算法设计和数据处理中扮演着至关重要的角色。本篇博客旨在深入浅出地介绍如何在C++中实现二叉堆，无论你是数据结构的新手还是寻求更深层次理解的开发者，都能从中获得宝贵的知识和技能。
二叉堆(优先队列)与堆排序的完整实现(C++)
zorchp
12-12 616
-
C/C++ 二叉堆
我想天胡啊啊啊的博客
04-02 1367
二叉堆是一棵满足“堆性质”的完全二叉树。以小根堆为例，其“堆性质”是指：树上每个结点的权值都小于等于其左右子节点的权值。（大根堆则反之） 根据完全二叉树的性质，可在存储时令下标为x的结点的左子结点下标为2x，右子结点下标为2x+1。 以小根堆为例，分别进行插入（Insert）、移除堆顶（Extract）、移除任意结点（Remove）操作。 # include <bits/stdc++.h> using namespace std; const int INF = ~(1<<31)
二叉堆原理及实现(C++)
baidu_36161424的博客
05-28 962
文章目录一、二叉堆简介二、二叉堆的实现2.1 基本定义2.2 堆的插入2.3 堆的删除 一、二叉堆简介 二叉堆是完全二元树或者是近似完全二元树，按照数据的排列方式可以分为两种：大根堆和小根堆。 大根堆：父节点键值总是大于等于任何一个子节点键值 小根堆：父节点键值总是小于等于任何一个子节点键值 性质： 索引为i的左孩子的索引是 (2*i+1); 索引为i的右孩子的索引是 (2*i+2); 索引为i...
用C++写二叉堆（优先队列）代码，详细注释
m0_56222998的博客
11-27 627
用C++自己编写二叉堆代码
数据结构 9 基础数据结构 二叉堆 了解二叉堆的元素插入、删除、构建二叉堆的代码方式...
Marc1999的博客
06-01 354
是否记得我们在之前的学习中有学习到二叉树 忘记的小伙伴们请查看：完全二叉树的定义。 https://blogs.chaobei.xyz/archives/shuju2 二叉堆 二叉堆其实就是一个完全二叉树 一起复习一下吧：关于二叉树和满二叉树以及完全二叉树的基本概念。 二叉树 每个节点下挂元素不超过2 并且元素都是按照一定规律排列的 二叉树规律 按照前人的总结，我们可以得出以...
二叉堆c++代码
03-23
c++实现的二叉堆，很好的编程规范，可以学到模板、inline函数、引用的实际应用。代码写的很简洁
C++二叉堆实现A*算法及方向优化
01-20
由两部分组成，my_map.cpp用OpenCV实现读取地图等图像处理操作，main.cpp实现A*算法。二叉堆为类，格子为结构体。生成结果后进行优化，使原本只能走8个方向的结果优化为任意角度和方向，也就是真正的全局最短路径。
C++二叉堆实现.zip
08-20
C++实现二叉堆
SuanFan.zip_A二叉堆_A星 二叉堆_C++_c++11 a星算法_二叉堆
09-20
使用C++实现了A星算法，使用二叉堆优化。仅供新手学习。
图片相似度计算 3---（dhash--c++实现）
weixin_41009689的博客
06-08 1574
前面两篇博客介绍了均值哈希算法(ahash)、感知哈希算法(phash)。由前面的介绍可知，ahash算法是基于比较灰度图每个像素与所有像素点的平均值来实现的，最适合用于缩略图，放大搜索在本质上是对颜色作比较。phash由于做了DCT操作，本质上是对频率的比较。 下面要介绍的图像差异哈希算法(dhash)是通过对比相邻像素像素值的差异，即逐像素得到当前像素与右邻像素的差值，得到一个图像差异矩阵，通过该矩阵生成哈希值。这个逐像素得到的图像差异矩阵的比原像素矩阵少了一列，即宽度比原像素矩阵少了1，高度不变。 下
图片相似度计算 1----（ahash--c++实现）
weixin_41009689的博客
06-07 1487
最近接触到图像去重算法，有phash、dhash和ahash等基于哈希方法的去重算法。 phash全称是感知哈希算法（Perceptual hash algorithm），使用这玩意儿可以对每个图片生成一个值，然后计算他们的hamming distance，简单的说就是数一数二进制之后有几位不同。整个处理流程有点像对文章去重时先算simhash再算hamming distance，很多东西都可以直接套用过来。 首先介绍ahash算法（全称average hash）是phash算法的一种，是基于图像内容搜.
c++中cin.clear()、cin.sync()的用法
weixin_41009689的博客
05-11 1267
最近在看一段程序的时候看见用完cin之后有的时候需要用到cin.clear(); cin.sync(); 首先需要加#include，然后在学习这个用法时，让我对cin有了新的认识，例如我们读取一系列整型数据，将其存入vector对象中，然后使用count()统计某个指定值出现的次数，下面是我开始的程序： #include<iostream> #include"algorithm" #include<vector> using namespace std; int main()
图片相似度计算 2---（phash--c++实现）
weixin_41009689的博客
06-08 1209
在上一篇博客里介绍了图片相似计算中的最简单的一个ahash, 其是基于内容检索最简单的一种，这篇介绍它的增强版感知哈希算法（phash—perceptual hash）。主要也是用缩略图搜索原图并能达到较好点的效果。 其实现一共包含以下几个步骤： 图像缩放–将图像缩放到32*32大小，这一步的作用是取出各种图片尺寸和图片比例的差异，只保留结构、明暗等信息。 灰度化–将32*32大小的图像进行灰度化 离散余弦变换（DCT）–对32*32大小图像进行DCT 计算均值–用3232大小图片前面88的像素值中大于均
C++优先队列实现二叉堆
09-25
C语言中实现优先队列的经典方式是使用二叉堆数据结构。二叉堆是一种完全二叉树，同时满足堆次序的条件。在二叉堆中，每个节点的值都大于或等于其子节点的值（最大堆），或者每个节点的值都小于或等于其子节点的值...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值