堆及其算法

SGI STL:heap排序的adjust函数 SGI STL:heap排序中adjust函数 本文不介绍具体的heap排序算法,阅读之前请先熟悉STL heap排序的逻辑。本文讨论的是SGI-STL源码中__adjust_heap函数中的一个细节。先展示源码。 // 实际执行的push函数: template <class _RandomAccessIterator, class _Distance, class _Tp> void __push_heap(_RandomAccessIterator __first, 阅读详情

       堆一般是一种隐式表述(implicit representation),简单的说堆是由另外一种容器实现的。由于堆中的操作都基于搜寻父节点,子节点。如果用数组的话,那么不需要额外的存储空间就可以轻松实现。左子节点标号=父节点标号*2+1;右子节点标号=父节点标号*2+2;父节点标号=(子节点标号-1)/2。如果在用一种小技巧,将标号0处元素保留(或设为无限大(小)值),从而忽略根节点的话,计算式将改为左子节点标号 = 父节点标号*2;右子节点标号 = 父节点标号*2+1;父节点标号 = 子节点标号/2。另外堆要求数组长度动态,所以用vector实现。

 

       接下来分析最大堆的各种操作(最小堆类似)。理解了上溯和下溯基本堆的操作都可以理解了。

 

push_heap()是在一个最大堆中插入元素,元素先插在最尾端,然后进行上溯。所以复杂度为O(lgn)

 

__adjust_heap()这个函数维持最大堆的性质,进行下溯就可以了,而STL中不知道为什么最终的赋值采用了插入操作再做一次上溯。但不管怎么样复杂度为O(lgn)。但是这里还有个问题,为什么只进行下溯就可以了?因为__adjust_heap()是个内部函数,客户端无法调用,看下面其他函数调用__adjust_heap()

的时刻就清楚了。

 

pop_heap()弹出最大元素,实现的方式就是先保存尾元素值,然后根节点值赋给尾元素,根变为一个洞然后洞号和值(尾值)都有了,调用__adjust_heap()重整堆,这里必然是下溯,符合__adjust_heap()算法。所以复杂度为O(lgn)。注意pop_heap()只是移动元素,并不弹出,要继续调用vector::push_back()。

 

make_heap()建堆是在未排序的数组上进行的,由最后一个非叶子节点开始,循环调用__adjust_heap()此时是往上循环的,所以只要进行下溯,符合__adjust_heap()算法。这里要分析make_heap()的复杂度,简单地想线性元素个数调用__adjust_heap()复杂度因为O(nlgn)。这是一个上界,但是不够精确,因为调用__adjust_heap()的节点高度不一样。这里要提到一个小性质:一个n元素堆的高度为lgn,在任意高度h上,至多有n/(2^h+1)(取上界)个节点。那么复杂度为n/(2^h+1)O(h)在0至lgn间求和,最终得O(n)。

 

sort_heap()很简单,从头至尾循环调用pop_heap(),复杂度O(nlgn)。

  

   以下见STL源码,分析已有详细注释。

//以下这组 push_heap()不允许指定“大小比较标准”
template <class RandomAccessIterator>
inline void push_heap(RandomAccessIterator first, RandomAccessIterator last) {
  // 注意!!!此函数调用的时候,元素以至于容器尾端。
  __push_heap_aux(first, last, distance_type(first), value_type(first));
}

template <class RandomAccessIterator, class Distance, class T>
inline void __push_heap_aux(RandomAccessIterator first,
                            RandomAccessIterator last, Distance*, T*) {
  __push_heap(first, Distance((last - first) - 1), Distance(0), 
              T(*(last - 1)));
  // 以上根据 implicit representation heap 的结构特性:新值必至于底层
  // 容器的最尾端,此即第一个洞号:(last-first)–1。
}

