C++ 基于链表的优先级队列

方法，add\u by\u priority“给了我分段错误，我知道问题发生在，get\u prio”方法中。我试图解决它或搜索它是否在其他任何地方工作，例如，在、、if”语句之外，它编译得很好。此外，我也不知道我是否正确执行了整个优先级插入算法（尤其是while循环后的两行）

\ifndef SNODE\H
#定义SNODE_H
#包括
模板
类势垒
{
私人：
类型_elem；//元素的值
SNode*\u next\u elem；//连接到下一个节点
int _prio；//优先级
公众：
SNode（）；
SNode（常数类型和元素，常数SNode*next_elem，常数int prio）；
键入并获取元素（）；
SNode*获取下一个元素（）；
int&get_prio（）；
无效集元素（常量类型和元素）；
无效集合下一个元素（SNode和下一个元素）；
无效设置优先级（常量int和优先级）；
布尔运算符（SNode和Node）；
};
#恩迪夫

---

\ifndef链接列表
#定义链接列表
#包括
#包括“SNode.h”
模板
类链接列表
{
私人：
斯诺德*头；
公众：
LinkedList（）；//konstruktor BezParameterryCzny
按优先级（常量类型和节点、常量int和prio）无效添加；
void removeFront（）；
void addFront（常量类型和节点、常量int和prio）；
常量类型&front（）常量；
bool empty（）常量；
作废打印（）；
};

---

#包括“SNode.h”
模板
SNode:：SNode（）{}
模板
SNode：：SNode（常量类型和元素，常量SNode*下一个元素，常量int prio）
{
_elem=elem；
next_elem=NULL；
_prio=prio；
}
模板
类型&SNode:：get_elem（）
{
返回元素；
}
模板
SNode*SNode:：获取下一个元素（）
{
返回下一个元素；
}
模板
int&SNode:：get_prio（）
{
返回优先权；
}
模板
无效节点：：集合元素（常量类型和元素）
{
_elem=elem；
}
模板
void SNode：：设置下一个元素（SNode和下一个元素）
{
_next_elem=&next_elem；
}
模板
void SNode:：设置优先级（常量int和prio）
{
_prio=prio；
}
模板
bool SNode:：运算符节点。get_prio（））
返回true；
返回false；
}
模板
bool SNode:：operator>（SNode和Node）
{
返回！（*thisget_elem（）；
}
模板
void LinkedList:：addFront（常量类型和节点、常量int和prio）
{
SNode*temp=new SNode；//tworzymy nowa zmienna do，ktorej przypiszemy wartosc podanego argumentu
temp->set_elem（节点）；//podpisujemy-wartosc
temp->set_prio（优先级）；//podpisujemy priority
临时->设置下一个元素（*head）；//podpisuje pod adres aktualnego poczatku
水头=温度；//nowa inicjalizacja poczatku临时水头
}
模板
作废LinkedList:：removeFront（）
{
SNode*temp=head；//tworzymy zmienna ktora pokazuje na head zeby nie zgubic pamieci head
head=head->get_next_elem（）；//przestawiamy head na nastepny元素
删除温度；//通常为pamiec ktora byla吊舱头
}
模板
作废链接列表：：打印（）
{
SNode*tmp=head；//podpisanie Zmienej pod wartosc i adres head（由od pcozatku printowac liste提供）
while（tmp->get_next_elem（）！=nullptr）//jesli lista nie jest pusta
{
std:：cout get_elem（）get_next_elem（）；//przestaw na kolejne miejsce
}
std:：cout get_elem（）set_priority（prio）；//podpisujemy priority
如果（prioget|prio（）| | head==nullptr）//jesli head ma wiekszy prio niz nowe podane prio lub lista jest puss
{
temp->set_next_elem（*head）//pod temp podpiz head
head=temp；//head的临时状态（wstawienie节点）utworzenie i wstawienie nowego节点z wyzszym priorytetem
}
其他的
{
while（start_temp->get_next_elem（）！=nullptr&&start_temp->get_next_elem（）->get_prio（）get_next_elem（）；//przejdz na kolejny元素列表
}
temp->set_next_elem（*start_temp->get_next_elem（））；//wez nastepny元素（petla zakonczyla sie element wczesniej）
start_temp->set_next_elem（*temp）；//ustawia nowy节点w poprawnie wybranym miejscu
}
}

---

