#include "list.h"    

#include <iostream>

using namespace std;

 

// Qustion#5:

// What is the purpose of list :: list()? In what situation would it be called?

// If we remove the only line of the code in its implementation below from it,

// what would go wrong when we use list objects?

list :: list()

{   head = NULL;

}

 

// Qustion#6:

// What is the purpose of list :: ~list()? In what situation would it be called?

// If we remove all lines of the code in its implementation below from it,

// what would go wrong when we use list objects?

list :: ~list()

{   listNode * temp;  

    while (head)  

       {       temp=head->next;     

               delete head;     

                        head=temp;  

       }

}

 

// Qustion#7:

// What is the value of temp when the while loop in the code stops?

void list::display()

{   listNode * temp=head;  

    while(temp)  

    {   cout<<temp->value<<endl;    

       temp=temp->next;  

    }

}

 

// Qustion#8:

// If Val equals to none of the values stored in the value field of the nodes

// of the linked list, what would be the value of temp when the while loop in the code stops?

// If Val equals to the value stored in the value field of one of the nodes

// of the linked list, what would be the value of temp when the while loop of code stop?

bool list:: search(int Val)

{   listNode * temp=head;  

    while(temp && temp->value != Val)    

       temp=temp->next;  

    if (temp)    

       return true;  

    else    

       return false;

}

 

// Qustion#9:

// What would go wrong if we replace the first line of the code simply as

// listNode * temp;

// ?

void list :: insert(int Val)

{   listNode * temp = new listNode;  

    temp->value = Val;  

    temp->next = head;  

    head = temp;

}

 

// Qustion#10:

// We know that list::insertInOrder should be used for insertion

// if we intend to maintain a linked list

// with nodes storing values in ascending order.

// Given a sorted linked list,

// if Val is less than the value stored in the value field of the first node

// of the linked list, what nodes would Prev and Curr point to respectively

// immediately after the while loop in the code terminates?

// if Val is greater than the value stored in the value field of the last node

// of the linked list, what nodes would Prev and Curr point to respectively

// immediately after the while loop in the code terminates?

 

void list::insertInOrder(int Val)

{   listNode * Curr = head;  

    listNode * Prev = NULL;  

    listNode * temp = new listNode;  

    temp->value = Val;  

    // Loop through list until end or item is found  

    while((Curr) && (Curr->value < Val))   

    {      Prev =  Curr;      Curr = Curr->next;  

    }  

 

    //Perform the actual insert  

    temp->next = Curr;  

    if (Prev)  //Inserting in the middle of the list    

       Prev->next = temp;  

    else  //Inserting into the front of the list    

       head = temp;

}  

 

 

// Qustion#11:

// What would happen if more than one nodes in the linked list store a value equal to Val?

// Would all these nodes be removed by list::remove(int Val)?

// If not, show how you may modify the code to achieve it.

void list::remove(int Val)   

{   listNode * Curr = head;     

    listNode * Prev = NULL;         

    while(Curr)      

    {        

       if (Curr->value == Val)        

       {   if (Prev == NULL) //Removing first node;

               head = Curr->next;         

           else //Removing a normal node;             

               Prev->next = Curr->next;          

           delete Curr; //In either case         

           return;      

       }        

       else //move to the next item in the list      

       {   Prev = Curr;            

           Curr = Curr->next;      

       }     

    }

}