索引优先队列 Indexed Priority Queue

已于 2023-02-09 15:32:23 修改
阅读量356 收藏 3
点赞数 2
文章标签： 数据结构 算法
于 2023-02-09 15:28:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jasonchen1224/article/details/128953876
版权

索引优先队列 Indexed Priority Queue的C 语言实现

  1. 索引优先队列定义

​ 在谈论索引优先队列时，无法绕开的话题就是优先队列，那么让我们简单回顾一下优先队列的定义。

1.1 优先队列(Priority Queue=PQ)

​ 优先队列的定义一般用Heap实现，过程中不断对Heap进行操作。常见的有最小优先队列和最大优先队列，最小优先队列的实现依靠min-heap的中元素不断进行上移或下沉操作，在顶部永远对应可比较对象的最小元素；而最大优先队列恰恰相反，其实现逻辑与最小优先队列类似。通过优先队列，可以快速对根元素进行访问和删除操作。

1.2 索引优先队列(Indexed Priority Queue= IPQ)

​ 既然有了优先队列这类数据，为什么还需要引入索引优先队列的概念呢？ 假设我们需要删除队列中的非根元素，那么正常的步骤就需要按照二叉树逐个进行遍历，首先找到此元素的位置，此过程需要花费大量的时间，无法在程序过程中直接访问；找到元素位置之后，和最后一个元素进行交换，再重新调整堆中个元素的位置。整个过程需要大量的遍历和数据移动，不方便程序操作。 为了解决这个问题，就提出了索引优先队列概念，索引优先队列和优先队列实际上有本质的区别。

​ 索引优先队列的核心是维护pm[]和im[]数组，而优先队列的核心是不断交换或调整heap中实际元素；索引优先队列无需对实际元素进行操作，实际上IPQ操作对象为数组的索引号(比如vals[]数组)，通过维护pm[]和im[]数组达到索引化，从而让优先队列的访问更加灵活。

​ pm[]数组，pm(position map)数组实际上映射的是vals数组索引在二叉树上节点的序列号，形象记忆为KN(KeyIndex–>NodeIndex)，通过pm映射，我们可以立即找到某个values的keyindex在优先队列中的节点位置。

​ im[]数组，im(inverse map)实际上是把二叉树上节点的序列号映射到vals数组的索引，形象记忆为(NK)(NodeIndex–>KeyIndex)，通过im映射，我们可以立即找到某个二叉树上节点序列号所对应的keyindex.

IPQ slide

大家可以通过William 的上述标记，进一步理解pm数组和im数组的具体含义。

  1. IPQ的实现(参考Java 版本)

网络上有很多IPQ的java实现版本，比较遗憾的是，还未发现C语言的实现方式，本文拟采用C语言的实现IPQ.

2.1 首先通过结构体建立IPQ所包含的基本对象，包含了基本pm[],im[],values[]以及当前IPQ大小（元素数量)

#if !defined DIJKSTRA_IPQ_H
	typedef int IPQElemType;
#endif

/**
 * @brief Define IPQ node struct
 * @param pm, position map,a given the key index of ki, pm will denote node index
 * @param im, inverse map, a give the index of node, im will denote the key index
 * @param sz, current size of IPQ_Node(number of elements)
 */
typedef struct IPQ_Node
{
    int         pm[MAX_SIZE];
    int         im[MAX_SIZE];
    IPQElemType   values[MAX_SIZE];
    int         sz;
}IPQ_Node;

2.2 基本函数

  • swim 函数，Swim函数的作用是，按照比较大小，对pm[], im[]操作，重新向上（float)调整顺序。
