上网查过很多优先队列代码都是C++的~直接调用模板类的~~打算找一个用C实现的~实现函数部分是自己弄的~~~
打算放假有时间自己研习一下~~~

PS:如果不知道什么是优先队列可以上网搜搜~网上有详细的解释~

优先队列，我有示例代码，你要不？
要的话，我手动敲一下，发给你？

可以~

青蛙跳水：噗通~~~~~~~~~

示例代码不完整，只有3个函数，不过是3个主要的函数。

某些不大容易理解的地方，我添加了必要的注释，希望不是画蛇添足。

#ifndef _BinHeap_H

struct HeapStruct;
typedef struct HeapStruct *PriorityQueue;

PriorityQueue
Initialize( int MaxElements );

void
Destroy( PriorityQueue H );

void
MakeEmpty( PriorityQueue H );

void
Insert( ElementType X, PriorityQueue H );

ElementType
DeleteMin( PriorityQueue H );

ElementType
FindMin( PriorityQueue H );

int
IsEmpty( PriorityQueue H );

int
IsFull( PriorityQueue H );

#endif

struct HeapStruct{
    int Capacity;
    int Size;
    ElementType *Elements;
};


PriorityQueue
Initialize( int MaxElements )
{
    PriorityQueue H;

    if( MaxElements < MinPQSize )
        Error( "Priority queue size is too samll" );//Error是报错函数，不需要知道它的具体功能，你只要知道它是干嘛的就行。

    H = malloc( sizeof( struct HeapStruct ) );
    if( NULL == H )
        FatalError( "Out of space!!!" );

    H->Elements = malloc( ( MaxElements + 1 ) * sizeof( ElementType ) );
    if( NULL == H->Elements )
        FatalError( " Out of space!!!" );

    H->Capacity = MaxElements;
    H->Size = 0[ 0 ] = MinData;//MinData是一个人为选择的标记，用来在Insert函数中跳出while循环，当然也还有别的方法，示例代码选择了一个比较简单的方法，以输入0-10的序列为例，那么MinData的值就该选择一个负数，例如-1

}


void
Insert( ElementType X, PriorityQueue H )
{
    int i;

    if( IsFull( H ) )
    {
        Error( "Priority queue is full" );
        return;
    }

    for( i = ++H->Size; H->Elements[ i / 2 ] > X; i /= 2 )
        H->Elements[ i ] = H->Elements[ i / 2 ];
    H->Elements[ i ] = X;
}


ElementType
DeleteMin( PriorityQueue H )
{
    int i, Child;
    ElementType MinElement, LastElement;

    if( IsEmpty( H ) )
    {
        Error( "Priority queue is empty" );
        return H->Elements[ 0 ];
    }
    MinElement = H->Elements[ 1 ];
    LastElement = H->Elements[ H->Size-- ];

    for( i = 1; i * 2 <= H->Size; i = Child )
    {
        Child = i * 2;
        if( Child != H->Size && H->Elements[ Child + 1 ] < H->Elements[ Child ] )
            Child++;

        if( LastElement > H->Elements[ Child ] )
            H->Elements[ i ] = H->Elements[ Child ];
        else
            break;
            
    }

    H->Elements[ i ] = LastElement;
    return MinElement;

}

[此贴子已经被作者于2017-7-3 20:21编辑过]

青蛙跳水这样理解感觉挺生动形象的~好像堆排序类似于这种写法~

感觉你打的句子就像青蛙跳水，激起层层波浪~~

是这样么~优先队列看来用数组实现预先还是要分配足够的空间的~如果预先不知道空间大小可能会造成空间浪费~个人感觉可以试试用树或者链堆来实现~当然这样操作效率会低一点的~

准备看看伸展树或者哈夫曼树(还没确定到底先弄哪个-大概是这里面的二选一吧)~~不过弄哈夫曼树要看看优先队列~要看优先队列就先看看堆栈性质~~~还要时不时看看我写的那个红黑树代码能怎么优化~看来这也有段时间弄了~~

优先队列本来就是树啊。
示例代码是用数组实现的树。
用数组实现有很多的方便，但是也要求元素数量已知。

[此贴子已经被作者于2017-7-4 14:19编辑过]

那个更像堆吧~虽然堆的结构和树类似~不过搜索树一般是左小右大~而堆的底层元素都比顶部元素要大(小)~