C语言中的优先级队列 struct节点 { int-id； 浮重； }; int find_last（结构节点优先级Q[]）） { int i=1； while（Prio_Q[i].id！=-1） { i+=1； } 返回i； } 无效初始化（结构节点优先级，整数大小） { int i； 对于（i=0；iPrio_Q[i]。权重） { 交换节点（优先级Q、i/2、i）； 健康检查（优先检查，i/2）； } } 无效交换节点（结构节点优先级Q[]，int i，int j） { 结构节点温度； 温度=Prio_Q[i]； Prio_Q[i]=Prio_Q[j]； Prio_Q[j]=温度； //printf（“smething已被交换。\n”）； } int main（int argc，char*argv[]） { 结构节点； 结构节点优先级Q[10]； int size=10； 初始化_Q（Prio_Q，11）； node.id=5； 节点重量=11； 对于（int m=0；m

这是我构建的一个优先级队列，但是如果您测试代码，您将看到在我实际请求函数执行此操作之前，队列将自动向其最后一个索引添加一个节点

在main函数中，我只使节点具有两个值，但没有将节点排入优先级队列数组。数组将自动将节点添加到最后一个索引中，有人可以帮助我吗

---

提前感谢。

在语句

struct node Prio_Q[10]中，您正在初始化一个大小为10[索引0,1，…，9]的数组

但是当您初始化队列时
initialize_Q（Prio_Q，11）使用大小11对其进行初始化：[0,1，…，10]。您正在从分配的阵列溢出

稍后在
for（int m=0；m

请记住，在c中，数组是从0索引的，因此如果您有
n
元素，那么您的索引是
[0,1，…，n-1]
-因此您的迭代应该是从
i=0
开始的，而
i
您正在初始化一个大小为10的数组[index 0,1，…，9]，在语句
struct node Prio_Q[10]

但是当您初始化队列时
initialize_Q（Prio_Q，11）使用大小11对其进行初始化：[0,1，…，10]。您正在从分配的阵列溢出

稍后在
for（int m=0；m

请记住，在c中，数组是从0开始索引的，因此如果您有
n
元素，那么您的索引是
[0,1，…，n-1]
-因此您的迭代应该是从
i=0
开始的，而
i
欢迎使用c；该语言无法帮助您避免数组访问超出范围，这是代码中的一个特殊问题：

从
main（）
：

请注意，您正在调用
initialize_Q（）
，其
大小为
11
。这意味着您的
for
循环将导致超出
Prio_Q
数组末尾的数组访问：

对于您的输出（它应该有自己的功能，这样您就可以在整个程序中自由地使用它）：

for（int m=0；m

同样，当
m==10
欢迎使用C时，您已经访问了数组末尾以外的位置；该语言无法帮助您避免数组访问超出范围，这是代码中的一个特殊问题：

从
main（）
：

请注意，您正在调用
initialize_Q（）
，其
大小为
11
。这意味着您的
for
循环将导致超出
Prio_Q
数组末尾的数组访问：

对于您的输出（它应该有自己的功能，这样您就可以在整个程序中自由地使用它）：

for（int m=0；m

同样，当
m==10
我发现您在函数
initialize\u Q
中传递值11作为size的参数时，您已经访问了数组末尾以外的位置。您应该使用值10，因为它是队列向量的大小。主函数末尾的最后一个for循环也是如此。我发现在函数
initialize\u Q
中传递值11作为size的参数。您应该使用值10，因为它是队列向量的大小。主函数末尾的最终for循环也是如此。
struct node
{
    int id;
    float weight;
};

int find_last(struct node Prio_Q[])
{
    int i = 1;
    while (Prio_Q[i].id != -1)
    {
        i += 1;
    }
    return i;
}

void initialize_Q(struct node Prio_Q[], int size)
{

    int i;

    for (i = 0; i < size; i ++)
    {
        Prio_Q[i].id = -1;
        Prio_Q[i].weight = -1;

    }
    //printf("The queue is %f", Prio_Q[3].weight);
}

void enque_Q(struct node Prio_Q[], struct node node, int size)
{
    int i = find_last(Prio_Q);

    Prio_Q[i].id = node.id;
    Prio_Q[i].weight = node.weight;
    printf("The last index is %d\n", i);
    heapify_up(Prio_Q, i);
}

void heapify_up(struct node Prio_Q[], int i)
{    

    if (Prio_Q[i/2].weight > Prio_Q[i].weight)
    {
        swap_node(Prio_Q,i/2, i);
        heapify_up(Prio_Q, i/2);
    }
}

void swap_node(struct node Prio_Q[], int i, int j)
{
    struct node temp;
    temp = Prio_Q[i];
    Prio_Q[i] = Prio_Q[j];
    Prio_Q[j] = temp;
    //printf("smething has been swapped.\n");
} 

int main(int argc, char *argv[])
{
    struct node node;
    struct node Prio_Q[10];

    int size = 10;
    initialize_Q(Prio_Q, 11);

    node.id = 5;
    node.weight = 11;

    for(int m = 0; m < size+1; m++)
    {
        printf("The %dth element in Que is %d with weight %f.\n", m, Prio_Q[m].id, Prio_Q[m].weight);
    }

}

struct node Prio_Q[10];

int size = 10;
initialize_Q(Prio_Q, 11);

void initialize_Q(struct node Prio_Q[], int size)
{

    int i;

    for (i = 0; i < size; i ++)
    {
        Prio_Q[i].id = -1;      /* BUG when i == 10 */
        Prio_Q[i].weight = -1;

int find_last(struct node Prio_Q[])
{
    int i = 1;
    while (Prio_Q[i].id != -1)
    {
        i += 1;
    }return i;
}

for(int m = 0; m < size+1; m++)
{
    printf("The %dth element in Que is %d with weight %f.\n", m, Prio_Q[m].id, Prio_Q[m].weight);
}