void swim(IPQ_Node *Q, int i)
{
    while (parent(i) >= 0 && less_value(Q->values[Q->im[i]], Q->values[Q->im[parent(i)]]))
    {
        swap(Q,i,parent(i));
        i=parent(i);
    }
}
  • sink 函数，Sink函数的作用是，按照比较大小，对pm[], im[]操作，重新向下(调整）调整顺序。
void sink(IPQ_Node *Q, int i)
{
    int l;
    int r;
    int smallest;

    l=left(i);
    r=right(i);
    if(l<Q->sz && less_value(Q->values[Q->im[l]],Q->values[Q->im[i]]))
    {
        smallest=l;
    }
    else
    {
        smallest=i;
    }

    if(r<Q->sz && less_value(Q->values[Q->im[r]],Q->values[Q->im[smallest]]))
    {
        smallest =r;
    }

    while(smallest != i)
    {
        swap(Q,i,smallest);

        i=smallest;
        l = left(i);
        r = right(i); 

        if (l < Q->sz && less_value(Q->values[Q->im[l]], Q->values[Q->im[i]]))
        {
            smallest = l;
        }
        else
        {
            smallest = i;
        }

        if (r < Q->sz && less_value(Q->values[Q->im[r]], Q->values[Q->im[smallest]]))
        {
            smallest = r;
        }
    }
}

  • swap 函数，这个函数不是交换values数组中的元素，而是维护im[]和pm[]数组

    void swap(IPQ_Node *Q, int i, int j)
{
    int temp;

    Q->pm[Q->im[i]]=j;
    Q->pm[Q->im[j]]=i;

    temp=Q->im[i];
    Q->im[i]=Q->im[j];
    Q->im[j]=temp;
}

  • 求heap 中各节点位置的函数

    int left(int i)
    {
        return 2*i+1;
    }

    int right(int i)
    {
        return 2*i+2;
    }

    int parent(int i)
    {
        return (i-1)/2;
    }
  • 比较函数，比较函数可以放在具体的应用中进行实现，比如Dijkstra或者main测试函数中实现，由于本文定义为整型，所以实现起来比较简单。
int less_value(IPQElemType v1, IPQElemType v2)
{
    return v1<v2;
}

2.3 操作函数实现（具体参考代码）

  1. 参考代码

3.1 头函数文件（IndexedPriorityQueue.h)

/**
 * @file IndexedPriorityQueue.h
 * @author your name (you@domain.com)
 * @brief 
 * Reference code link in the learning note.md documentation
 * @version 0.1
 * @date 2023-02-09
 * 
 * @copyright Copyright (c) 2023
 * 
 */
#ifndef INDEXPRIORITYQUEUE_H
#define INDEXPRIORITYQUEUE_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <stdbool.h>
#define  MAX_SIZE 100

#if !defined DIJKSTRA_IPQ_H
typedef int IPQElemType;
#endif

/**
 * @brief Define indexed priority queue node
 * @param pm, position map, given the key index of ki, pm will denote node index
 * @param im, inverse map, give the index of node, im will denote the key index
 * @param sz, current size of IPQ_Node(number of elements)
 */
typedef struct IPQ_Node
{
    int         pm[MAX_SIZE];
    int         im[MAX_SIZE];
    IPQElemType   values[MAX_SIZE];
    int         sz;
}IPQ_Node;

/**
 * @brief Initialize indexed priority queue
 * 
 * @param Q 
 */
void Init_IPQ(IPQ_Node *Q);

/**
 * @brief Check if ki had been included in the ipq
 * 
 * @param Q  indexed priority queue
 * @param ki key index number
 * @return true 
 * @return false 
 */
bool contains(IPQ_Node Q,int ki);

/**
 * @brief Get the key index of node[0]
 * @param Q  indexed priority queue
 * @return int -Key index of node[0]
 */
int Peek_MinKeyIndex(IPQ_Node Q);

/**
 * @brief Get the node[0] as the min key index
 * Remove this element
 *
 * @param Q Pointer to indexed priority queue
 * @return int int -Key index of node[0]
 */
int Poll_MinKeyIndex(IPQ_Node *Q);

/**
 * @brief Look for the values of node[0]
 * 
 * @param Q indexed priority queue
 * @return IPQElemType -Object of IPQElemType
 */
IPQElemType Peek_MinValue(IPQ_Node Q);

/**
 * @brief Get the ki from the node[0] and look for the value based on ki
 *
 * @param Q Pointer to indexed priority queue
 * @return IPQElemType -Min value from the key index,follow this ki and return 
 */
IPQElemType Poll_MinValue(IPQ_Node *Q);

/**
 * @brief Assign value to a certain of Q->values[], then conduct the swim function
 *
 * @param Q Pointer to indexed priority queue
 * @param ki Key index with hashtable
 * @param value Value(weight/distance etc.) to be assigned to Q->values[]
 */
void Insert_KeyValue(IPQ_Node *Q, int ki, IPQElemType value);

/**
 * @brief Acquire the value from values[] based on key index(ki)
 * 
 * @param ki Key index of pair map
 * @return IPQElemType -Return IPQElemType object
 */
IPQElemType Get_ValueOf(IPQ_Node Q, int ki);

/**
 * @brief Delete the value of key index(ki)
 * 
 * @param Q Poiner to IPQ_Node
 * @param ki Key index
 * @return -IPQElemType IPQElemType object
 */
