数据结构 之 堆（完全二叉树、大根堆、小根堆）

最新推荐文章于 2024-09-18 10:21:37 发布
最新推荐文章于 2024-09-18 10:21:37 发布
阅读量1.1w 收藏 15
点赞数 5
分类专栏： 工作上的学习 文章标签： 数据结构 二叉树 堆 完全二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012925231/article/details/78671015
版权

堆是一种完全二叉树结构，这意味着它具有完全二叉树的性质，其中一点如下所示：

设完全二叉树的一元素编号为i，1 <= I <= n，n为元素总数。有以下关系成立：
1、如果i=1，则该元素为二叉树的根节点，若i>1，则其父节点的编号为(int)(i/2)；
2、如果2*i > n，则该元素无左孩子。否则，其左孩子的编号为2 * i;
3、如果1 + 2*i > n ，则该元素无右孩子，否则，其右孩子的编号为1+2*i

这里写图片描述
之前在看堆结构的内容的时候，误认为需要将树结构引入进来进行堆中元素的管理。但是因为上面的性质使得这一切不在需要树结构。使用数组的方式就能够管理。
大根堆是大根树的一种。大根树是一种父节点值始终大于其子节点的值的结构。根树不是完全二叉树类型的，但是根堆是。
下面以大根堆为例，进行对这种具有一定属性的堆结构的插入、删除、构造和“整理”操作：
插入节点
在插入的时候，首先将数据放置到完全二叉树的下一个子节点上。然后判断其与父节点值得大小，如果父节点的值小，那么将父节点和子节点的值进行交换；交换完成之后，接着判断插入数值所在的节点与其父节点的值大小，如果仍旧是父节点的数值小，则继续交换……直到满足父节点的数值更大或者不存在父节点的情况发生。
以上面的示意图为例，如果我插入的是数值2。那么他本来就满足父节点大的情况，不需要进行任何操作。但是如果插入的是10，则需要将数值8 和数值6都向下降一级，同时，数值10一路升级到最顶点。
这里写图片描述
插入的代码如下所示：

//// 需要在堆底部增加一个元素，然后自底向上进行大小关系的比较和交换位置
    template<class T>
    void myHeapArray<T>::push_back(T val)
    {
        if (0 == (m_back - m_front + 1 + m_len) % m_len)////将要满了，扩容
        {
            T* p = new T[(int)(m_len * 1.2 + 1)];
            if (m_back >= m_front)/////正常模式，正常扩容，仅修改m_len即可
            {
                memcpy(p, m_ptr, sizeof(T) * m_len);
            }
            else////按照堆的安排方式，是不存在这种情况的，因为数组前面的位置不存在空出来的机会
            {
                memcpy(p, &(m_ptr[m_front]), sizeof(T) * (m_len - m_front));
                memcpy(&(p[m_len - m_front]), m_ptr, m_back);
                m_front = 0;
                m_back = (m_back - m_front) % m_len;
            }
            delete[] m_ptr;
            m_ptr = p;
            m_len = (int)(m_len * 1.2 + 1);
        }
        m_ptr[m_back] = val;
        m_back = m_back + 1;

        int curNode = m_back - 1;
        int parNode = (int)((m_front - 1 + curNode) / 2);
        while (parNode >= m_front)////还没有到达堆顶部
        {
            if (m_ptr[curNode] > m_ptr[parNode])////子节点的值比父节点的值大，需要交换
            {
                T tmp = m_ptr[curNode];
                m_ptr[curNode] = m_ptr[parNode];
                m_ptr[parNode] = tmp;

                curNode = parNode;
                parNode = (int)((m_front - 1 + curNode) / 2);
            }
            else////// 因为push的操作是在前面都遵循了一定的规范的，所以可以直接跳过
            {
                break;
            }
        }
    }

