Consider the C code fragment given below-typedef struct node int data- node- next- node-void join node- m- node- n node- p - n- while p- next - NULL p - p - next- p - next - m-Assuming that m and n point to valid NULL - terminated linked lists- invocation of join will

You visited us 1 times! Enjoying our articles? Unlock Full Access!

Encoding and Decoding Patterns

Consider the ...

Question

Consider the C code fragment given below:

typedef struct node
{
int data;
node* next;
} node;
void join (node* m, node* n)
{
node* p = n;
while (p $\to$ next != NULL)
{
p = p $\to$ next;
}
p $\to$ next = m;
}

Assuming that m and n point to valid NULL - terminated linked lists, invocation of join will

cause a null pointer dereference for all inputs.

No worries! We‘ve got your back. Try BYJU‘S free classes today!

either cause a null pointer dereference or append list m to the end of list n.

Right on! Give the BNAT exam to get a 100% scholarship for BYJUS courses

append list m to the end of list n for all inputs.

No worries! We‘ve got your back. Try BYJU‘S free classes today!

append list n to the end of list m for all inputs.

No worries! We‘ve got your back. Try BYJU‘S free classes today!

Open in App

Solution

The correct option is B either cause a null pointer dereference or append list m to the end of list n.
Consider two linked lists:

After the code execution, list 'm' will be appended to the end of list 'n'. But in some cases it can cause all pointer dereferenced also.

Suggest Corrections

Similar questions

Q. The following C function takes a singly-linked list as input argument. It modified by 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.

typed of struct node
{
int value;
struct node * next;
} Node;
Node *mode_to_ front(Node *head)
{
Node *p, *q;
if((head == NULL)

∥

(head

\to

next == NULL))
return head;
q = NULL;
p = head;
while (p

\to

next != NULL)
{
q = p;
p = p

\to

next;
}
______________________
return head;
}

Choose the correct alternative to replace the blank line.

Q. The following C function takes a singly-linked list of integers as a parameter and rearranges the elements of the list. The list is represented as pointer to a structure. The function is called with the list containing the integers 1, 2, 3, 4, 5, 6, 7 in the given order.

What will be the contents of the list after the function completes execution?

struct node
{
int value;
struct node *next;
};
void rearrange (struct node *list)
{
struct node *p, *q;
int temp;
if (!list

∣

∣

!list

\to

next)
return;
p = list;
q = list

\to

next;
while (q)
{
temp = p

\to

value;
p

\to

value = q

\to

value;
q

\to

value = temp;
p = q

\to

next;
q = p ? p

\to

next : 0;
}
}

Q. Consider the function f defined below:

struct item
{
int data;
struct item *next;
};
int f(struct item *p)
{
return (
(p == NULL)

∥

\to

next == NULL

∥

((p

\to

data <= p

\to

\to

data )
&& f(p

\to

next))
);
}

For a given linked list p, the function f returns 1 if and only if

Q. Consider the following ANSI C program:

#include <stdio.h>
#include <stdlib.h>
struct Node
{
int value;
struct Node *next;
};
int main( )
{
struct Node *boxE, *head, *boxN;
int index = 0;
boxE = head = (strcut Node *) malloc(sizeof (struct Node));
head

\to

value = index;
for (index = 1; index <=3; index++){
boxN = (struct Node *) malloc (sizeof (struct Node));
boxE

\to

next = boxN;
boxN

\to

value = index;
boxE = box N;}
for (index = 0; index <= 3; index ++)
{
printf("Value at index %d is %d\n", index, head

\to

value);
head = head

\to

next;
printf("Value at index %d is %d\n", index + 1, head

\to

value);
}
}

Which one of the statements below is correct about the program?

Q. A circular queue has been implemented using a singly linked list where each node consists of a value and a single pointer pointing to the next node. We maintain exactly two external pointers FRONT and REAR pointing to the front node
and the rear node of the queue, respectively. Which of the following statements is/are CORRECT for such a circular queue, so that insertion and deletion operations can be performed in O(1) time?
I . Next pointer of front node points to the rear node.
II . Next pointer of rear node points to the front node.

Join BYJU'S Learning Program

Consider the C code fragment given below: typedef struct node { int data; node* next; } node; void join (node* m, node* n) { node* p = n; while (p→ next != NULL) { p = p → next; } p → next = m; } Assuming that m and n point to valid NULL - terminated linked lists, invocation of join will

The correct option is B either cause a null pointer dereference or append list m to the end of list n. Consider two linked lists: After the code execution, list 'm' will be appended to the end of list 'n'. But in some cases it can cause all pointer dereferenced also.

The correct option is B either cause a null pointer dereference or append list m to the end of list n.
Consider two linked lists:

After the code execution, list 'm' will be appended to the end of list 'n'. But in some cases it can cause all pointer dereferenced also.