IPQElemType Delete_ValueOf(IPQ_Node *Q, int ki);

/**
 * @brief Update the value at ki locatoin, then execute swim() and sink() function
 * 
 * @param Q Pointer to IPQ_Node
 * @param ki Key index
 * @param value new value
 * @return IPQElemType -Return the old value 
 */
IPQElemType Update_ValueOf(IPQ_Node *Q, int ki,IPQElemType value);

/**
 * @brief Decrease the value at the location of ki to new value(value)
 * 
 * @param Q Pointer to IPQ_Node
 * @param ki Key index
 * @param value -New value(decreased to this value)
 */
void Decrease_Valueof(IPQ_Node *Q, int ki, IPQElemType value);

/**
 * @brief Increase the value at the location of ki to new value(value)
 *
 * @param Q Pointer to IPQ_Node
 * @param ki Key index
 * @param value -New value(increased to this value)
 */
void Increase_Valueof(IPQ_Node *Q, int ki, IPQElemType value);


/*
   It will list the helper function in next section
*/

/**
 * @brief Return the left child of index i
 * 
 * @param i parent index
 * @return int 
 */
int left(int i);

/**
 * @brief Return the right child of index i
 * 
 * @param i current index
 * @return int return the index of right child
 */
int right(int i);

/**
 * @brief Return the parent node of index i
 *
 * @param i current index
 * @return int return the index of right child
 */
int parent(int i);

/**
 * @brief Float up since node[i]
 * 
 * @param Q Pointer to IPQ_Node
 * @param i Index of node(node[i]) 
 */
void swim(IPQ_Node *Q, int i);

/**
 * @brief Sink down since node[i]
 *
 * @param Q Pointer to IPQ_Node
 * @param i Index of node(node[i])
 */
void sink(IPQ_Node *Q, int i);

/**
 * @brief Update the pm[] and i[] in the IPQ_Node
 * 
 * @param Q Pointer to IPQ_Node
 * @param i Index of node i(node[i])
 * @param j Index of node j(node[j])
 */
void swap(IPQ_Node *Q, int i, int j);


/**
 * @brief Compare index of array
 * 
 * @param i index i
 * @param j index j
 * @return int return i<j;
 */
int less_index(int i, int j);

/**
 * @brief Compare the value of IPQElemType v1 and v2
 * IPQElement should be comparable
 * 
 * @param v1 First value
 * @param v2 Second value
 * @return int return v1<v2(comparable)
 */
int less_value(IPQElemType v1, IPQElemType v2);

#endif

2.2 函数的实现C语言实现文件(IndexedPriorityQueue.c)

/**
 * @file IndexedPriorityQueue.c
 * @author your name (you@domain.com)
 * @brief 
 * @version 0.1
 * @date 2023-02-09
 * 
 * @copyright Copyright (c) 2023
 * 
 */

#ifndef INDEXPRIORITYQUEUE_C
#define INDEXPRIORITYQUEUE_C
#include "IndexedPriorityQueue.h"

void swim(IPQ_Node *Q, int i)
{
    while (parent(i) >= 0 && less_value(Q->values[Q->im[i]], Q->values[Q->im[parent(i)]]))
    {
        swap(Q,i,parent(i));
        i=parent(i);
    }
}

void sink(IPQ_Node *Q, int i)
{
    int l;
    int r;
    int smallest;

    l=left(i);
    r=right(i);
    if(l<Q->sz && less_value(Q->values[Q->im[l]],Q->values[Q->im[i]]))
    {
        smallest=l;
    }
    else
    {
        smallest=i;
    }

    if(r<Q->sz && less_value(Q->values[Q->im[r]],Q->values[Q->im[smallest]]))
    {
        smallest =r;
    }

    while(smallest != i)
    {
        swap(Q,i,smallest);

        i=smallest;
        l = left(i);
        r = right(i); 

        if (l < Q->sz && less_value(Q->values[Q->im[l]], Q->values[Q->im[i]]))
        {
            smallest = l;
        }
        else
        {
            smallest = i;
        }

        if (r < Q->sz && less_value(Q->values[Q->im[r]], Q->values[Q->im[smallest]]))
        {
            smallest = r;
        }
    }
}

void swap(IPQ_Node *Q, int i, int j)
{
    int temp;

    Q->pm[Q->im[i]]=j;
    Q->pm[Q->im[j]]=i;

    temp=Q->im[i];
    Q->im[i]=Q->im[j];
    Q->im[j]=temp;
}

int left(int i)
{
    return 2*i+1;
}