template <class RandomAccessIterator, class Distance, class T>
void __push_heap(RandomAccessIterator first, Distance holeIndex,
                 Distance topIndex, T value) {
  Distance parent = (holeIndex - 1) / 2;	// 父节点标号
  while (holeIndex > topIndex && *(first + parent) < value) {
    // 尚未到达顶端且父节点值小于新值(这不符合最大堆的特性)
    // 由于以上使用 operator<,可知 STL heap 是一种max-heap
    *(first + holeIndex) = *(first + parent);	
    holeIndex = parent; // 上溯:父节点标号为洞号
    parent = (holeIndex - 1) / 2;	// 新洞的父节点标号
  }    // 持续至顶端或满足最大堆特性为止。
  *(first + holeIndex) = value;	// 另洞值为新值,完成拆入操作。
}

// 以下这组 push_heap()允许指定“大小比较标准”
template <class RandomAccessIterator, class Compare>
inline void push_heap(RandomAccessIterator first, RandomAccessIterator last,
                      Compare comp) {
  __push_heap_aux(first, last, comp, distance_type(first), value_type(first));
}

template <class RandomAccessIterator, class Compare, class Distance, class T>
inline void __push_heap_aux(RandomAccessIterator first,
                            RandomAccessIterator last, Compare comp,
                            Distance*, T*) {
  __push_heap(first, Distance((last - first) - 1), Distance(0), 
              T(*(last - 1)), comp);
}

template <class RandomAccessIterator, class Distance, class T, class Compare>
void __push_heap(RandomAccessIterator first, Distance holeIndex,
                 Distance topIndex, T value, Compare comp) {
  Distance parent = (holeIndex - 1) / 2;
  while (holeIndex > topIndex && comp(*(first + parent), value)) {
    *(first + holeIndex) = *(first + parent);
    holeIndex = parent;
    parent = (holeIndex - 1) / 2;
  }
  *(first + holeIndex) = value;
}



// 以下这个 __adjust_heap()不允许指定“大小比较标准”
template <class RandomAccessIterator, class Distance, class T>
void __adjust_heap(RandomAccessIterator first, Distance holeIndex,
                   Distance len, T value) {
  Distance topIndex = holeIndex;
  Distance secondChild = 2 * holeIndex + 2;// 洞节点右子节点标号
  while (secondChild < len) {
    // 比较洞节点的左右子节点值,选出较大子节点
    if (*(first + secondChild) < *(first + (secondChild - 1)))
      secondChild--; //左子结点大,洞号为左子结点标号
    // Percolate down:另较大值为洞值,再令洞号下移为较大值标号
    *(first + holeIndex) = *(first + secondChild);  
    holeIndex = secondChild;
    // 找出新洞结点的右子节点
    secondChild = 2 * (secondChild + 1);
  }
if (secondChild == len) { // 因为secondChild为标号,而标号等于长度的话
  //那么就是该洞节点无右子结点但有左子结点
    // Percolate down
    *(first + holeIndex) = *(first + (secondChild - 1));
    holeIndex = secondChild - 1;
  }
// 将欲调整值填入洞号内。
//!!!!!!注意,此时肯定满足次序特性。
//下面直接改为 *(first + holeIndex) = value; 应该可以。
//这里__push_heap的话还要进行一次上溯
  __push_heap(first, holeIndex, topIndex, value);
}

// 以下这个 __adjust_heap()允许指定“大小比较标准”
template <class RandomAccessIterator, class Distance, class T, class Compare>
void __adjust_heap(RandomAccessIterator first, Distance holeIndex,
                   Distance len, T value, Compare comp) {
  Distance topIndex = holeIndex;
  Distance secondChild = 2 * holeIndex + 2;
  while (secondChild < len) {
    if (comp(*(first + secondChild), *(first + (secondChild - 1))))
      secondChild--;
    *(first + holeIndex) = *(first + secondChild);
    holeIndex = secondChild;
    secondChild = 2 * (secondChild + 1);
  }
  if (secondChild == len) {
    *(first + holeIndex) = *(first + (secondChild - 1));
    holeIndex = secondChild - 1;
  }
  __push_heap(first, holeIndex, topIndex, value, comp);
}
// 以下这组pop_heap()不允许指定“大小比较标准”
template <class RandomAccessIterator>
inline void pop_heap(RandomAccessIterator first, RandomAccessIterator last) {
  __pop_heap_aux(first, last, value_type(first));
}

