Сортировка в двусвязном списке

---

Проблема:

Определите класс RegularPolygon для представления правильного многоугольника с различным числом сторон. Теперь, в вашем классе,

Объявите закрытые поля (данные членов) для представления следующих данных:

. Целое число для представления отсутствия сторон

. Еще одно целое число для представления длины стороны

Определите следующие открытые методы (функции-члены) для:

.установите значение по умолчанию полигонального объекта с помощью конструктора

.получить значения полигона (для объекта клиента)

.отображение периметра, площади и имени полигона (для объекта клиента)

---------------------------------------------------------------------------------------------------------------------------------------------------------------

Теперь определите другой класс для представления узла двусвязного списка. В вашем классе,

Объявите следующие поля:

.Объект RegularPolygon

.Два самореферентных указателя в качестве ссылки на предыдущий и следующий узлы

Определите следующие методы (Примечание: имейте в виду, что узел содержит объект RegularPolygon):

.Метод вставки узла в начало списка

.Метод вставки узла в конец списка

.Метод вставки узла в качестве n-го узла списка (n - это ввод пользователя)

.Метод удаления узла из начала списка

.Метод удаления узла из конца списка

.Метод удаления n-го узла из списка (n - это ввод пользователя)

.Метод возврата суммарных площадей всех полигонов (из узлов)

.Метод поиска полигонов, имеющих определенную площадь a (a - это ввод пользователя) и отображения их (если они найдены)

.Метод поиска полигонов с определенным периметром p (p-это пользовательский ввод) и отображения их (если они найдены)

.Метод возврата средней площади полигонов (из узлов)

.Метод возврата среднего периметра полигонов (из узлов)

.Метод сортировки узлов связанного списка по областям. Если области одинаковы, то ни по одной из сторон

.Метод отображения полигонов (из узлов) в прямой последовательности из списка

.Метод отображения полигонов (из узлов) в обратной последовательности из списка


Я застрял на " методе сортировки узлов связанного списка на основе областей. Если области одинаковы, то ни по одной из сторон"

Каким будет код для этого..

вот мой код ...

Что я уже пробовал:

#include<iostream>
#include <math.h>
using namespace std;

class RegularPolygon
{

    float s,n;

public:
    void setRegularPolygonData(){
        cout<<"Input the number of sides of the polygon (maximum 12): ";
        cin>>n;
        cout<<"Input the length of each side of the polygon: ";
        cin>> s;

    }
    void display(){
        if(n==3){
            cout<<"This is a Triangle"<<"\n";
            cout<<"The area of the ploygon is: "<<(n * (s * s)) / (4.0 * tan((M_PI / n)))<<"\n";
	        cout<<"The perimeter of the ploygon is: "<<n*s<<"\n";
        }
        else if(n==4){
            cout<<"This is a Square"<<"\n";
            cout<<"The area of the ploygon is: "<<(n * (s * s)) / (4.0 * tan((M_PI / n)))<<"\n";
	        cout<<"The perimeter of the ploygon is: "<<n*s<<"\n";
        }
        else if(n==5){
            cout<<"This is a Pentagon"<<"\n";
            cout<<"The area of the ploygon is: "<<(n * (s * s)) / (4.0 * tan((M_PI / n)))<<"\n";
	        cout<<"The perimeter of the ploygon is: "<<n*s<<"\n";
        }
        else if(n==6){
            cout<<"This is a Hexagon"<<"\n";
            cout<<"The area of the ploygon is: "<<(n * (s * s)) / (4.0 * tan((M_PI / n)))<<"\n";
	        cout<<"The perimeter of the ploygon is: "<<n*s<<"\n";
        }
        else if(n==7){
            cout<<"This is a Heptagon"<<"\n";
            cout<<"The area of the ploygon is: "<<(n * (s * s)) / (4.0 * tan((M_PI / n)))<<"\n";
	        cout<<"The perimeter of the ploygon is: "<<n*s<<"\n";
        }
        else if(n==8){
            cout<<"This is a Octagon"<<"\n";
            cout<<"The area of the ploygon is: "<<(n * (s * s)) / (4.0 * tan((M_PI / n)))<<"\n";
	        cout<<"The perimeter of the ploygon is: "<<n*s<<"\n";
        }
        else if(n==9){
            cout<<"This is a Nonagon"<<"\n";
            cout<<"The area of the ploygon is: "<<(n * (s * s)) / (4.0 * tan((M_PI / n)))<<"\n";
	        cout<<"The perimeter of the ploygon is: "<<n*s<<"\n";
        }
        else if(n==10){
            cout<<"This is a Decagon"<<"\n";
            cout<<"The area of the ploygon is: "<<(n * (s * s)) / (4.0 * tan((M_PI / n)))<<"\n";
	        cout<<"The perimeter of the ploygon is: "<<n*s<<"\n";
        }
        else if(n==11){
            cout<<"This is a Undecagon"<<"\n";
            cout<<"The area of the ploygon is: "<<(n * (s * s)) / (4.0 * tan((M_PI / n)))<<"\n";
	        cout<<"The perimeter of the ploygon is: "<<n*s<<"\n";
        }
        else if(n==12){
            cout<<"This is a Dodecagon"<<"\n";
            cout<<"The area of the ploygon is: "<<(n * (s * s)) / (4.0 * tan((M_PI / n)))<<"\n";
	        cout<<"The perimeter of the ploygon is: "<<n*s<<"\n";
        }
    }
};

