List 如何为双链接列表编写堆？c++；

我需要为双链表编写一个heapsort，但我无法实现该算法。你能帮我吗？

谢谢大家-有这样一个工作代码用于双链接列表的堆排序-工作。也许以后会有人需要它

void List::heap_sort(int n) {
Node* temp = Head;
for (int i = n / 2 - 1; i >= 0; i--)
    heapify(temp, n, i);

   //По очереди извлекаем элементы из кучи
    for (int i = n - 1; i >= 0; i--)
    {
        swap(0, i, temp);

   
        heapify(temp, i, 0);
    }
}

void List::heapify(Node* temp, int n, int i) {
    // Инициализация большего элемента, как корня
    int largest = i; 
    int l = 2 * i + 1; 
    int r = 2 * i + 2; 
    Node* largesti = temp;
    for (int k = 0; k < largest; k++) {
        largesti = largesti->Next;
    }
    Node* li = temp;
    for (int k = 0; k < l; k++) {
        if (li == NULL)
            break;
        li = li->Next;
    }
    Node* ri = NULL;
    if (li != NULL) ri = li->Next;

    // Если правый потомок больше корня
    if (li != NULL)
    if (l < n && li->x > largesti->x) {
        largest = l;
        largesti = li;
    }
    // Если правый потомок до сих пор самый большой
        if (ri != NULL)
    if (r < n && ri->x > largesti->x)
        largest = r;

    // Если largest не является корнем
    if (largest != i)
    {
        swap(i, largest, temp);

        // Формируем дерево
        heapify(temp, n, largest);
    }
}

void List::swap(int i, int k, Node* swapList) {
    Node* temp1 = swapList, * temp2 = swapList;
    for (int j = 0; j < i; j++) {
        temp1 = temp1->Next;
    }
    for (int j = 0; j < k; j++) {
    temp2 = temp2->Next;
    }
    int number = temp1->x;
    temp1->x = temp2->x;

    temp2->x = number;

}

void List:：heap\u排序（int n）{
节点*温度=头部；
对于（int i=n/2-1；i>=0；i--）
heapify（温度、n、i）；
//По очереди извлекаем элементы из кучи
对于（int i=n-1；i>=0；i--）
{
交换（0，i，temp）；
heapify（温度，i，0）；
}
}
无效列表：：heapify（节点*temp，int n，int i）{
// Инициализация большего элемента, как корня
int=i；
int l=2*i+1；
int r=2*i+2；
节点*最大值=温度；
对于（int k=0；k<最大值；k++）{
largesti=largesti->Next；
}
节点*li=温度；
对于（int k=0；kNext；
}
Node*ri=NULL；
如果（li！=NULL）ri=li->Next；
// Если правый потомок больше корня
如果（li！=NULL）
如果（lx>largesti->x）{
最大=l；
最大值=li；
}
// Если правый потомок до сих пор самый большой
如果（ri！=NULL）
如果（rx>largesti->x）
最大=r；
//最大的
如果（最大！=i）
{
交换（i、最大、临时）；
// Формируем дерево
heapify（温度，n，最大）；
}
}
void List:：swap（int i、int k、Node*swapList）{
节点*temp1=swapList，*temp2=swapList；
对于（int j=0；jNext；
}
对于（int j=0；jNext；
}
整数=temp1->x；
temp1->x=temp2->x；
temp2->x=编号；
}

完整代码：

#include <iostream>
#include <fstream>
using namespace std;

struct Node                             
{
    int x;                             
    Node* Next, * Prev;                 
};

class List                             
{
    //Указатели на адреса начала списка и его конца
    Node* Head, * Tail;                 
public:
    //Инициализируем адреса как пустые
    List() :Head(NULL), Tail(NULL) {};    
    ~List();                           
    void show();                       
    void output_to_file(int c);
    void add(double x);                  
    void bubble_sort();
    void heap_sort(int n);
    void swap(int i, int k, Node* swapList);
    void heapify(Node* temp, int n, int i);
};

void List::add(double x)
{
    //Выделение памяти под новый элемент структуры
    Node* temp = new Node; 
    //Указываем, что изначально по следующему адресу пусто
    temp->Next = NULL;                   
    temp->x = x;                        

    if (Head != NULL)                   
    {
        temp->Prev = Tail;               
        Tail->Next = temp;               
        Tail = temp;                     
    }
    else
    {
        temp->Prev = NULL;               
        Head = Tail = temp;              
    }
}

void List::show()
{
    //Временно указываем на адрес первого элемента
    Node* temp = Head;  
    //Пока не встретим пустое значение
    while (temp != NULL)              
    {
        cout << temp->x << " ";        
        temp = temp->Next;             
    }
}

void List::output_to_file(int c)
{
    ofstream fout;
    fout.open("output.txt");
    if (fout.is_open()) {
        Node* temp = Head;                   
        fout << c << " ";
        while (temp != Tail)              
        {
            fout << temp->x << " ";        
            temp = temp->Next;           
        }
        fout << temp->x;
    }
    else
        cout << "Output file doesnt exist";
}

void List::bubble_sort() {
    //Первый элемент — это пусть будет голова
    Node* left = Head;                 
    //Второй элемент — это пусть будет следующий за головой элемент
    Node* right = Head->Next;          

    Node* temp = new Node;             

    while (left->Next) {                 
        while (right) {             
            if ((left->x) > (right->x)) {        
                temp->x = left->x;              
                left->x = right->x;            
                right->x = temp->x;            
            }
            right = right->Next;                    
        }
        left = left->Next;                              
        right = left->Next;                             
   }
}