template <class RandomAccessIterator, class T>
inline void __pop_heap_aux(RandomAccessIterator first,
                           RandomAccessIterator last, T*) {
  __pop_heap(first, last-1, last-1, T(*(last-1)), distance_type(first));
  // 以上,根据 implicit representation heap 的次序特性,pop动作的结果
  // 应为底层容器的第一个值(标号0的根节点)。因此,首先设定欲调整的值是尾值,然後將首值调至
// 尾节点(所以以上将迭代器result设为last-1)。然后重整 [first, last-1)。这里有个细节
// 因为最后要重整,需要传入重整节点值,第四个参数,生成了一个原堆尾节点值的临时变量!!
}

template <class RandomAccessIterator, class T, class Distance>
inline void __pop_heap(RandomAccessIterator first, RandomAccessIterator last,
                       RandomAccessIterator result, T value, Distance*) {
  *result = *first; //设定尾值为根节点值,即为欲求结果
// pop_heap是没有返回值的。之后可由客户端以底层容器的pop_back() 取出尾值。
  __adjust_heap(first, Distance(0), Distance(last - first), value);
  // 以上重新调整 heap,洞号为 0(根节点),欲调整值为value(原尾值)。
}


// 以下这组 __pop_heap()允许指定“大小比较标准”
template <class RandomAccessIterator, class T, class Compare, class Distance>
inline void __pop_heap(RandomAccessIterator first, RandomAccessIterator last,
                       RandomAccessIterator result, T value, Compare comp,
                       Distance*) {
  *result = *first;
  __adjust_heap(first, Distance(0), Distance(last - first), value, comp);
}

template <class RandomAccessIterator, class T, class Compare>
inline void __pop_heap_aux(RandomAccessIterator first,
                           RandomAccessIterator last, T*, Compare comp) {
  __pop_heap(first, last - 1, last - 1, T(*(last - 1)), comp,
             distance_type(first));
}

template <class RandomAccessIterator, class Compare>
inline void pop_heap(RandomAccessIterator first, RandomAccessIterator last,
                     Compare comp) {
    __pop_heap_aux(first, last, value_type(first), comp);
}

// 以下这组 make_heap()不允许指定“大小比较标准”。
// 将 [first,last) 排列为一个max-heap。
template <class RandomAccessIterator>
inline void make_heap(RandomAccessIterator first, RandomAccessIterator last) {
  __make_heap(first, last, value_type(first), distance_type(first));
}

template <class RandomAccessIterator, class T, class Distance>
void __make_heap(RandomAccessIterator first, RandomAccessIterator last, T*,
                 Distance*) {
  if (last - first < 2) return;	// 如果長度為 0 或 1,不必重新排列。
  Distance len = last - first;
//找出第一個需要重排的子樹頭部,以 parent 標示出。
//由于任何叶子节点都不需执行下溯
  //所以有以下计算,parent 命名不佳,名为 holeIndex 更好。
  Distance parent = (len - 2)/2; 
//为什么是这个算式??由于STL中第一个节点的标号为0,所以求节点的父节点算式为(n-1)/2,
//而这里len为长度,len-1是最后一个叶子节点的标号。
  while (true) {
    // 重排以parent为首的子树。len 是为了让 __adjust_heap() 判断操作范围
    __adjust_heap(first, parent, len, T(*(first + parent)));
    if (parent == 0) return;	// 走完根节点,就结束。
    parent--;					
  }
}


// 以下这组 make_heap()允许指定“大小比较标准”。
template <class RandomAccessIterator, class Compare>
inline void make_heap(RandomAccessIterator first, RandomAccessIterator last,
                      Compare comp) {
  __make_heap(first, last, comp, value_type(first), distance_type(first));
}

