优先级调度程序的实现作为双向链表的子类

Question

我正在将调度程序的实现作为队列的子类。我的函数工作正常，但就我所知的课程工作而言，排序和抗锁算法应从NodeDequeue的Scheduler版本调用。

当我从该功能代码调用时，调试器无法正常工作，快速排序和防盗锁功能无法访问代码的各个部分。

是否可以通过NodeDequeue进行程序工作和调用排序，或者您是否有其他方法可以使其正常工作？

class Node
{
public:

Node(int value, Node* nextptr = nullptr, Node* prevptr = nullptr, int     currentpriority = 0)
{
    this->value=value;
    next = nextptr;
    prev = prevptr;
    priority = currentpriority;

}

int getVal(void)
{
    return value;
}

Node* getNext(void)
{
    return next;
}

Node* getPrev(void)
{
    return prev;
}

void setVal(int value)
{
    this->value = value;
}

void setPrev(Node* prevptr)
{prev = prevptr; };

void setNext(Node* nextptr)
{
    next = nextptr;
}

int getPriority(void)
{
    return priority;
}

void setPriority(int priority)
{
    this->priority = priority;
}

private:
Node* next;
Node* prev;
int priority;
int value;
};

class Stack
{
public:
Stack(void) 
{
    top = nullptr;
}


~Stack(void)
{
    while (NodePop() != nullptr);
}

void Push(int value)
{
    Node* tmp = new Node(value,top);   
    top = tmp;
}

Node* NodePop(void)
{
    Node* tmp = top;
    if (top != nullptr) top = top->getNext();
    return tmp;
}

int Pop(void)
{
    Node* tmp = NodePop();
    int ret = 0;
    if (tmp != nullptr)
    { 
        ret = tmp->getVal();
    }

    else 
    {
        throw "Stack Empty";
    }
    delete tmp;
    return ret;
}

private:

Node* top;
};

class Queue
{
public:
Queue(void)
{
    back = front = nullptr;
}

~Queue(void)
{
    while (NodeDequeue() != nullptr);
}

void Enqueue(int i, int priority = 0)
{
    Node* tmp = new Node(i, back, nullptr, priority);
    back = tmp;
    if (front == nullptr) front = back;
    else
    {
        tmp = back->getNext();
        tmp->setPrev(back);
    }
}

int Dequeue(void)
{
    Node* tmp = NodeDequeue();
    int ret = 0;
    if (tmp != nullptr)
    {
        ret = tmp->getVal();
    }
    else
    {
        throw "Queue Empty";
    }
    if (front == nullptr) back = front; // queue now empty
    delete tmp;
    return ret;
}

protected:

Node* back;
Node* front;

private:

virtual Node* NodeDequeue(void)
{
    Node* tmp = front;
    if (front != nullptr)
    {
        front = front->getPrev();
        if (front != nullptr) front->setNext(nullptr);
    }
    return tmp;
}
};


class Scheduler : public Queue
{

public:


private:

Node* NodeDequeue(void)
{
    Node* tmp = front;
    quicksort();
    antiBlock();
    if (front != nullptr)
    {
        front = front->getPrev();
        if (front != nullptr) front->setNext(nullptr);
    }
    return tmp;
}

int cycle = 0;

    void EnqueueFront(int i, int priority = 0)
{
    Node* tmp = new Node(i, nullptr, front, priority);
    front = tmp;
    if (back == nullptr) back = front;
    else
    {
        tmp = front->getPrev();
        tmp->setNext(front);
    }

}


Node* NodeDequeueBack(void)
{
    Node* tmp = back;
    if (back != nullptr)
    {
        back = back->getNext();
        if (back != nullptr) back->setPrev(nullptr);
    }
    return tmp;
}



int DequeueBack(void)
{
    Node* tmp = NodeDequeueBack();
    int ret = 0;
    if (tmp != nullptr)
    {
        ret = tmp->getVal();
    }
    else
    {
        throw "Queue Empty";
    }
    if (back == nullptr) front = back; // queue now empty
    delete tmp;
    return ret;
}
void quicksort()
{
    Enqueue(0);
    EnqueueFront(0);
    partition(back, front);
    Dequeue();
    DequeueBack();
}

void partition(Node * left, Node * right)
{
    Node *p, *i, *j;
    p = left->getNext();
    i = p->getNext();
    if (i != right)
    {
        do
        {

            j = i;
            i = i->getNext();
            if (j->getPriority() < p->getPriority())
            {
                j->getPrev()->setNext(j->getNext());
                j->getNext()->setPrev(j->getPrev());
                j->setNext( p);

                j->setPrev( p->getPrev());
                p->setPrev( j);
                j->getPrev()->setNext( j);

            }
        } while (i != right);
        if (left->getNext() != p) partition(left, p);
        if (p->getNext() != right) partition(p, right);
    }
}
Node* split()
{

         Node *singleJump = back, *doubleJump = back;
        while (singleJump->getNext() && doubleJump->getNext()->getNext())
        {
            doubleJump = doubleJump->getNext()->getNext();
            singleJump = singleJump->getNext();
        }
        Node *temp = singleJump->getNext();
        singleJump->getNext()->setNext(nullptr);
        return temp;
}

void antiBlock()
{
    cycle++;
    if (cycle == 5)
    {
        Node* temp = split();
        while (temp != front)
        {
            if (temp->getPriority() < 10)

                temp->setPriority(temp->getPriority() + 1);

        }
        cycle = 0;
    }
}


};



int main()
{

    Scheduler* s= new Scheduler;
    s->Enqueue(1,5);
    s->Enqueue(2, 6);
    s->Enqueue(3, 1);
    s->Enqueue(4, 8);
    s->Enqueue(5, 9);
    s->Enqueue(6, 10);
    s->Enqueue(7, 6);
    s->Enqueue(8, 3);
    s->Enqueue(9, 2);
    s->Enqueue(10, 7);
    s->Enqueue(11, 4);
    s->Enqueue(12, 8);
    s->Enqueue(13, 3);
    s->Enqueue(14, 6);
    s->Enqueue(15, 2);
    s->Enqueue(16,7);
    //s->quicksort();
    for (int i = 0; i < 16; i++)
    cout<<  s->Dequeue();

    return 0;


};