删除操作
删除操作的做法有点奇妙。因为删除操作是删除最上面的顶点，在删除之后，树会被分割成两棵树（如果存在两棵子树），不在便于维护，所以改为将最后的一个子节点移除出去，同时将其数值移动到顶点上面，这样保持了树的结构，还删除了一个顶点。但是，可以预见的是，现在这棵树已经不再满足是大根树的条件。需要对树进行“整理”。方法是从顶点开始，比较节点与子树（存在的话）的值大小，如果子树的数值大，那么就交换两个节点的数值，如果换下去之后的节点的数值仍旧比其子节点的数值小，则继续进行该操作知道满足父节点的数值大于子节点的数值，或者不存在子节点为止。
这里写图片描述
下面贴上从栈顶删除一个元素的代码

    ////从栈顶上删除一个元素
    //// 需要把堆底的元素挪到堆顶部，然后进行整理
    template<class T>
    T myHeapArray<T>::pop_front(void)
    {
        if(m_back == m_front)
        {
            throw("NoElmentToPop");
        }
        else
        {
            T val = m_ptr[m_front];
            ///// 其实没有必要取余数，利用数组进行堆管理不存在back到前面去的情况
            m_back = (m_len + m_back - 1) % m_len;///// 其实没有必要取余数，利用数组进行堆管理不存在back到前面去的情况
            ///// 把最后一个元素防止到最前面，覆盖掉，表示删除了顶部的元素
            m_ptr[m_front] = m_ptr[m_back];
            int curNode = m_front;
            int childNodeL = 2 * curNode - m_front + 1;
            int childNodeR = childNodeL + 1;
            int swapNode;
            int tmp;
            while (childNodeL < m_back)//////至少存在一个节点
            {
                if (childNodeR < m_back)/// 存在两个子节点
                {
                    ////// 至少存在一个子节点是大于父节点的，必然要进行交换
                    if (m_ptr[childNodeL] > m_ptr[curNode] || m_ptr[childNodeR] > m_ptr[curNode])
                    {
                        if (m_ptr[childNodeL] > m_ptr[childNodeR])
                        {
                            swapNode = childNodeL;
                        }
                        else
                        {
                            swapNode = childNodeR;
                        }
                    }
                    else//// 两个子节点都比父节点小，可以不继续交换了
                    {
                        break;
                    }
                }
                else////只存在一个左子节点
                {
                    if (m_ptr[curNode] < m_ptr[childNodeL])//// 子节点的数值比较大，需要进行交换
                    {
                        swapNode = childNodeL;
                    }
                    else//// 只有一个节点，而且节点大小也满足停止条件
                    {
                        break;
                    }
                }
                tmp = m_ptr[swapNode];
                m_ptr[swapNode] = m_ptr[curNode];
                m_ptr[curNode] = tmp;

                //// 更新位置
                curNode = swapNode;
                childNodeL = 2 * curNode - m_front + 1;
                childNodeR = childNodeL + 1;
            }
            return(val);
        }
    }

整理操作
整理操作是对一个没有大小关系的堆结构进行大小的定位，使堆结构能够具有大根或者小根的特点的操作。
下面的示意图是使用到的一些求节点的表达式：
这里写图片描述
下面是整理部分的代码，其实可以从整理的代码中可以看到，堆（也是完全二叉树，虽然在这里使用的是数组的管理方法，但是仍旧能够体现出树的递归的性质）。这部分的思考感觉在一些边缘条件上面还可以推敲，希望大家能留言多多指导

template<class T>
void myHeapArray<T>::sort(int pos)
{
    int curNode = pos;
    int childNodeL = 2 * curNode - m_front + 1;
    int childNodeR = childNodeL + 1;

    ////// 再次体现树结构的递归特点，虽然这里不是以树的的组织形式，而是数组的形式
    if (childNodeL < m_back)
    {
        sort(childNodeL);
    }
    if (childNodeR < m_back)
    {
        sort(childNodeR);
    }

    int swapNode;
    int tmp;
    while (childNodeL < m_back)//////至少存在一个节点
    {
        if (childNodeR < m_back)/// 存在两个子节点
        {
            ////// 至少存在一个子节点是大于父节点的，必然要进行交换
            if (m_ptr[childNodeL] > m_ptr[curNode] || m_ptr[childNodeR] > m_ptr[curNode])
            {
                if (m_ptr[childNodeL] > m_ptr[childNodeR])
                {
                    swapNode = childNodeL;
                }
                else
                {
                    swapNode = childNodeR;
                }
            }
            else//// 两个子节点都比父节点小，可以不继续交换了
            {
                break;
            }
        }
        else////只存在一个左子节点
        {
            if (m_ptr[curNode] < m_ptr[childNodeL])//// 子节点的数值比较大，需要进行交换
            {
                swapNode = childNodeL;
            }
            else//// 只有一个节点，而且节点大小也满足停止条件
            {
                break;
            }
        }
        tmp = m_ptr[swapNode];
        m_ptr[swapNode] = m_ptr[curNode];
        m_ptr[curNode] = tmp;

        //// 更新位置
        curNode = swapNode;
        childNodeL = 2 * curNode - m_front + 1;
        childNodeR = childNodeL + 1;
    }
}