template <class RandomAccessIterator, class Compare, class T, class Distance>
void __make_heap(RandomAccessIterator first, RandomAccessIterator last,
                 Compare comp, T*, Distance*) {
  if (last - first < 2) return;       
  Distance len = last - first;
  Distance parent = (len - 2)/2;
    
  while (true) {
    __adjust_heap(first, parent, len, T(*(first + parent)), comp);
    if (parent == 0) return;
    parent--;
  }
}


// 以下这个 sort_heap()不允许指定“大小比较标准”
template <class RandomAccessIterator>
void sort_heap(RandomAccessIterator first, RandomAccessIterator last) {
  // 以下,每执行一次 pop_heap(),极值(在STL heap中为极大值)即被放在尾端。
  // 扣除尾端再执行一次 pop_heap(),次极值又被放在新尾端。一直下去,最后即得
  // 排序结果。
  while (last - first > 1)
     pop_heap(first, last--); // 每执行 pop_heap() 一次,操作范围即退缩一格。
}

// 以下这个 sort_heap()允许指定“大小比较标准”
template <class RandomAccessIterator, class Compare>
void sort_heap(RandomAccessIterator first, RandomAccessIterator last,
               Compare comp) {
  while (last - first > 1)
     pop_heap(first, last--, comp);
}


 

Dijkstra算法及其堆优化代码详解 迪杰斯特拉算法解决的是带权重的有向图上单源最短路径问题,该算法要求所有边的权重都为非负值,其在运行过程中维持的关键信息是一组节点集合S。算法重复从结点集V-S中选择最短路径估计最小的结点u,将u加入到集合S,然后对所有从u发生的边进行松弛,运行结束后,从源节点到集合S中每个结点之间的最短路径已经被找到。 下面,通过一个实例讲解该过程! 1 实例讲解 如图,是一个有向无环图。 2 代码详解 在以... 阅读详情

相关推荐

Dijkstra算法介绍及其优先队列优化和斐波那契堆优化

Dijkstra算法介绍及其优先队列优化和斐波那契堆优化 文章目录一、dijkstra算法概述二、实现dijkstra算法需要掌握的算法知识1、从数据中剔除最小项(函数ExtractMin())2、松弛操作3、伪代码分析三、最小优先队列概述四、最小优先队列伪代码分析1.维护堆的性质2.建堆3.剔除最小节点:4.关键字减值(松弛操作,具体实现中将此函数命名为relax())五、例题分析1. 首先设法存储输入的数据2. 设计最小优先队列3.实现Dijkstra算法(限于题目要求,略显臃肿):4.与优先队列

qq_33903332的博客 5913

堆排序-浅见

一直以来都不敢去学习了解堆排序,无形中自己产生对该算法的畏惧心理。今天有幸弄通,特来祭奠!看来世事,只要敢行,就一定行! 概述 堆排序使用数据结构中的堆结构,通过建立堆,然后循环调整堆,完成排序过程。 基础 首先要了解完全二叉树的概念,将堆分为大根堆和小根堆。大根堆用于维护非降序序列(也就是升序排列)。 对于完全二叉树必须记住的一个口诀:

meiyuli的专栏 997

用Python实现倾斜堆算法及其完整源代码

倾斜堆是由一组二叉树节点组成的森林,每个节点包含一个关键字值和两个子节点,其中左子树的关键字值不大于右子树的关键字值。具体实现上,我们使用递归的方式对左右子树进行交换并合并,最终得到一个新的倾斜堆。倾斜堆(Skew Heap)是一种基于二叉树的堆数据结构,能够支持常见的堆操作,如插入元素、删除最小元素等。然后,我们可以实现删除最小元素操作。由于倾斜堆的左右子树都是规模相同或相差1的,所以我们只需要交换左右子树即可完成删除最小元素的操作。将上述代码放在一起,就是完整的Python实现倾斜堆算法的代码了。

学习使你进步。 179

学习堆小结

