What does the following function do for a given Linked List with first node as head?

void fun1(struct node* head) {

if(head == NULL)

return;

fun1(head->next);

printf("%d ", head->data); }

• Prints all nodes of linked lists

• 
  Prints alternate nodes of Linked List

• Prints all nodes of linked list in reverse order

• Prints alternate nodes in reverse order

Which of the following points is/are true about Linked List data structure when it is compared with array?

• Arrays have better cache locality that can make them better in terms of performance

• It is easy to insert and delete elements in Linked List

• 
  Random access is not allowed in a typical implementation of Linked Lists

• The size of array has to be pre-decided, linked lists can change their size any time

• ALL THE ABOVE

Consider the following function that takes reference to head of a Doubly Linked List as parameter.

Assume that a node of doubly linked list has previous pointer as prev and next pointer as next. 

void fun(struct node **head_ref) {

    struct node *temp = NULL;

    struct node current = head_ref;

     while (current !=  NULL)    {

        temp = current->prev;

        current->prev = current->next;

        current->next = temp;

        current = current->prev;     }

     if(temp != NULL )

        *head_ref = temp->prev; }

Assume that reference of head of following doubly linked list is passed to above function

1 <--> 2 <--> 3 <--> 4 <--> 5 <-->6.

What should be the modified linked list after the function call?

• 2 <--> 1 <--> 4 <--> 3 <--> 6 <-->5

• 6 <--> 5 <--> 4 <--> 3 <--> 2 <--> 1

• 5 <--> 4 <--> 3 <--> 2 <--> 1 <-->6.

• 6 <--> 5 <--> 4 <--> 3 <--> 1 <--> 2

Which of the following sorting algorithms can be used to sort a random linked list with minimum time complexity?

• 
  Insertion Sort

• Quick Sort

• Selection Sort

• Merge Sort

The following function reverse() is supposed to reverse a singly linked list. There is one line missing at the end of the function. 

struct node {

    int data;

    struct node* next; };

 

/* head_ref is a double pointer which points to head (or start) pointer

  of linked list */

static void reverse(struct node** head_ref) {

    struct node* prev   = NULL;

    struct node* current = *head_ref;

    struct node* next;

    while (current != NULL)     {

        next  = current->next; 

        current->next = prev;  

        prev = current;

        current = next;     }

    /*ADD A STATEMENT HERE*/

}

What should be added in place of "/*ADD A STATEMENT HERE*/", so that the function correctly reverses a linked list.

• *head_ref = prev;

• *head_ref = current;

• 
  *head_ref = next;

• *head_ref = NULL;

What is the output of following function in which start is pointing to the first node of the following linked list 1->2->3->4->5->6 ?

void fun(struct node* start) {

  if(start == NULL)

    return;

  printf("%d  ", start->data);   

  if(start->next != NULL )

    fun(start->next->next);

  printf("%d  ", start->data); }

• 1 4 6 6 4 1

• 
  1 3 5 1 3 5

• 1 3 5 5 3 1

• 1 2 3 5

The following C function takes a simply-linked list as input argument. It modifies the list by moving the last element to the front of the list and returns the modified list. Some part of the code is left blank. Choose the correct alternative to replace the blank line. 

typedef struct node {

  int value;

  struct node *next; }Node;

  

Node move_to_front(Node head) {

  Node p, q;

  if ((head == NULL: || (head->next == NULL))

    return head;

  q = NULL; p = head;

  while (p-> next !=NULL)   {

    q = p;

    p = p->next;

  }

 //FILL THE MISSING CODE HERE //

  return head;

}

• q = NULL;

  p->next = head;

  head = p;

• q->next = NULL;

  p->next = head;

  head = p;

• q->next = NULL;

  head = p;

  p->next = head;

• head = p;

  p->next = q;

  q->next = NULL;

In the worst case, the number of comparisons needed to search a singly linked list of length n for a given element is

• 
  log(2*n)

• n/2

• log(2*n)-1

• n

Answer explanation

In the worst case, the given element may not be present in the singly linked list of length n. Therefore, the search algorithm would need to traverse the entire list to determine that the element is not present.

Therefore, the number of comparisons needed to search a singly linked list of length n in the worst case is equal to n, which is the length of the list.

Suppose each set is represented as a linked list with elements in arbitrary order. Which of the operations among union, intersection, membership, cardinality will be the slowest?

• union

• membership

• union, intersection

• cardinality

Answer explanation

Cardinality and membership are definitely not the slowest one. For cardinality, just count the number of nodes in a list. For membership, just traverse the list and look for a match
For getting intersection of L1 and L2, search for each element of L1 in L2 and print the elements we find in L2. 
There can be many ways for getting union of L1 and L2. One of them is as follows 
a) Print all the nodes of L1 and print only those which are not present in L2. 
b) Print nodes of L2.

Consider the function f defined below. 

struct item

{

  int data;

  struct item * next; };

 

int f(struct item *p) {

  return (       

    (p == NULL) ||           (p->next == NULL) ||    (( p->data <= p->next->data) && f(p->next))  

 );

}

• not all elements in the list have the same data value.

• the elements in the list are sorted in non-decreasing order of data value

• 
  the elements in the list are sorted in non-increasing order of data value

• None of the Above

Answer explanation

The function checks if the current element is less than or equal to the next element, and recursively applies the same check to the next element. If the end of the list is reached (i.e., p->next is NULL), or the next element is less than the current element, the function returns 1. Otherwise, it returns 0. Therefore, the function returns 1 only if the linked list is sorted in non-decreasing order.