构造操作
在写完上面的插入操作的时候，构造的操作也就变得简单了。既可以通过对数组逐个执行插入的操作来完成由数组到堆结构的构造，也可以由整理操作来完成堆结构的大小定位。
下面贴上构造中使用的sort函数代码（对一棵树进行整理，使其符合大根堆或小根堆的特点）

    template<class T>
    void myHeapArray<T>::sort(int pos)
    {
        int curNode = pos;
        int childNodeL = 2 * curNode - m_front + 1;
        int childNodeR = childNodeL + 1;

        ////// 再次体现树结构的递归特点，虽然这里不是以树的的组织形式，而是数组的形式
        if (childNodeL < m_back)
        {
            sort(childNodeL);
        }
        if (childNodeR < m_back)
        {
            sort(childNodeR);
        }

        int swapNode;
        int tmp;
        while (childNodeL < m_back)//////至少存在一个节点
        {
            if (childNodeR < m_back)/// 存在两个子节点
            {
                ////// 至少存在一个子节点是大于父节点的，必然要进行交换
                if (m_ptr[childNodeL] > m_ptr[curNode] || m_ptr[childNodeR] > m_ptr[curNode])
                {
                    if (m_ptr[childNodeL] > m_ptr[childNodeR])
                    {
                        swapNode = childNodeL;
                    }
                    else
                    {
                        swapNode = childNodeR;
                    }
                }
                else//// 两个子节点都比父节点小，可以不继续交换了
                {
                    break;
                }
            }
            else////只存在一个左子节点
            {
                if (m_ptr[curNode] < m_ptr[childNodeL])//// 子节点的数值比较大，需要进行交换
                {
                    swapNode = childNodeL;
                }
                else//// 只有一个节点，而且节点大小也满足停止条件
                {
                    break;
                }
            }
            tmp = m_ptr[swapNode];
            m_ptr[swapNode] = m_ptr[curNode];
            m_ptr[curNode] = tmp;

            //// 更新位置
            curNode = swapNode;
            childNodeL = 2 * curNode - m_front + 1;
            childNodeR = childNodeL + 1;
        }
    }