学习堆小结 个人信息:就读于燕大本科软件工程专业 目前大三; 本人博客:百度搜索“cqs_2012”即可; 个人爱好:酷爱数据结构和算法,希望将来搞科研为人民作出自己的贡献; 博客内容:数据结构里的堆(大顶堆或小顶堆; 知识选自:个人对堆长时间的理解和应用,故总结与此;   引言 学过堆排序以后,但是一直没对堆没有认真的总结过,知识点很散,理解不够深刻,相信这一

cqs_2012 1264

堆数据结构在优先队列中的应用及其对算法效率的影响

本章节详细介绍了堆数据结构在优先队列中的应用,包括最大堆和最小堆的概念、堆的选择操作以及如何通过堆实现有效的排序算法。通过对堆操作复杂度的分析,探讨了堆数据结构在解决特定问题(如分数背包问题)中的优势,以及它如何简化贪心算法的实现并可能提高其实用效率。

weixin_42590539的博客 446

大模型量化技术全解析:从INT8到GPTQ/AWQ,降低部署成本实战指南

模型量化是一种通过降低神经网络权重和激活值的数据精度(如从FP16降至INT8/INT4),从而大幅减少模型内存占用和计算开销的核心模型压缩技术。其原理基于线性变换,将高精度浮点数映射到低精度整数表示,在硬件层面能利用专用低精度计算单元实现显著加速。这项技术的核心价值在于解决了大模型(如千亿参数LLM)部署时面临的高昂显存成本和推理延迟问题,使其能在消费级GPU和边缘设备上高效运行。当前,后训练量化(PTQ)因其无需重新训练的特性成为主流,衍生出GPTQ、AWQ、SmoothQuant等多种方法,广泛应用于

weixin_33804582的博客 635

STL算法_heap算法篇

STL算法_heap算法篇 堆简介二叉堆是一种完全二叉树,即整棵二叉树中除了最底层的叶子节点之外,其余节点是填满的,而最底层的叶子节点由左到右也是填满的不能存在空隙。堆主要包括两类:大顶堆和小顶堆。大顶堆指每个节点的键值(key)都大于或等于其叶子节点的键值,而小顶堆指每个节点键值都小于等于其节点的键值。STL中堆主要使用vector/array实现的。大顶堆的最大值在根节点,故其总是位于底层的ve

没有最好,只有更好! 1683

WSL2不能上网,Failed to connect to github.com port 443问题解决方案

WSL2不能上网: 问题:ping外网无效 例如:ping www.baidu.com失败 解决方案: 在wsl: $sudo vi /etc/wsl.conf wsl.conf: [network] generateResolvConf = false 在PowerShell: $sudo vi /etc/etc/resolv.conf resolv.conf: # This file was automatically generated by WSL. To stop automatic gen

Jason_Chen__的博客 9528

STL heap部分源码分析

本文假设你已对堆排序的算法有基本的了解。 要分析stl中heap的源码的独到之处,最好的办法就是拿普通的代码进行比较。话不多说,先看一段普通的堆排序的代码:

poi7777的专栏 754

pdf.js 移动端手势缩放功能实现与原生事件集成

本文详细解析了如何为pdf.js的viewer.html移动端页面实现流畅的双指捏合手势缩放功能。通过深入分析pdf.js的缩放机制,并利用原生触摸事件(touchstart、touchmove、touchend)进行集成,在不修改核心源码的前提下,为用户提供媲美原生应用的顺滑缩放体验,有效提升了移动端PDF阅读的专业性和用户满意度。

brandy的博客 490

通信原理 | 随机数仿真 | 均匀、正态、双高斯、瑞利、莱斯、对数正态、nakagami、Suzuki分布的随机数仿真(matlab)

信道建模在通信系统设计和分析中扮演着至关重要的角色。它指的是使用数学和物理模型来描述和模拟无线或有线通信路径中的信号传播特性。

若北辰 1991

dijkstra算法及其堆优化

dijkstra算法及其堆优化 (个人笔记写给自己看的) 数据结构:链式前向星,优先队列 dijkstra算法: vis数组初始化为0,dis数组初始化为inf(很大的值如:0x7fffffff),设起点为s,则d[s]=0,vis[s]=1 for循环n次以下步骤: for循环遍历d数组,找出最小的d[u],for循环结束。 for循环遍历u的邻接点v d[v]=min(d[v],d[u]+e[i].weight(为u到v的权重)); dijkstra堆优化: dis数组初始化为inf,设起点为s,

weixin_43901337的博客 1739

2023年03月CCF-GESP编程能力等级认证Scratch图形化编程一级真题解析

以下不属于计算机输入设备的有( )?A:键盘B:音响C:鼠标D:传感器。

人生就是一个不断学习的过程 1113

Dijkstra算法及其堆优化

欢迎来到NOIP考前复习系列。。。。。。 Dijkstra算法用于解决单源最短路问题,即求取从一个给定的起点出发到其他节点的最短距离。

不写博客 2万+

cursor AI代码编辑器IDE对接deepseek模型api;字节ai编辑器trae

参考: https://www.cursor.com/ https://platform.deepseek.com/https://www.cursor.com/下载安装后,注册账号登录即可 再高级里选择设置 再模型这注册模型: 模型名称一定要填正确,url地址填好,最后填上秘钥验证

weixin_42357472的博客 1万+

OpenClaw 开机自启配置:Windows/macOS/Linux 全平台技术指南

OpenClaw 开机自启全平台配置指南 本文提供了在Windows、macOS和Linux系统上配置OpenClaw开机自启的完整技术方案。主要内容包括: Windows配置:提供三种方法(Windows服务、任务计划程序、启动文件夹),详细说明服务脚本创建、服务注册和测试流程 macOS配置:使用LaunchAgent实现开机自启,包含配置文件创建和加载方法 Linux配置:通过systemd服务实现,包括服务单元文件创建和启用步骤 系统要求:明确硬件(64位CPU/4GB内存)和软件(各平台操作系统版

一键难忘的博客 2995

【智能算法】堆优化算法原理及其 MATLAB 实现

本文介绍了堆优化算法及其在MATLAB中的实现与应用。文章首先阐述了堆数据结构的基本原理,包括大根堆和小根堆的特性,以及堆优化算法的核心思路和优势。随后详细讲解了在MATLAB中实现堆优化Dijkstra算法的步骤,包括图的表示、最小堆的实现和算法核心流程。通过地图导航的实际案例,展示了堆优化算法在最短路径规划中的高效应用,并分析了其时间复杂度优势和局限性。最后,文章总结了堆优化算法的重要价值,并展望了其未来在人工智能、大数据处理等领域的应用前景。堆优化算法凭借其高效的性能,为解决复杂优化问题提供了有力工具

大雨淅淅的博客 923

美军利用MANET技术实现无人作战单元协同作战

本文首先介绍了移动自组织网络 (MANET)以及Wave Relay®波形中继技术,并探讨了波形中继MANET平台在美空军ABMS项目等军事方面的运用情况。

guanyifu9的博客 859

【智能算法】堆优化算法原理及其Python实现

堆优化算法是一种基于堆数据结构的优化算法,通过利用堆的特性(最大堆或最小堆)来提升传统算法的性能。其核心思想是将数据存储在堆结构中,以便快速获取极值元素,从而显著降低时间复杂度。在Dijkstra算法等图论问题中,堆优化可将时间复杂度从O(n²)降至O((m+n)logn),极大提升大规模数据处理的效率。Python中可通过heapq库实现堆操作,支持高效的元素插入、删除和极值查找。该算法广泛应用于最短路径计算、任务调度和大数据处理等领域,但实现复杂度较高,需根据具体场景权衡其优势与局限。未来在人工智能、物

大雨淅淅的博客 1947

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

【数据结构与算法】之堆及其实现!

},把它的所有元素按完全二叉树的顺序存储方式存储 在一个一维数组中,并满足: 且 = 且 >= ) i = 0,1, 2…将根节点最大的堆叫做最大堆或大根堆,根节点最小的堆叫做最小堆或小根堆。下面我们给出一个数组,这个数组逻辑上可以看做一颗完全二叉树,但是还不是一个堆,现在我们通过算 法,把它构建成一个堆。这里我们从倒数的第一个非叶子节点的 子树开始调整,一直调整到根节点的树,就可以调整成堆。删除堆是删除堆顶的数据,将堆顶的数据根最后一个数据一换,然后删除数组最后一个数据,再进行向下调 整算法。

