Blog: CS301 Assignment Solution No. 2

    #include <iostream>
    #include <conio.h>
    using namespace std;
    // Node Class
    class Node{
    public:
    void set_next(Node* next_node){Next_Node = next_node;}
    Node * get_next(){return Next_Node;}
    char * get_name(){return nod_name;}
    void set_objects(int,int);
    void set_name(char*);
    int get_objects(int);
    void set_sum(int sums){sum = sums;}
    int get_sum(){return sum;}
    ~Node(){};
    private:
    int sum;
    char *nod_name;
    int objects[6];
    Node * Next_Node;

    };
    void Node::set_name(char* name){
    nod_name = new char[strlen(name+1)];
    strcpy(nod_name,name);
    }
    void Node::set_objects(int obj,int indux)
    {

    objects[indux] = obj;

    }
    int Node::get_objects(int indux)
    {
    return objects[indux];
    }
    // End Of Node Class
    // Class List
    class List{
    public:
    List();
    void sort(Node*,int);
    void display(int);
    void get_input(int,Node*);
    int get(int);
    void add(int[],Node*);

    private:
    int size;
    Node * Head_Node;
    Node * Current_Node;
    Node * Last_Current_Node;

    };
    List::List()
    {
    size = 0;
    Head_Node = new Node();
    Head_Node->set_next(NULL);
    Current_Node = NULL;
    Last_Current_Node = NULL;
    }
    void List::sort(Node * sort_node, int number_nodes)
    {
    char temp_name[25];
    Current_Node = Head_Node;
    int * sum = new int[number_nodes];
    for(int i=0;i<number_nodes;i++)
    {
    sum[i] = 0;
    if(Current_Node != NULL)
    {
    for(int a=0;a<6;a++)
    {
    sum[i] += this->Current_Node->get_objects(a);
    }
    }
    Current_Node->set_sum(sum[i]);
    Current_Node = Current_Node->get_next();

    }
    Current_Node = Head_Node;
    Last_Current_Node = Head_Node->get_next();
    int temp = 0;
    // Sorting Nodes
    for(int i=0;i<number_nodes;i++)
    {

    for(int a=0;a<number_nodes;a++)
    {

    if(Current_Node != NULL && Last_Current_Node != NULL)
    {

    if(Current_Node->get_sum() < Last_Current_Node->get_sum())
    {
    // Swaping Nodes Value and Name in ascending Order
    temp = Current_Node->get_sum();
    strcpy(temp_name , Current_Node->get_name());
    Current_Node->set_sum(Last_Current_Node->get_sum());
    Current_Node->set_name(Last_Current_Node->get_name());
    Last_Current_Node->set_sum(temp);
    Last_Current_Node->set_name(temp_name);

    }

    Last_Current_Node = Last_Current_Node->get_next();
    }
    else
    {
    break; // if Last current node or current node becoms Null stop Inner Loop
    }

    }
    Last_Current_Node = Head_Node;
    Current_Node = Current_Node->get_next();

    }
    }

    void List::display(int number_nods)
    {
    Current_Node = Head_Node;
    if(Current_Node != NULL)
    {
    cout"List Size = "sizeendl;
    for(int a=0;a<number_nods;a++)
    {
    cout'\n'endl;
    cout'\t'"Elements Of: "a+1'\t'Current_Node->get_name()endl;

    Current_Node = Current_Node->get_next();
    }
    }
    }

    void List::get_input(int number_nod,Node * Nodes)
    {
    int f = 0;
    char arrs[25];
    for(int i=0;i<number_nod;i++)
    {
    int arr[6] = {0};
    cout"Enter The Name OF the Node: ";
    cin>>arrs;
    Nodes[i].set_name(arrs);
    for(int a=0;a<6;a++)
    {
    f = 0;
    cout"enter Elements "a+1": ";
    cin>>arr[a];
    for(int j=0;j<6;j++)
    {
    if(arr[a] == arr[j])
    {

    f++;

    }
    }
    if(f > 1)
    {

    coutarr[a]" Dublicated"endl;
    a--;
    continue; // if number Dublicated Contine the itration and decrement the Loop counter by 1
    }

    }
    coutendl;
    cout"Node Value Finshed"endlendl;
    this->add(arr,&Nodes[i]);

    }

    }

    int List::get(int Indux)
    {
    return Current_Node->get_objects(Indux);
    }
    void List::add(int objests[],Node * nodss)
    {

    for(int i=0;i<6;i++)
    {
    nodss->set_objects(objests[i],i);
    }

    if(Current_Node == NULL)
    {

    nodss->set_next(NULL);
    Head_Node->set_next(nodss);
    Last_Current_Node = Head_Node;
    Current_Node = nodss;
    Head_Node = Current_Node;

    }
    else
    {
    nodss->set_next(Current_Node->get_next());
    Current_Node->set_next(nodss);
    Last_Current_Node = Current_Node;
    Current_Node = nodss;
    }
    size++;

    }
    int main()
    {
    List list;
    int number_nods = 0;
    cout"How many Nodes You want to Create: ";
    cin>>number_nods;
    Node * Nodes = new Node[number_nods];
    list.get_input(number_nods,Nodes);
    list.sort(Nodes,number_nods);
    list.display(number_nods);
    delete [] Nodes;
    _getch();
    }