下图是使用构造方式获得的大根堆：
这里写图片描述
下面贴上完整的堆结构的模板类代码，以及完整的贴图

    #ifndef _H_MYHEAPARRAY_H
    #define _H_MYHEAPARRAY_H
    #include <iostream>

    template<class T>
    class myHeapArray;

    template<class T>
    class myHeapArray
    {
    public:
        myHeapArray(int len = 64);
        myHeapArray(const myHeapArray<T>& mqa);
        myHeapArray(T arr[], int len);
        ~myHeapArray();

        T pop_front(void);
        void push_back(T val);
        int size(void);
        bool full(void);
        bool empty(void);
        T top();
        myHeapArray<T>& operator=(myHeapArray<T>& mqa);
        void printAll(void);
    private:
        void sort(int pos);
    private:
        T* m_ptr;
        int m_front;
        int m_back;
        int m_len;
    };

     D E F I N I T I O N S /

    template<class T>
    myHeapArray<T>::myHeapArray(int len = 64)
    {
        std::cout<<"Constructor by Length"<<std::endl;
        m_front = 0;
        m_back = 0;
        if (len <= 0)
        {
            len = 16;
        }
        m_len = len;
        m_ptr = new T[m_len];
    }

    template<class T>
    myHeapArray<T>::myHeapArray(const myHeapArray<T>& mqa)
    {
        std::cout<<"Copy Constructor"<<std::endl;
        m_front = mqa.m_front;
        m_back = mqa.m_back;
        m_len = mqa.m_len;
        m_ptr = new T[m_len];
        memcpy(m_ptr, mqa.m_ptr, sizeof(T) * m_len);
        sort(m_front);
    }

    //template<class T>
    //myHeapArray<T>::myHeapArray(T arr[], int len)
    //{
    //  std::cout<<"Constructor by array"<<std::endl;
    //  m_front = 0;
    //  m_back = len;
    //  m_len = (int)(len * 1.2 + 1);
    //  m_ptr = new T[m_len];
    //  memcpy(m_ptr, arr, sizeof(T) * len);
    //  sort(m_front);
    //}

    /// 上面和下面的构造函数都可以，结果都符合大根堆的特点

    template<class T>
    myHeapArray<T>::myHeapArray(T arr[], int len)
    {
        std::cout<<"Constructor by array"<<std::endl;
        m_front = 0;
        m_back = 0;
        m_len = (int)(len * 1.2 + 1);
        m_ptr = new T[m_len];
        for (int ii = 0; ii < len; ii++)
        {
            push_back(arr[ii]);
        }
    }

    template<class T>
    myHeapArray<T>::~myHeapArray()
    {
        std::cout<<"Destructor"<<std::endl;
        if (NULL != m_ptr)
        {
            delete[] m_ptr;
        }
    }

    从栈顶上删除一个元素
     需要把堆底的元素挪到堆顶部，然后进行整理
    template<class T>
    T myHeapArray<T>::pop_front(void)
    {
        if(m_back == m_front)
        {
            throw("NoElmentToPop");
        }
        else
        {
            T val = m_ptr[m_front];
            / 其实没有必要取余数，利用数组进行堆管理不存在back到前面去的情况
            m_back = (m_len + m_back - 1) % m_len;/ 其实没有必要取余数，利用数组进行堆管理不存在back到前面去的情况
            / 把最后一个元素防止到最前面，覆盖掉，表示删除了顶部的元素
            m_ptr[m_front] = m_ptr[m_back];
            int curNode = m_front;
            int childNodeL = 2 * curNode - m_front + 1;
            int childNodeR = childNodeL + 1;
            int swapNode;
            int tmp;
            while (childNodeL < m_back)//至少存在一个节点
            {
                if (childNodeR < m_back)/// 存在两个子节点
                {
                    // 至少存在一个子节点是大于父节点的，必然要进行交换
                    if (m_ptr[childNodeL] > m_ptr[curNode] || m_ptr[childNodeR] > m_ptr[curNode])
                    {
                        if (m_ptr[childNodeL] > m_ptr[childNodeR])
                        {
                            swapNode = childNodeL;
                        }
                        else
                        {
                            swapNode = childNodeR;
                        }
                    }
                    else 两个子节点都比父节点小，可以不继续交换了
                    {
                        break;
                    }
                }
                else只存在一个左子节点
                {
                    if (m_ptr[curNode] < m_ptr[childNodeL]) 子节点的数值比较大，需要进行交换
                    {
                        swapNode = childNodeL;
                    }
                    else 只有一个节点，而且节点大小也满足停止条件
                    {
                        break;
                    }
                }
                tmp = m_ptr[swapNode];
                m_ptr[swapNode] = m_ptr[curNode];
                m_ptr[curNode] = tmp;

                 更新位置
                curNode = swapNode;
                childNodeL = 2 * curNode - m_front + 1;
                childNodeR = childNodeL + 1;
            }
            return(val);
        }
    }

    template<class T>
    void myHeapArray<T>::sort(int pos)
    {
        int curNode = pos;
        int childNodeL = 2 * curNode - m_front + 1;
        int childNodeR = childNodeL + 1;

        // 再次体现树结构的递归特点，虽然这里不是以树的的组织形式，而是数组的形式
        if (childNodeL < m_back)
        {
            sort(childNodeL);
        }
        if (childNodeR < m_back)
        {
            sort(childNodeR);
        }

        int swapNode;
        int tmp;
        while (childNodeL < m_back)//至少存在一个节点
        {
            if (childNodeR < m_back)/// 存在两个子节点
            {
                // 至少存在一个子节点是大于父节点的，必然要进行交换
                if (m_ptr[childNodeL] > m_ptr[curNode] || m_ptr[childNodeR] > m_ptr[curNode])
                {
                    if (m_ptr[childNodeL] > m_ptr[childNodeR])
                    {
                        swapNode = childNodeL;
                    }
                    else
                    {
                        swapNode = childNodeR;
                    }
                }
                else 两个子节点都比父节点小，可以不继续交换了
                {
                    break;
                }
            }
            else只存在一个左子节点
            {
                if (m_ptr[curNode] < m_ptr[childNodeL]) 子节点的数值比较大，需要进行交换
                {
                    swapNode = childNodeL;
                }
                else 只有一个节点，而且节点大小也满足停止条件
                {
                    break;
                }
            }
            tmp = m_ptr[swapNode];
            m_ptr[swapNode] = m_ptr[curNode];
            m_ptr[curNode] = tmp;

             更新位置
            curNode = swapNode;
            childNodeL = 2 * curNode - m_front + 1;
            childNodeR = childNodeL + 1;
        }
    }

     需要在堆底部增加一个元素，然后自底向上进行大小关系的比较和交换位置
    template<class T>
    void myHeapArray<T>::push_back(T val)
    {
        if (0 == (m_back - m_front + 1 + m_len) % m_len)将要满了，扩容
        {
            T* p = new T[(int)(m_len * 1.2 + 1)];
            if (m_back >= m_front)/正常模式，正常扩容，仅修改m_len即可
            {
                memcpy(p, m_ptr, sizeof(T) * m_len);
            }
            else按照堆的安排方式，是不存在这种情况的，因为数组前面的位置不存在空出来的机会
            {
                memcpy(p, &(m_ptr[m_front]), sizeof(T) * (m_len - m_front));
                memcpy(&(p[m_len - m_front]), m_ptr, m_back);
                m_front = 0;
                m_back = (m_back - m_front) % m_len;
            }
            delete[] m_ptr;
            m_ptr = p;
            m_len = (int)(m_len * 1.2 + 1);
        }
        m_ptr[m_back] = val;
        m_back = m_back + 1;

        int curNode = m_back - 1;
        int parNode = (int)((m_front - 1 + curNode) / 2);
        while (parNode >= m_front)还没有到达堆顶部
        {
            if (m_ptr[curNode] > m_ptr[parNode])子节点的值比父节点的值大，需要交换
            {
                T tmp = m_ptr[curNode];
                m_ptr[curNode] = m_ptr[parNode];
                m_ptr[parNode] = tmp;

                curNode = parNode;
                parNode = (int)((m_front - 1 + curNode) / 2);
            }
            else// 因为push的操作是在前面都遵循了一定的规范的，所以可以直接跳过
            {
                break;
            }
        }
    }

    template<class T>
    int myHeapArray<T>::size(void)
    {
        return((m_back - m_front + 1 + m_len) % m_len);
    }

    template<class T>
    bool myHeapArray<T>::full(void)
    {
        return(0 == (m_back - m_front + 1 + m_len) % m_len);
    }

    template<class T>
    bool myHeapArray<T>::empty(void)
    {
        return(m_back == m_front);
    }

    template<class T>
    T myHeapArray<T>::top()
    {
        if (m_front != m_back)
        {
            return(m_ptr[m_front]);
        }
        else
        {
            throw("NoElement");
        }
    }

    template<class T>
    myHeapArray<T>& myHeapArray<T>::operator=(myHeapArray<T>& mqa)
    {
        std::cout<<"OverLoad Operator"<<std::endl;
        if (this != &mqa)
        {
            m_len = mqa.m_len;
            m_front = mqa.m_front;
            m_back = mqa.m_back;
            delete[] m_ptr;
            m_ptr = new T[m_len];
            memcpy(m_ptr, mqa.m_ptr, sizeof(T) * m_len);
            sort(m_front);
        }
        return(*this);
    }

    template<class T>
    void myHeapArray<T>::printAll(void)
    {
        std::cout<<std::endl;
        for (int ii = m_front; ii < m_back; ii++)
        {
            std::cout<<"\t"<<m_ptr[ii];
        }
        std::cout<<std::endl;
    }
    #endif