int right(int i)
{
    return 2*i+2;
}

int parent(int i)
{
    return (i-1)/2;
}

/* Main function implementation*/

void Init_IPQ(IPQ_Node *Q)
{
    int i;

    for(i=0;i<MAX_SIZE;i++)
    {
        Q->pm[i]=-1;
        Q->im[i]=-1;
        Q->values[i]=INT_MIN;
    }

    Q->sz=0;
}

bool contains(IPQ_Node Q, int ki)
{
    return Q.pm[ki]!=-1;
}

int Peek_MinKeyIndex(IPQ_Node Q)
{
    return Q.im[0];
}

int Poll_MinKeyIndex(IPQ_Node *Q)
{
    int minki;

    minki= Peek_MinKeyIndex(*Q);

    Delete_ValueOf(Q,minki);

    return minki;
}

IPQElemType Peek_MinValue(IPQ_Node Q)
{
    return Q.values[Q.im[0]];
}

IPQElemType Poll_MinValue(IPQ_Node *Q)
{
    IPQElemType minvalue;
    minvalue = Peek_MinValue(*Q);
    Delete_ValueOf(Q,Peek_MinKeyIndex(*Q));

    return minvalue;
}

void Insert_KeyValue(IPQ_Node *Q, int ki, IPQElemType value)
{
    Q->pm[ki]=Q->sz;
    Q->im[Q->sz]=ki;
    Q->values[ki]=value;

    swim(Q,Q->sz);
    Q->sz++;
}

IPQElemType Get_ValueOf(IPQ_Node Q, int ki)
{
    return Q.values[ki];
}

IPQElemType Delete_ValueOf(IPQ_Node *Q, int ki)
{
    int i;
    IPQElemType value;

    i=Q->pm[ki];
    value=Q->values[ki];
    Q->sz--;
    swap(Q,i,Q->sz);
    sink(Q,i);
    swim(Q,i);

    Q->values[ki]=INT_MIN;
    Q->pm[ki]=-1; //node index set to -1
    Q->im[Q->sz]=-1;

    return value;
}

IPQElemType Update_ValueOf(IPQ_Node *Q, int ki, IPQElemType value)
{
    int i;
    IPQElemType old_value;

    i=Q->pm[ki];

    old_value=Q->values[ki];

    Q->values[ki]=value;
    sink(Q,i);
    swim(Q,i);

    return old_value;
}

void Decrease_Valueof(IPQ_Node *Q, int ki, IPQElemType value)
{
    if (less_value(value, Q->values[ki]))
    {
        Q->values[ki] = value;
        swim(Q,Q->pm[ki]);
    }
}

void Increase_Valueof(IPQ_Node *Q, int ki, IPQElemType value)
{
    if (less_value(Q->values[ki],value))
    {
        Q->values[ki] = value;
        sink(Q,Q->pm[ki]);
    }
}

#endif
  1. 主函数测试(IndexedPriorityQueue_main.c)
/**
 * @file IndexedPriorityQueue_main.c
 * @author your name (you@domain.com)
 * @brief 
 * @version 0.1
 * @date 2023-02-09
 * 
 * @copyright Copyright (c) 2023
 * 
 */

#ifndef INDEXPRIORITYQUEUE_MAIN_C
#define INDEXPRIORITYQUEUE_MAIN_C
#include "IndexedPriorityQueue.c"

int main(void)
{
    int ki;
    int N=5;
    char *map[]={"jason","mary","jacky","lily","maggy"};
    int  values[]={3,20,5,9,2};
    IPQ_Node Q;
    int minvalue;

    Init_IPQ(&Q);
    for(ki=0;ki<N;ki++)
    {
        Insert_KeyValue(&Q,ki,values[ki]);
    }

    Increase_Valueof(&Q,4,7);
    minvalue=Peek_MinValue(Q);
    minvalue = Poll_MinValue(&Q);
    minvalue = Peek_MinValue(Q);
    printf("\n end \n");
   	getchar();
    return EXIT_SUCCESS;
}

int less_value(IPQElemType v1, IPQElemType v2)
{
    return v1<v2;
}

#endif

  1. 总结

    通过对IPQ的学习和C语言实现，初步掌握了PQ(Priority Queue)和IPQ(Indexed Priority Queue)之间的区别，另外通过C语言实现，将为Dijkstra的eager算法提供了可能。

    IPQ的关键还是理解pm[]和im[]数组，理解这两个数组后，其它的操作都相对比较简单。

    以上，

    谢谢

  2. 总结

    通过对IPQ的学习和C语言实现，初步掌握了PQ(Priority Queue)和IPQ(Indexed Priority Queue)之间的区别，另外通过C语言实现，将为Dijkstra的eager算法提供了可能。

    IPQ的关键还是理解pm[]和im[]数组，理解这两个数组后，其它的操作都相对比较简单。

    以上，

    谢谢

