Question

Please help me on all the questions !!!!!!!! Really need help! Will give a thumb up for helping.

Short Answer (6)

1. Explain why a public method should be declared to be final if it is called by a constructor.

2. In the linked implementation of a list, why shouldn’t the constructor call the method clear even

   though they do the same exact assignment statements?

3. Outline the basic steps to add a node to the end of a linked implementation of a list.

4. Outline the basic steps to add a node to the beginning of an empty linked implementation of a

   list.

5. Outline the basic steps to add a node to the beginning of a non-empty linked implementation of

   a list.

6. Outline the basic steps to remove a node from the beginning of a list.

Answer 1

Ans 1.  

When a method is declared with finalkeyword, it is called a final method. A final method cannot be overridden. The Objectclass does this—a number of its methods are final.We must declare methods with final keyword for which we required to follow the same implementation throughout all the derived classes. The following fragment illustrates final keyword with a method:

class A 
{
    final void m1() 
    {
        System.out.println("This is a final method.");
    }
}

class B extends A 
{
    void m1()
    { 
        // COMPILE-ERROR! Can't override.
        System.out.println("Illegal!");
    }
}

Ans 2. Because constructor is executed only during initalisation of object.

Ans 3.  Add a node at the end: (6 steps process)
The new node is always added after the last node of the given Linked List. For example if the given Linked List is 5->10->15->20->25 and we add an item 30 at the end, then the Linked List becomes 5->10->15->20->25->30.
Since a Linked List is typically represented by the head of it, we have to traverse the list till end and then change the next of last node to new node.

Following are the 6 steps to add node at the end.It is in the form of C code.

/* Given a reference (pointer to pointer) to the head

   of a list and an int, appends a new node at the end */

void append(struct Node** head_ref, int new_data)

{

    /* 1. allocate node */

    struct Node* new_node = (struct Node*) malloc(sizeof(struct Node));

  

    struct Node *last = *head_ref; /* used in step 5*/

   

    /* 2. put in the data */

    new_node->data = new_data;

  

    /* 3. This new node is going to be the last node, so make next

          of it as NULL*/

    new_node->next = NULL;

  

    /* 4. If the Linked List is empty, then make the new node as head */

    if (*head_ref == NULL)

    {

       *head_ref = new_node;

       return;

    }  

  /* 5. Else traverse till the last node */

    while (last->next != NULL)

        last = last->next;

   

    /* 6. Change the next of last node */

    last->next = new_node;

    return;    

}

Time complexity of append is O(n) where n is the number of nodes in linked list. Since there is a loop from head to end, the function does O(n) work.
This method can also be optimized to work in O(1) by keeping an extra pointer to tail of linked list/

Ans 4. Add node at front of empty link list .

Simply initalise head as the value to be added in link list .

Ans 5.

Add a node at the front: (A 4 steps process)
The new node is always added before the head of the given Linked List. And newly added node becomes the new head of the Linked List. For example if the given Linked List is 10->15->20->25 and we add an item 5 at the front, then the Linked List becomes 5->10->15->20->25. Let us call the function that adds at the front of the list is push(). The push() must receive a pointer to the head pointer, because push must change the head pointer to point to the new node (See this)

Following are the 4 steps to add node at the front in form of C code :

C

/* Given a reference (pointer to pointer) to the head of a list    and an int, inserts a new node on the front of the list. */ void push(struct Node** head_ref, int new_data) {     /* 1. allocate node */     struct Node* new_node = (struct Node*) malloc(sizeof(struct Node));         /* 2. put in the data */     new_node->data = new_data;         /* 3. Make next of new node as head */     new_node->next = (*head_ref);         /* 4. move the head to point to the new node */     (*head_ref)    = new_node; } Time complexity of push() is O(1) as it does constant amount of work. Ans 6. To remove first node, we need to make second node as head and delete memory allocated for first node. // CPP program to remove first node of // linked list. #include <iostream> using namespace std;    /* Link list node */ struct Node {     int data;     struct Node* next; };    /* Function to remove the first node    of the linked list */ Node *removeFirstNode(struct Node* head) {     if (head == NULL)        return NULL;        // Move the head pointer to the next node     Node *temp = head;     head = head->next;          delete temp;        return head; }    // Function to push node at head void push(struct Node** head_ref, int new_data) {     struct Node* new_node = new Node;     new_node->data = new_data;     new_node->next = (*head_ref);     (*head_ref) = new_node; }    // Driver code int main() {     /* Start with the empty list */     Node* head = NULL;        /* Use push() function to construct          the below list 8 -> 23 -> 11 -> 29 -> 12 */     push(&head, 12);     push(&head, 29);     push(&head, 11);     push(&head, 23);     push(&head, 8);        head = removeFirstNode(head);     for (Node *temp = head; temp != NULL; temp = temp->next)        cout << temp->data << " ";        return 0; } Kindly please do upvote. We are working very hard to provide you with best content. Upvoting is very essential for sustaining us. Kindly upvote please .