下图是思考过程中使用的一张插图：
思考过程中使用到的插图---完整版

u012925231
关注
专栏目录
什么是二叉堆
小枫哥的博客
02-03 772
二叉堆是一种完全二叉树，有两种类型：最大堆（大根堆）、最小堆（小根堆） 二叉堆是堆排序和优先队列的基础数据结构 名词概念 最大堆：父节点比子节点大或相等的二叉堆 最小堆：父节点比子节点小或相等的二叉堆 堆顶：二叉堆的根节点就是堆顶，最小堆的根节点是最小值，最大堆的根节点是最大值 二叉堆的存储方式 二叉堆虽然是一颗完全二叉树，但是它并不是采用链式存储，而是采用顺序存储 也就是说，二叉树的存储...
【数据结构】 拿捏二叉树堆排序与遍历
qq_61386381的博客
07-29 1445
二叉树的存储结构 二叉树的堆排序 堆的概念 堆向上调整算法 堆向下调整算法 堆排序应用之TopK问题 二叉树的遍历 链式二叉树 创建二叉树 二叉树的遍历 前序遍历 中序遍历 后续遍历 层序遍历 ............
堆是什么？是一种特殊的完全二叉树
gly的博客
08-23 3767
堆： 堆是为了实现排序而设计的一种数据结构，它不是面向查找操作的 堆是什么？是一种特殊的完全二叉树 这棵二叉树有一个特点，就是所有父结点都比子结点要小 符合这样特点的完全二叉树我们称为最小堆。 反之，如果所有父结点都比子结点要大，这样的完全二叉树称为最大堆 假如有14个数分别是99、5、36、7、22、17、46、12、2、19、25、28、1和92。 请找出这14个数中最小的数，请问怎么办呢？...
Dijkstra算法详解（附代码）
最新发布
tecoes的博客
09-18 327
1、从图中的某个顶点出发到达另外一个顶点的所经过的边的权重和最小的一条路径，称为最短路径。
数组实现完全二叉树(大根堆)
qq_39045241的博客
10-14 1306
public class AvlTree { /* * 堆结构就是用数组实现的完全二叉树结构 * 完全二叉树中如果每棵子树的最大值都在顶部就是大根堆 * 完全二叉树中如果每棵子树的最小值都在顶部就是小根堆 * 优先级队列结构就是堆结构 * * 数组实现完全二叉树(大根堆) * 数组从1开始存储 [null,9,5,6,4,3] * 父:i 左子节点:2*i 右子节点:2*i+1 */ int[] ar...
堆排––以大根堆为例(二叉树思路)
m0_69724592的博客
12-10 363
大根堆方式进行排序
判断完全二叉树是不是一个堆
weixin_34026484的博客
12-10 1218
完全二叉树适合用数组存储，而且从第二个位置及a[1]开始存储，这样对于一个节点i，它的左子树和右子树就分别为i*2和i*2+1。 对于一个完全二叉树存储的树结构，可以用如下方法来它是不是一个堆。 方法1： bool isMinHeap(int root){ if(root*2>n) return true;//叶节点 if(root*2<=n&&roo...
STL_quene.rar_crowd7oc_优先队列 堆_大根堆_大根对 c++_小根堆
09-24
堆通常是一个完全二叉树，其中每个父节点的值都大于或等于其子节点的值（大根堆），或者小于或等于其子节点的值（小根堆）。这种特性使得堆的根节点始终是最大值或最小值，因此非常适合用于优先队列的实现。 C++的...
c++ 大根堆和小根堆
01-14
总之，C++的大根堆和小根堆是通过数组实现的，利用了完全二叉树的特性以及堆的定义来确保数据的排列。堆排序利用堆的性质对数据进行排序，效率高且空间复杂度低。通过学习和实践这些概念，你可以在解决各种问题时...
数据结构—堆 大根堆 小根堆 STL实现
up_up_up_的博客
05-09 1109
我是真的不会 优先队列创建小根堆的遍历，所以我就通过调试的方法，给大家展示了。
【数据结构】堆，大根堆，小根堆，优先队列 详解
热门推荐
繁凡さん的博客
02-24 1万+
堆 要了解堆之前,请先了解树,因为堆是一颗完全二叉树 如果不知道的话请点击下方链接了解 树,二叉树,完全二叉树详解 要注意的是 首先堆是一颗完全二叉树 其次堆中存储的值是偏序 Min-heap(小根堆): 父节点的值小于或等于子节点的值 Max-heap(大根堆): 父节点的值大于或等于子节点的值 好吧其实就是实现自动排序 O（logn）时间复杂度内实现插入，删除，O（1）查询 1....
关于满二叉树、完全二叉树以及完全二叉树的大根堆小根堆
飞奔的WSL-WLL
03-20 1472
满二叉树 完全二叉树的定义 满二叉树就是每一层节点个数都是满的二叉树。第n层节点个数 = pow（2，n - 1）， 总的节点个数 = pow（2， n）。 完全二叉树就是满二叉树从最后一层的最右侧开始去节点得的树，这个去节点只能从右往左去。 满二叉树 完全二叉树 关于完全二叉树的几个面试题目一：判断是不是完全二叉树 思路：层次遍历：当前节点左子树不空放入queu...
二叉树大(小)堆以及堆排序
a331683772的博客
05-25 421
#pragma once #include "assert.h" #include <stdio.h> #include<stdlib.h> typedef int HPDataType; typedef struct Heap { HPDataType* _array; int _capacity; int _size; }; // 用数组初始化堆 void ...
堆排序-大根堆
weixin_43157935的博客
02-28 3459
#include<stdio.h> #include<stdlib.h> // 大根堆-堆排序 void get_heap_max(int *arr, int length) { //每执行一次最大值都在放置在数组首位 int child, parent; for (int i = length - 1; i > 0; i--) { child = i, p...
图文最详细的堆解析：从二叉树到堆到解析大根堆小根堆，分析堆排序，最后实现topK经典面试问题
尚墨1111的博客
07-10 2051
堆1 数据结构——堆 Heap1.0 树1.1堆1.1.1 什么是堆1.1.2 堆的常用方法：1.2 数组构造大根堆1.2.1 节点与数组索引的对应关系1.2.2 实际样例1.3 Java实现1.3.1 自下往上法1.3.2 堆的相关操作1.4 堆排序1.4 优先队列`PriorityQueue`1.4.1 什么是优先级队列1.4.2 自定义排序和Lambda回顾1.4.3 源码分析2 面试经典TopK问题2.1 题目列表：2.2 TopK小2.2.1 基于快排找topk小2.2.2 大根堆法找topk小
【算法】构造数组的MaxTree，构建大根树
清凌的博客
04-02 786
【算法】构造数组的MaxTree，构建大根树
构造大根树 Maximum Binary Tree
weixin_34387468的博客
01-13 205
为什么80%的码农都做不了架构师？>>> ...
数据结构学习——大根堆
qq_18873031的博客
12-21 1万+
大根堆就是其中每个节点的值都大于或等于其子节点。 大根堆既是大根树又是完全二叉树。 像下图这样： 大根堆的类中的数据成员是，heap数组（一个类型为T的一维数组），arrayLength（数组heap的容量），heapSize（堆的元素个数） 以下是大根堆的插入函数： //插入函数 template<class T> void maxHeap<T>::push(const...
【数据结构】大根堆和左高树
stuXuan的博客
10-18 452
树中的每一个节点的值都大于或等于其子节点的值既是大根树又是完全二叉树（增加了完全二叉树的限制条件）所以下图中只有(a)和(c)是大根堆。
C++ STL实现大根堆与小根堆高效优先队列
堆是一种特殊的完全二叉树，它满足所有父节点的值均不小于（在大根堆中）或不大于（在小根堆中）其子节点的值。这种属性被用来在O(1)的时间内获取最大或最小的元素。在大根堆中，任何一个父节点的值都大于或等于其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值