class DoublyLLNode{
    RegularPolygon c;
    DoublyLLNode *prev, *next;
public:
    RegularPolygon & RegularPolygonObject(){
        return c;
    }
    DoublyLLNode*& getNext(){
        return next;
    }
    DoublyLLNode*& getPrev(){
        return prev;
    }
};

void addNodeAtTail(DoublyLLNode*& h, DoublyLLNode*& t){
    if(h==NULL){
        h = new DoublyLLNode;
        t = h;
        h->RegularPolygonObject().setRegularPolygonData();
        h->getNext()=NULL;
        h->getPrev()=NULL;
    }
    else {
       t->getNext() = new DoublyLLNode;

       t->getNext()->getPrev() = t;
       t = t->getNext();
       t->RegularPolygonObject().setRegularPolygonData();
       t->getNext()= NULL;
    }
}

void addNodeAtHead(DoublyLLNode*& h, DoublyLLNode*& t){
    if(h==NULL){
        h = new DoublyLLNode;
        t = h;
        h->RegularPolygonObject().setRegularPolygonData();
        h->getNext()=NULL;
        h->getPrev()=NULL;
    }
    else {
        DoublyLLNode *temp = h;
        h = new DoublyLLNode;
        h->getNext() = temp;
        h->getPrev() = NULL;
        temp->getPrev() = h;
        h->RegularPolygonObject().setRegularPolygonData();
    }
}

void addNodeAtNthPos(DoublyLLNode*& h, DoublyLLNode*& t, int pos){
    int noOfNodes=0;
    DoublyLLNode *curr=h;
    while(curr!=NULL){
        noOfNodes++;
        curr = curr->getNext();
    }

    if(pos<0 || noOfNodes < pos-1){
        cout<<"Invalid position!"<<endl;
        return;
    }


    if(pos==1)
        addNodeAtHead(h,t);
    else if(noOfNodes == pos-1)
        addNodeAtTail(h,t);
    else{
        int count=1; curr=h;

        while(count != pos-1){
            curr=curr->getNext();
            count++;
        }

       
        curr->getNext()->getPrev() = new DoublyLLNode;
        curr->getNext()->getPrev()->getPrev()=curr;
        curr->getNext()->getPrev()->getNext()=curr->getNext();
        curr->getNext() = curr->getNext()->getPrev();

        curr->getNext()->RegularPolygonObject().setRegularPolygonData();


    }
}

void deleteFirstNode(DoublyLLNode*& h, DoublyLLNode*& t){
    if(h==NULL){
        cout<<"The list is empty! Nothing to delete."<<endl;
        return;
    }
    if(h==t){
        delete h;
        h = t = NULL;
    }
    else {
        h = h->getNext();
        delete h->getPrev();
        h->getPrev() = NULL;
    }
}

void deleteLastNode(DoublyLLNode*& h, DoublyLLNode*& t){
    if(h==NULL){
        cout<<"The list is Empty! Nothing to display..."<<endl;
    }
     if (h==t){
        delete h;
        h = t = NULL;
    }
    else if{
        DoublyLLNode *temp = t->getPrev();
        delete t;
        t=temp;
        t->getNext()= NULL;
    }
}


void displayInForwardSequence(DoublyLLNode *current){
    if(current==NULL)
        cout<<"The list is empty! Nothing to display."<<endl;
    else{
        while(current != NULL)
        {
            current->RegularPolygonObject().display();
            current = current->getNext();
        }
    }
}


int main(){
    DoublyLLNode *head=NULL, *tail=NULL;
    int ch, position;
    do{
        cout<<"Enter [1] to insert a Node at the end."<<endl;
        cout<<"Enter [2] to insert a Node at the beginning."<<endl;
        cout<<"Enter [3] to insert a Node at n-th position."<<endl;

        cout<<"Enter [4] to delete first Node."<<endl;
        cout<<"Enter [5] to delete last Node."<<endl;
        //cout<<"Enter [6] to delete n-th Node."<<endl;

        cout<<"Enter [7]-> to display nodes in forward sequence"<<endl;
        //cout<<"Enter [8]-> to display nodes in backward sequence"<<endl;
        cout<<"Enter [9]-> to Exit: ";
        cin>>ch;
        switch(ch)
        {
         case 1: addNodeAtTail(head, tail);break;
         case 2: addNodeAtHead(head, tail);break;
         case 3: cout<<"Enter position of new Node: ";
                 cin>>position;
                 addNodeAtNthPos(head, tail, position);break;
         case 4: deleteFirstNode(head, tail);break;
         case 5: deleteLastNode(head, tail);break;
         case 6: //deleteNthNode(head, tail);break;
         case 7: displayInForwardSequence(head);break;
         case 8: //displayInBackwardSequence(tail);
             break;
        }
    }while(ch != 9);
    return 0;
}

---