void List::heap_sort(int n) {
    Node* temp = Head;
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(temp, n, i);

   //По очереди извлекаем элементы из кучи
    for (int i = n - 1; i >= 0; i--)
    {
        swap(0, i, temp);

   
        heapify(temp, i, 0);
    }
}

void List::heapify(Node* temp, int n, int i) {
    // Инициализация большего элемента, как корня
    int largest = i; 
    int l = 2 * i + 1; 
    int r = 2 * i + 2; 
    Node* largesti = temp;
    for (int k = 0; k < largest; k++) {
        largesti = largesti->Next;
    }
    Node* li = temp;
    for (int k = 0; k < l; k++) {
        if (li == NULL)
            break;
        li = li->Next;
    }
    Node* ri = NULL;
    if (li != NULL) ri = li->Next;

    // Если правый потомок больше корня
    if (li != NULL)
    if (l < n && li->x > largesti->x) {
        largest = l;
        largesti = li;
    }
    // Если правый потомок до сих пор самый большой
    if (ri != NULL)
    if (r < n && ri->x > largesti->x)
        largest = r;

    // Если largest не является корнем
    if (largest != i)
    {
        swap(i, largest, temp);

        // Формируем дерево
        heapify(temp, n, largest);
    }
}

void List::swap(int i, int k, Node* swapList) {
    Node* temp1 = swapList, * temp2 = swapList;
    for (int j = 0; j < i; j++) {
        temp1 = temp1->Next;
    }
    for (int j = 0; j < k; j++) {
        temp2 = temp2->Next;
    }
    int number = temp1->x;
    temp1->x = temp2->x;

    temp2->x = number;

}

List::~List()                          
{
    while (Head)                      
    {
        Tail = Head->Next;            
        delete Head;                   
        Head = Tail;                   
    }
}

void adder(List &lst,int &b) {
    ifstream fin("input.txt");
    double k;
    fin >> b;
    while (fin >> k) {
        lst.add(k);
    }
}

int main()
{
    ifstream fin;
    List lst; 
    int b;
    double k;
    int c = 0;
    fin.open("input.txt");
    if (fin.is_open()) {
//counting the numbers of elements in file
        while (fin >> k) {
            c++;
        }
        fin.close();

        fin.open("input.txt");
        if (fin.is_open()) {

            adder(lst, b);
            lst.show();

            if (b == 0)
                lst.heap_sort(c - 1);
            else
                lst.bubble_sort();

            cout << endl;
            lst.show();
            lst.output_to_file(c - 1);
        }
        else
            cout << "Input file doesnt exist";
    }
    else
        cout << "Input file doesnt exist";
    return 0;
}

#包括
#包括
使用名称空间std；
结构节点
{
int x；
节点*Next，*Prev；
};
班级名单
{
//Указатели на адреса начала списка и его конца
节点*头，*尾；
公众：
//Инициализируем адреса как пустые
List（）：Head（NULL），Tail（NULL）{}；
~List（）；
void show（）；
无效输出_到_文件（int c）；
空加（双x）；
void bubble_sort（）；
无效堆排序（int n）；
无效交换（整数i、整数k、节点*swapList）；
void heapify（节点*temp，int n，int i）；
};
无效列表：：添加（双x）
{
//Выделение памяти под новый элемент структуры
Node*temp=新节点；
//Указываем, что изначально по следующему адресу пусто
temp->Next=NULL；
温度->x=x；
if（Head！=NULL）
{
温度->上一个=尾部；
尾部->下一步=温度；
尾=温度；
}
其他的
{
temp->Prev=NULL；
头部=尾部=温度；
}
}
无效列表：：show（）
{
//Временно указываем на адрес первого элемента
节点*温度=头部；
//Пока не встретим пустое значение
while（temp！=NULL）
{
cout x Next；
}
}
无效列表：：输出到文件（INTC）
{
流式流量计；
fout.open（“output.txt”）；
if（fout.is_open（））{
节点*温度=头部；
fout x）>（右->x）{
温度->x=左->x；
左->x=右->x；
右->x=温度->x；
}
右=右->下一步；
}
左=左->下一步；
右=左->下一步；
}
}
无效列表：：堆排序（int n）{
节点*温度=头部；
对于（int i=n/2-1；i>=0；i--）
heapify（温度、n、i）；
//По очереди извлекаем элементы из кучи
对于（int i=n-1；i>=0；i--）
{
交换（0，i，temp）；
heapify（温度，i，0）；
}
}
无效列表：：heapify（节点*temp，int n，int i）{
// Инициализация большего элемента, как корня
int=i；
int l=2*i+1；
int r=2*i+2；
节点*最大值=温度；
对于（int k=0；k<最大值；k++）{
largesti=largesti->Next；
}
节点*li=温度；
对于（int k=0；kNext；
}
Node*ri=NULL；
如果（li！=NULL）ri=li->Next；
// Если правый потомок больше корня
如果（li！=NULL）
如果（lx>largesti->x）{
最大=l；
最大值=li；
}
// Если правый потомок до сих пор самый большой
如果（ri！=NULL）
如果（rx>largesti->x）
最大=r；
//最大的
如果（最大！=i）
{
交换（i、最大、临时）；
// Формируем дерево
heapify（温度，n，最大）；
}
}
void List:：swap（int i、int k、Node*swapList）{
节点*temp1=swapList，*temp2=swapList；
对于（int j=0；jNext；
}
对于（int j=0；jNext；
}
整数=temp1->x；
temp1->x=temp2->x；
temp2->x=编号；
}
列表：：~List（）
{
while（Head）
{
尾部=头部->下一步；