C++ 正在生成的最大堆未发送到顶部

我试图用一个大小为10的向量构建一个最大堆。它包含数字1-10。然而，我的程序不会将最大值10设置为最大变量，因为在比较时，它超出了向量的范围

if ((l <= v.size()) && (v.at(l) > v.at(i)))
    {largest = l;}
    else { largest = i; }

    if ((r <= v.size()) && (v.at(r) > v.at(largest))) // r at some point is 10. which exceeds v.
    {largest = r;}

这几乎是正确的，但10应该是第一位。如何确保堆正确构建？这是我的全部代码：

#include <iostream>
#include <fstream>
#include <string>
#include <vector>

using namespace std;


vector<string> readFile(string fileName) { /* read in file. Works Fine.*/}
void display(vector<string>& v)  {/*displays vector. works fine. */  }

inline int parent(int i){return i / 2; }
inline int left(int i)  {return 2*i;}
inline int right(int i) {return 2*i + 1;}

void Max_Heapify(vector<string>& v, int i)
{
    int largest;
    int l = left(i);
    int r = right(i);
    i--;

    if ((l <= v.size()) && (v.at(l) > v.at(i)))  
    {largest = l;}
    else { largest = i; }

    if ((r <= v.size()) && (v.at(r) > v.at(largest)))
    {
        largest = r;
    }

    if (largest != i)
    {
        string temp = v.at(i);
        v.at(i) = v.at(largest);
        v.at(largest) = temp;

        Max_Heapify(v, largest);
    }
}

void Build_Max_Heap(vector<string>& v, int length) 
{
    for (int i = (length / 2); i > 0; i--)
    {
        Max_Heapify(v, i);
    }
}

int main() {
    vector<string> vectorReadIn;
    vector<string> sortedVector;
    int x = 0;

    string fileName = "C:/Users/user/Downloads/Algorithims/Perm Words/perm15k.txt";

    vectorReadIn = readFile(fileName);

    cout << "Unsorted file:" << endl;
    display(vectorReadIn);
    vectorReadIn.resize(vectorReadIn.size());
    Build_Max_Heap(vectorReadIn, vectorReadIn.size());

    display(vectorReadIn);  
}

#包括
#包括
#包括
#包括
使用名称空间std；
矢量读取文件（字符串文件名）{/*在文件中读取。工作正常。*/}
void display（vector&v）{/*显示向量。工作正常。*/}
内联int父（inti）{return i/2；}
内联int left（int i）{返回2*i；}
内联int-right（inti）{返回2*i+1；}
void Max_Heapify（向量和向量，整数i）
{
int最大；
int l=左（i）；
int r=右（i）；
我--；
如果（（v.at（i）））
{最大=l；}
else{maxed=i；}
如果（（r v.at（最大）））
{
最大=r；
}
如果（最大！=i）
{
字符串温度=v.at（i）；
v、 at（i）=v.at（最大值）；
v、 温度（最大）=温度；
最大值（v，最大值）；
}
}
无效构建\u最大\u堆（向量&v，整数长度）
{
对于（int i=（长度/2）；i>0；i--）
{
Max_Heapify（v，i）；
}
}
int main（）{
载体载体阅读蛋白；
向量分类器；
int x=0；
string fileName=“C:/Users/user/Downloads/Algorithims/Perm Words/perm15k.txt”；
vectorReadIn=读取文件（文件名）；
cout除了Igor Tandetnik的评论之外，您对左和右子代的计算是错误的。在索引0为第一项的向量中，堆的根位于索引0处。因此，对左和右子代的计算是：

left child: (2*x) + 1
right child: (2*x) + 2

您的计算是针对根位于索引1的堆进行的

另外，
Build\u Max\u Heap
函数中的循环需要：

for (int i = (length / 2); i >= 0; i--)

也就是说，您必须检查向量中的第一项是否需要重新排列。
大小为
N
的向量的有效索引是0到
N-1
。因此，当
l==v.size（）
时，
v.at（l）
将抛出范围外异常。鉴于此，条件
（（l v.at（i）））
看起来不正确-
v.at（l）
仅在
l
严格小于
v.size（）时有效。
for (int i = (length / 2); i >= 0; i--)