#包括
#包括
#包括
#包括
#包括“LinkedList.cpp”
#包括“SNode.h”
/*
模板
结构混乱(prio)
{
int_键；
类型_-mess；
};
*/
int main（）
{
int值、大小、优先级；
链接列表；
std:：cout您的代码中有几个错误：

// OP CODE
template<typename TYPE>
    SNode<TYPE>::SNode(){}

//操作码
模板
SNode:：SNode（）{}

不初始化_next_元素，使其处于无效状态。此构造函数运行后不一定为null

// OP CODE
template<typename TYPE>
SNode<TYPE>::SNode(const TYPE & elem, const SNode<TYPE>* next_elem, const int prio)
{
    _elem=elem;
    next_elem= NULL;
    _prio = prio;
}

//操作码
模板
SNode：：SNode（常量类型和元素，常量SNode*下一个元素，常量int prio）
{
_elem=elem；
next_elem=NULL；
_prio=prio；
}

在这里，您确实将其设置为null，但您正在设置函数参数，而不是成员，并且您从未从函数参数中读取。下一步，此构造函数之后的元素也未初始化

// OP CODE
template<typename TYPE>
void SNode<TYPE>::set_next_elem( SNode<TYPE>& next_elem)
{
    _next_elem = &next_elem;
}

//操作码
模板
void SNode：：设置下一个元素（SNode和下一个元素）
{
    #include <iostream>
    #include "LinkedList.h"
    
    
    //inicjuje obiekt ktory nie poakzuje na nic (NULL)
    template<typename TYPE>
    LinkedList<TYPE>::LinkedList()
    {
        head = nullptr; 
    }
    
    
    //zwraca 1 element listy
    template<typename TYPE>
    const TYPE & LinkedList<TYPE>::front() const
    {
        return head->get_elem();
    }
    
    
    template<typename TYPE>
    void LinkedList<TYPE>::addFront(const TYPE& Node, const int &prio) 
    {
    
        SNode<TYPE>* temp = new SNode<TYPE>; //tworzymy nowa zmienna do, ktorej przypiszemy wartosc podanego argumentu
        temp->set_elem(Node); //podpisujemy wartosc
        temp->set_priority(prio); //podpisujemy priority
        temp->set_next_elem(*head); //podpisuje pod adres aktualnego poczatku
        head = temp; //nowa inicjalizacja poczatku temp staje sie head
    }
    
    
    template<typename TYPE>
    void LinkedList<TYPE>::removeFront() 
    {
    
        SNode<TYPE>* temp = head; //tworzymy zmienna ktora pokazuje na head zeby nie zgubic pamieci head
        head = head->get_next_elem(); //przestawiamy head na nastepny element
    
    delete temp; //usuwamy pamiec ktora byla pod head
    
    }
    
    
    template<typename TYPE>
    void LinkedList<TYPE>::print()
    {
    SNode<TYPE>* tmp = head; //podpisanie zmiennej pod wartosc i adres head(by od pcozatku printowac liste)
    while(tmp->get_next_elem() !=nullptr ) //jesli lista nie jest pusta
        {
            std::cout << tmp->get_elem() << std::endl;  //print wartosc pod adresem tmp
            tmp = tmp->get_next_elem(); //przestaw na kolejne miejsce
        }
        std::cout << tmp->get_elem() <<std::endl;
    }
    
    
    template<typename TYPE>
    bool LinkedList<TYPE>::empty() const
    {
    if(head == nullptr) //jesli head nie pokazuje na NULL true
        return true;
    else
        return false; //jesli head jest NULL to nie ma elementow bo nic na nic nie pokazuje
    }
    
    
    template<typename TYPE>
    void LinkedList<TYPE>::add_by_priority(const TYPE& Node, const int &prio)
    {
    
    SNode<TYPE>* start_temp; //zmienna pomocnicza by wyszukac odpowiednie miejsce 
    SNode<TYPE>* temp = new SNode<TYPE>; 
    start_temp = head; //ustaw zmienna na head (poczatek listy)
    
    temp->set_elem(Node); //podpisujemy wartosc
    temp->set_priority(prio); //podpisujemy priority
    
    
        if(prio < head->get_prio() || head == nullptr) //jesli head ma wiekszy prio niz nowe podane prio lub lista jest puste
            {

                temp->set_next_elem(*head); // pod temp podpisz head
                head = temp; //temp staje sie head (wstawienie Node) utworzenie i wstawienie nowego node z wyzszym priorytetem
            }
        else
            {

        
                while(start_temp->get_next_elem() != nullptr && start_temp->get_next_elem()->get_prio() < prio) //rob dopoki nie skonczy sie lista 
                {                                                                                     //lub znajdzie priorytet wiekszy od obecnego 
                    start_temp = start_temp->get_next_elem(); //przejdz na kolejny element listy
                }
    
    
        temp->set_next_elem(*start_temp->get_next_elem()); //wez nastepny element(petla zakonczyla sie element wczesniej)
    
        start_temp->set_next_elem(*temp); //ustawia nowy node w poprawnie wybranym miejscu
    
            }
    }
    

    #include <iostream>
    #include <stdlib.h>
    #include <fstream>
    #include <string.h>
    #include "LinkedList.cpp"
    #include "SNode.h"
    
    /*
    template<typename TYPE>
    struct Mess_prio
    {
    int _key;
    TYPE _mess;
    };
    */
    
    
    int main()
        {
        
    int value,size,prio;
    LinkedList<int> list;
    
    std::cout << " Pass list size: " <<std::endl;
    std::cin >> size;
    std::cout << std::endl;
    for(int i=0; i<size; i++)
    {
    std::cout << "Enter the value: " << std::endl;
    std::cin >> value;
    std::cout << std::endl;
    std::cout << "Enter the priority: " << std::endl;
    std::cin >> prio;
    std::cout << std::endl;
    list.add_by_priority(value,prio);
    
    }
    list.print();
    
        }

// OP CODE
template<typename TYPE>
    SNode<TYPE>::SNode(){}

// OP CODE
template<typename TYPE>
SNode<TYPE>::SNode(const TYPE & elem, const SNode<TYPE>* next_elem, const int prio)
{
    _elem=elem;
    next_elem= NULL;
    _prio = prio;
}

// OP CODE
template<typename TYPE>
void SNode<TYPE>::set_next_elem( SNode<TYPE>& next_elem)
{
    _next_elem = &next_elem;
}

// OP CODE
template<typename TYPE>
bool SNode<TYPE>::operator<(SNode<TYPE> & Node) 
{
    if((*this).get_prio() > Node.get_prio())
        return true;
    return false;
}

// suggestion
template<typename TYPE>
bool SNode<TYPE>::operator<(SNode<TYPE> & Node) 
{
    return this->get_prio() > Node.get_prio();
}

// OP CODE
template<typename TYPE>
LinkedList<TYPE>::LinkedList()
{
    head = nullptr; 
}

// OP CODE
template<typename TYPE>
void LinkedList<TYPE>::addFront(const TYPE& Node, const int &prio) 
{
...
    temp->set_next_elem(*head);
}