参考文献：

  1. Indexed Priority Queue的Java实现 by William Fiset

https://github.com/williamfiset/Algorithms/blob/master/src/main/java/com/williamfiset/algorithms/datastructures/priorityqueue/MinIndexedDHeap.java#L124

  1. Video Index Priority Queue by William Fiset

https://www.youtube.com/watch?v=jND_WJ8r7FE&t=0s&ab_channel=WilliamFiset

Jasonchen1224
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
索引优先队列
光何
11-04 681
一、算法思想 　　优先队列的原理本质上就是利用完全二叉树的结构实现以log2n的时间复杂度删除队列中的最小对象（这里以小堆顶为例）。完全二叉树又可以通过数组下标实现索引，当插入一个对象的时候，利用上浮操作更新最小对象。当删除堆顶最小对象时，将末尾的对象放置到堆顶上，然后执行下沉操作。 　　优先队列有一个缺点，就是不能直接访问已存在于优先队列中的对象，并更新它们。这个问题在Dijistra算法中就有明显的体现，有时候我们需要更新已在队列中的顶点的距离。为此就需要设计一种新型的数据结构来解决这个问题，这就是
java 索引优先队列_索引式优先队列（indexed priority queue）
weixin_40002009的博客
02-16 515
import java.util.*;/*** Created by 浩然 on 4/19/15.* 索引式优先队列* * 建立目的：* 在实现普利姆算法时，需要用优先队列来优化最轻边的查找.* 而jdk中的优先队列只满足lazy实现，如果要作eager实现，需实现一个decrease-key操作.* * 参考：* 1.普林斯顿大学 algorithms 4th edition.* 2.jdk p...
02优先队列和索引优先队列-优先队列-数据结构和算法(Java)
gaogzhen的博客
12-10 562
02优先队列和索引最小优先队列-优先队列-数据结构和算法(Java)
索引式优先队列（indexed priority queue）
weixin_30474613的博客
04-21 255
为了达到O(ElogV)的效率，需要对普利姆算法进行eager实现。 如果我们用java来做，jdk当中的priorityQueue并不能满足我们的要求。 因为我们需要进行一个对索引元素降key的操作（decrease-key）. /** * 将索引所关联的key降到newKey * * @param index 索引 * @p...
java 索引优先队列_索引优先队列
weixin_29492649的博客
02-16 178
#include #include #include #include #include "Common.hpp"#include using namespace std;/*** 索引最小优先队列**/templateclass IndexMinPQ {public:IndexMinPQ(int max);void show() const;int size() const {return N...
mui及索引列表indexedList,mui.picker.有索引列表具体教程
05-30
好用的mui索引列表插件，我的博客中有详细教程，博客地址： https://blog.csdn.net/lianzhang861/article/details/80505799
深入解析HTML5的IndexedDB索引数据库
01-21
介绍IndexedDB是HTML5 WEB数据库，允许HTML5 WEB应用在用户浏览器端存储数据。对于应用来说IndexedDB非常强大、有用，...IndexedDB 创建有数据类型和简单的JavaScript持久对象的object，每个object可以有索引，使其有
IndexedDB:索引数据库示例
07-06
索引数据库 索引数据库示例
被索引「Is Indexed」-crx插件
03-19
检查一个网页是否被Google编入索引 该扩展快速告诉你，如果一个页面被谷歌索引。而已。干净利落。只需点击工具栏图标，然后等待答案。有用的SEO。由http://www.jitbit.com/ 支持语言:English (United States)
Java优先队列
qq_45666842的博客
11-17 1828
优先队列应用场景： 在一堆杂乱无序的数据里，尤其是当数据量特别大时，要选出最大（最小）的几个元素，那么就不必将所有数据都排序后再选择。这时需要一种合适的数据结构，能够删除最小元素和插入元素。 例如在一个有100万个数字的文件中选出最大的10个，百万整数文档链接 public static void main(String[] args) { //创建一个MinPQ实例，可以存放输入的最大的10个整数 //MinPQ类的代码在下方会有介绍 MinPQ<In.
优先队列和索引优先队
huang1433的博客
12-16 1120
用堆二叉树实现，参考《算法》（第四版）。 1.优先队列 //二叉堆，从小到大排序 class heapBinaryTree { public: heapBinaryTree(int capacity);//指定容量 heapBinaryTree(const int num[], int len);//用数组初始化堆 ~heapBinaryTree(); inline int getCa
数据结构与算法之索引优先队列
JavaBoy_XZL的博客
12-21 468
在前面实现的最大优先队列和最小优先队列，他们可以分别快速访问到队列中最大元素和最小元素，但是他们有一 个缺点，就是没有办法通过索引访问已存在于优先队列中的对象，并更新它们。为了实现这个目的，在优先队列的 基础上，学习一种新的数据结构，索引优先队列。接下来我们以最小索引优先队列举列。 最小索引优先队列实现思路 步骤一： 存储数据时，给每一个元素关联一个索引，我们用一个T[ ] items数组来保存数据元素，在insert(T t，int k)插入时，k就是 items数组的索引，元素 t 放到items数
10.2索引优先队列---了解
pc的博客
02-04 196
在之前实现的最大优先队列和最小优先队列，他们可以分别快速访问到队列中最大元素和最小元素，但是他们有一个缺点，就是没有办法通过索引访问已存在于优先队列中的对象，并更新它们。为了实现这个目的，在优先队列的基础上，学习一种新的数据结构，索引优先队列。接下来我们以最小索引优先队列举列。 /** * 索引优先队列 * 增加或者删除数据时候，是通过pd指针的交换达到最大堆或最小堆 * 排序 排的不是items 而是pq */ public class IndexMinPriorityQueue...
《算法4》索引优先队列笔记-----java实现
一颗小陨石的博客
03-05 803
一、前言 前面已经讲了优先队列的实现，https://blog.csdn.net/weixin_43696529/article/details/104672731，但是其很明显有一个缺点，那就是无法直接访问已经在队列中的元素，更新或是删除它们，在Dijistra算法中就非常需要此性质，因此要解决此问题就需用到索引优先队列 二、索引优先队列数据结构讲解 索引优先队列使用一个int[] pq数组作为...
索引最小优先队列简单实现(java)
qq_38708372的博客
04-12 182
虽然最大优先队列和最小优先队列，他们可以分别快速访问到队列中最大元素和最小元素，但是他们有一 个缺点，就是没有办法通过索引访问已存在于优先队列中的对象，并更新它们。为了实现这个目的，创建一种新的数据结构，索引优先队列。 实现思路： 步骤一： 存储数据时，给每一个数据元素关联一个整数，例如insert(int k,T t),我们可以看做k是t关联的整数，那么我们的实 现需要通过k这个值，快速获取到队列中t这个元素，此时有个k这个值需要具有唯一性。我们可以用一个T[] items数组来保存数据元素，在in
数据结构实现之最小索引优先队列
清文的博客
01-24 2738
在很多应用中，允许用例引用进入优先队列中的元素是有必要的。做到这一点的一种简单方式是给每个元素一个索引。 另外，一种常见的情况是用例已经有了总量为N的多个元素，而且可能还同时使用了多个（平行）数组来存储这些元素的信息。此时，其他无关的用例代码可能已经在使用一个整数索引来引用这些无关元素了。这些考虑引导我们设计了如下所示的API。 public class IndexMinPQ> 说明
java 索引优先队列_我理解的数据结构（七）—— 堆和优先队列（Heap And PriorityQueue）...
weixin_39691748的博客
02-16 98
我理解的数据结构(七)—— 堆和优先队列(Heap And PriorityQueue)一、堆1.堆的基础堆也是一颗树堆最为主流的一种实现方式：二叉堆二叉堆是一颗完全二叉树2.完全二叉树完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。(通俗来说：完全二叉树...
indexeddb 排序
最新发布
08-06
IndexedDB中的数据是按照存储的顺序进行排序的。当你向IndexedDB中添加数据时，它们将按照添加的顺序进行排序。因此，当你从IndexedDB中检索数据时，它们将按照添加的顺序返回给你。如果你希望按照特定字段进行排序，你需要使用索引。引用中提到了创建对象仓库和索引的过程。通过创建一个索引，你可以指定一个字段来进行排序。然后，当你检索数据时，可以使用这个索引来按照指定的字段进行排序。请注意，IndexedDB不支持动态排序，一旦数据添加到数据库中，它们的排序就是固定的。因此，如果你希望对数据进行不同的排序，你需要创建不同的索引来支持这些排序方式。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值