2301_80221228的博客 1362

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

【纵横数据结构与算法】 堆及其堆的应用

堆,堆排序,TOPK

AF_帆的技术成长日记 249

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

初阶数据结构——初识二叉树及其应用——堆——及其向下向上调整算法

????????想快速入门数据结构,推荐订阅作者的初阶数据结构专栏!此专栏预计更新:顺序表,链表,栈,队列,二叉树,排序算法等等 ????????初阶数据结构我们通过c语言实现,所以此专栏也可以帮助大家巩固大家的c语言知识 ????????源代码已上传至我的码云 前言 二叉树算是初阶数据结构的一个新坑吧,不仅仅是因为难度比前面的数据结构提升了一个档次,而且这也是我们学的第一种非线性结构 我们在前面学的数据结构,无论是顺序表还是链表,不管它们在物理中的存储方式如何,它们的逻辑一定是串在一起的。 但是

dtxew love c++ 2740

迪杰斯特拉算法及其堆优化

迪杰斯特拉算法及其堆优化 迪杰斯特拉算法是一种求解图的单点最短路径的算法。 迪杰斯特拉算法的原理是 1.首先在没有中间节点的情况下,也就是直达路径中找到到达某点p的最短路径。易知,该路径一定是原点到点p的最短路径。将点p标记在vis数组中,并将最短路径的值存在dist数组中。 2.再对所有节点进行松弛操作,也就是下一个节点的最短路径有两种情况,一种是经过某个已知的最短路(就是被vis标记的最短路径),第二种情况是直达。所以,求解下一个最短路径就是求解递推公式 dist[i]=min(dist[i] , ma

qq_41729237的博客 4747

【图论——第四讲】dijkstra算法求单源最短路及其堆优化

算法图论题总关于dijkstra算法求单源最短路即其堆优化 文章目录一、前言二、朴素dijkstra算法三、堆优化版dijkstra最后 一、前言 单源最短路,指的是求一个点,到其他所有点的最短距离。(起点是固定的,单一的) 根据是否存在权重为负数的边,又分为两种情况 所有边的权重都是正数 通常有两种算法 朴素Dijkstra 时间复杂度O(n2),其中n是图中点的个数,m是边的个数 堆优化版的Dijkstra 时间复杂度O(mlogn) 两者孰优孰劣,取决于.

m0_63233163的博客 1791

单源最短路问题(1)—朴素Dijkstra算法及其堆优化

常见的最短路问题分为两类:单源最短路(从一个点到其他所有点)、多源汇最短路(任意两点) 1、在单源最短路问题中,若所有的边都是非负数,使用Dijkstra算法;若存在负权边,那么可以使用Bellman-Ford算法,SPFA是对前者优化。关于算法原理的介绍有很多,这里不再详述。 (1)朴素Dijkstra算法,时间复杂度O(n ^ 2),通常在稠密图的时候使用(边的数量级大概为点的数量级的平方...

LFT24的博客 683

基于C++和Python的Dijkstra算法实现及其堆优化

本文从邻接矩阵入手,对Dijkstra算法进行了初步的实现,然后通过堆和链式前向星实现了一定的优化

永远相信美好的事情即将发生 2379
上一篇: STL的rotate函数分析
下一篇: STL中的二分查找——lower_bound 、upper_bound 、binary_search
sicofield
博客等级 码龄18年 169粉丝 169原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值