Wednesday, December 28, 2011

Linked Lists FAQ with Example solutions

How do you reverse a singly linked list? How do
you reverse a doubly linked list? Write a C program to do the
same.

Given only a pointer to a node to be deleted in
a singly linked list, how do you delete it?

How do you sort a linked list? Write a C program
to sort a linked list.

How to declare a structure of a linked list?

Write a C program to implement a Generic Linked
List.

How do you reverse a linked list without using
any C pointers?

How would you detect a loop in a linked list?
Write a C program to detect a loop in a linked list.

How do you find the middle of a linked list?
Write a C program to return the middle of a linked list

If you are using C language to implement the
heterogeneous linked list, what pointer type will you use?

How to compare two linked lists? Write a C
program to compare two linked lists.

How to create a copy of a linked list? Write a C
program to create a copy of a linked list.

Write a C program to free the nodes of a linked
list?

Can we do a Binary search on a linked list?

Write a C program to return the nth node from
the end of a linked list

How would you find out if one of the pointers in
a linked list is corrupted or not? Write a C program to do the same.

Here are a few C programs to reverse a singly linked list.

Method1 (Iterative)

#include <stdio.h>

// Variables

typedef struct node

{

int value;

struct node *next;

}mynode;

// Globals (not required, though).

mynode *head, *tail, *temp;

// Functions

void add(int value);

void iterative_reverse();

void print_list();

// The main() function

int main()

{

head=(mynode *)0;

// Construct the linked list.

add(1);

add(2);

add(3);

//Print it

print_list();

// Reverse it.

iterative_reverse();

//Print it again

print_list();

return(0);

}

// The reverse function

void iterative_reverse()

{

mynode *p, *q, *r;

if(head == (mynode *)0)

{

return;

}

p = head;

q = p->next;

p->next = (mynode *)0;

while (q != (mynode *)0)

{

r = q->next;

q->next = p;

p = q;

q = r;

}

head = p;

}

// Function to add new nodes to the linked list

void add(int value)

{

temp = (mynode *) malloc(sizeof(struct node));

temp->next=(mynode *)0;

temp->value=value;

if(head==(mynode *)0)

{

head=temp;

tail=temp;

}

else

{

tail->next=temp;

tail=temp;

}

}

// Function to print the linked list.

void print_list()

{

printf("\n\n");

for(temp=head; temp!=(mynode *)0; temp=temp->next)

{

printf("[%d]->",(temp->value));

}

printf("[NULL]\n\n");

}

Method2 (Recursive, without using any temporary variable)

#include <stdio.h>

// Variables

typedef struct node

{

int value;

struct node *next;

}mynode;

// Globals.

mynode *head, *tail, *temp;

// Functions

void add(int value);

mynode* reverse_recurse(mynode *root);

void print_list();

// The main() function

int main()

{

head=(mynode *)0;

// Construct the linked list.

add(1);

add(2);

add(3);

//Print it

print_list();

// Reverse it.

if(head != (mynode *)0)

{

temp = reverse_recurse(head);

temp->next = (mynode *)0;

}

//Print it again

print_list();

return(0);

}

// Reverse the linked list recursively

//

// This function uses the power of the stack to make this

// *magical* assignment

//

// node->next->next=node;

//

// :)

mynode* reverse_recurse(mynode *root)

{

if(root->next!=(mynode *)0)

{

reverse_recurse(root->next);

root->next->next=root;

return(root);

}

else

{

head=root;

}

}

// Function to add new nodes to the linked list.

void add(int value)

{

temp = (mynode *) malloc(sizeof(struct node));

temp->next=(mynode *)0;

temp->value=value;

if(head==(mynode *)0)

{

head=temp;

tail=temp;

}

else

{

tail->next=temp;

tail=temp;

}

}

// Function to print the linked list.

void print_list()

{

printf("\n\n");

for(temp=head; temp!=(mynode *)0; temp=temp->next)

{

printf("[%d]->",(temp->value));

}

printf("[NULL]\n\n");

}

Method3 (Recursive, but without ANY global variables.
Slightly messy!)

#include <stdio.h>

// Variables

typedef struct node

{

int value;

struct node *next;

}mynode;

// Functions

void add(mynode **head, mynode **tail, int value);

mynode* reverse_recurse(mynode *current, mynode *next);

void print_list(mynode *);

int main()

{

mynode *head, *tail;

head=(mynode *)0;

// Construct the linked list.

add(&head, &tail, 1);

add(&head, &tail, 2);

add(&head, &tail, 3);

//Print it

print_list(head);

// Reverse it.

head = reverse_recurse(head, (mynode *)0);

//Print it again

print_list(head);

getch();

return(0);

}

// Reverse the linked list recursively

mynode* reverse_recurse(mynode *current, mynode *next)

{

mynode *ret;

if(current==(mynode *)0)

{

return((mynode *)0);

}

ret = (mynode *)0;

if (current->next != (mynode *)0)

{

ret = reverse_recurse(current->next, current);

}

else

{

ret = current;

}

current->next = next;

return ret;

}

// Function to add new nodes to the linked list.

// Takes pointers to pointers to maintain the

// *actual* head and tail pointers (which are local to
main()).

void add(mynode **head, mynode **tail, int value)

{

mynode *temp1, *temp2;

temp1 = (mynode *) malloc(sizeof(struct node));

temp1->next=(mynode *)0;

temp1->value=value;

if(*head==(mynode *)0)

{

*head=temp1;

*tail=temp1;

}

else

{

for(temp2 = *head; temp2->next!= (mynode *)0;
temp2=temp2->next);

temp2->next = temp1;

*tail=temp1;

}

}

// Function to print the linked list.

void print_list(mynode *head)

{

mynode *temp;

printf("\n\n");

for(temp=head; temp!=(mynode *)0; temp=temp->next)

{

printf("[%d]->",(temp->value));

}

printf("[NULL]\n\n");

}

Doubly linked lists

This is really easy, just keep swapping the prev and next
pointers and at the end swap the

head and the tail:)

#include<stdio.h>

#include<ctype.h>

typedef struct node

{

int value;

struct node *next;

struct node *prev;

}mynode ;

mynode *head, *tail;

void add_node(int value);

void print_list();

void reverse();

int main()

{

head=NULL;

tail=NULL;

add_node(1);

add_node(2);

add_node(3);

add_node(4);

add_node(5);

print_list();

reverse();

print_list();

return(1);

}

void add_node(int value)

{

mynode *temp, *cur;

temp = (mynode *)malloc(sizeof(mynode));

temp->next=NULL;

temp->prev=NULL;

if(head == NULL)

{

printf("\nAdding a head pointer\n");

head=temp;

tail=temp;

temp->value=value;

}

else

{

for(cur=head;cur->next!=NULL;cur=cur->next);

cur->next=temp;

temp->prev=cur;

temp->value=value;

tail=temp;

}

}

void print_list()

{

mynode *temp;

printf("\n--------------------------------\n");

for(temp=head;temp!=NULL;temp=temp->next)

{

printf("\n[%d]\n",temp->value);

}

}

void reverse()

{

mynode *cur, *temp, *save_next;

if(head==tail)return;

if(head==NULL || tail==NULL)

return;

for(cur=head;cur!=NULL;)

{

printf("\ncur->value : [%d]\n",cur->value);

temp=cur->next;

save_next=cur->next;

cur->next=cur->prev;

cur->prev=temp;

cur=save_next;

} temp=head;

head=tail;

tail=temp;

}

2. Given only a pointer to a node to
be deleted in a singly linked list, how do you delete it?

This is a very good interview question

The solution to this is to copy the data from the next node
into this node and delete the

next node!. Of course this won’t work if the node to be
deleted is the last node. Mark it as

Dummy in that case. If you have a Circular linked list, then
this might be all the more

Interesting. Try writing your own C program to solve this
problem. Having a doubly

Linked list is always better.

3. How do you sort a linked list?
Write a C program to sort a linked list.

This is a very popular interview question, which most people
go wrong. The ideal

Solution to this problem is to keep the linked list sorted
as you build it. This really saves a

Lot of time which would have been required to sort it.

However....

Method1 (Usual method)

The general idea is to decide upon a sorting algorithm (say
bubble sort). Then, one needs

to come up with different scenarios to swap two nodes in the
linked list when they are not

in the required order. The different scenarios would be
something like

1. When the nodes being compared are not adjacent and one of
them is the first node.

2. When the nodes being compared are not adjacent and none
of them is the first node

3. When the nodes being compared are adjacent and one of
them is the first node.

4. When the nodes being compared are adjacent and none of
them is the first node.

One example bubble sort for a linked list goes like this

for(i = 1; i < n; i++)

{

p1 = head;

p2 = head->next;

p3 = p2->next;

for(j = 1; j <= (n - i); j++)

{

if(p2->value < p3->value)

{

p2->next = p3->next;

p3->next = p2;

p1->next = p3;

p1 = p3;

p3 = p2->next;

}

else

{

p1 = p2;

p2 = p3;

p3 = p3->next;

}

}

}

As you can see, the code becomes quite messy because of the
pointer logic. Thats why I

have not elaborated too much on the code, nor on variations
such as soring a doubly

linked list. You have to do it yourself once to understand
it.

Method1 (Divide and Conquer using merge sort)

The pseudocode for this method is

typedef struct node

{

int value;

struct node *next;

}mynode;

mynode *head, *tail;

int size;

mynode *mergesort(mynode *list, int size);

void display(mynode *list);

mynode *mergesort(mynode *list, int size)

{

int size1, size2;

mynode *tempnode1, *tempnode2, *tempnode3;

if( size<=2 )

{

if(size==1)

{

// Nothing to sort!

return(list);

}

else

{

if(list->value < list->next->value

{

// These 2 nodes are already in right order, no need to sort

return(list);

}

else

{

// Need to swap these 2 nodes

/* Here we have 2 nodes

*

*node 1 -> node2 -> NULL

*

* This should be converted to

*

* node2 -> node1 -> NULL

*

*/

tempnode1 = list;

tempnode2 = list->next;

tempnode2->next = tempnode1;

tempnode1->next = NULL;

return(tempnode2);

}

}

}

else

{

// The size of the linked list is more than 2.

// Need to split this linked list, sort the

// left and right sub-linked lists and merge.

// Split.

// tempnode1 will have the first half of the linked list of
size "size1".

// tempnode2 will have the second half of the linked list of
size "size2".

<CODE TO SPLIT THE LINKED LIST INTO TWO>

// Sort the two halves recursively

tempnode1 = mergesort(tempnode1, size1);

tempnode2 = mergesort(tempnode2, size2);

// Now merge the sorted lists back, let tempnode3 point to
that new list.

<CODE TO MERGE THE 2 LINKED LISTS BACK INTO A SINGLE

SORTED LINKED LIST>

return(tempnode3);

}

}

The code to merge the two already sorted sub-linked lists
into a sorted linked list could be

something like this..

mynode * merge(mynode *a, mynode *b)

{

mynode *i, *j, *k, *c;

i = a;

j = b;

c = getNewNode();

k = getNewNode();

while(i != NULL && j != NULL)

{

if( i -> value < j -> value )

{

k -> next = i;

i = i -> next;

}

else

{

k -> next = j;

j = j -> next;

}

}

if( i != NULL)

k -> next = i ;

else

k -> next = j;

return( c -> next );

}

4.How to declare a structure of a
linked list?

The right way of declaring a structure for a linked list in
a C program is

struct node

{

int value;

struct node *next;

};

typedef struct node *mynode;

Note that the following are not correct

typedef struct

{

int value;

mynode next;

} *mynode;

The typedef is not defined at the point where the
"next" field is declared.

struct node

{

int value;

struct node next;

};

typedef struct node mynode;

You can only have pointer to structures, not the structure
itself as its recursive!

5.Write a C program to implement a
Generic Linked List.

Here is a C program which implements a generic linked list. The
crux of the solution is to use the void C

pointer to make it generic. Also notice how we use function
pointers to pass the address

of different functions to print the different generic data.

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

typedef struct list

{

void *data;

struct list *next;

} List;

struct check

{

int i;

char c;

double d;

}chk[] = { { 1, 'a', 1.1 },{ 2, 'b', 2.2 }, { 3, 'c', 3.3 }
};

void insert(List **, void *, unsigned int);

void print(List *, void (*)(void *));

void printstr(void *);

void printint(void *);

void printchar(void *);

void printcomp(void *);

List *list1, *list2, *list3, *list4;

int main(void)

{

char c[] = { 'a', 'b', 'c', 'd' };

int i[] = { 1, 2, 3, 4 };

char *str[] = { "hello1", "hello2",
"hello3", "hello4" };

list1 = list2 = list3 = list4 = NULL;

insert(&list1, &c[0], sizeof(char));

insert(&list1, &c[1], sizeof(char));

insert(&list1, &c[2], sizeof(char));

insert(&list1, &c[3], sizeof(char));

insert(&list2, &i[0], sizeof(int));

insert(&list2, &i[1], sizeof(int));

insert(&list2, &i[2], sizeof(int));

insert(&list2, &i[3], sizeof(int));

insert(&list3, str[0], strlen(str[0])+1);

insert(&list3, str[1], strlen(str[0])+1);

insert(&list3, str[2], strlen(str[0])+1);

insert(&list3, str[3], strlen(str[0])+1);

insert(&list4, &chk[0], sizeof chk[0]);

insert(&list4, &chk[1], sizeof chk[1]);

insert(&list4, &chk[2], sizeof chk[2]);

printf("Printing characters:");

print(list1, printchar);

printf(" : done\n\n");

printf("Printing integers:");

print(list2, printint);

printf(" : done\n\n");

printf("Printing strings:");

print(list3, printstr);

printf(" : done\n\n");

printf("Printing composite:");

print(list4, printcomp);

printf(" : done\n");

return 0;

}

void insert( List **p, void *data, unsigned int n )

{

List *temp;

int i;

/* Error check is ignored */

temp = malloc( sizeof ( List ) );

temp -> data = malloc( n );

for (i = 0; i < n; i++)

*( char * ) ( temp -> data + i ) = *( char * ) ( data + i
);

temp -> next = *p;

*p = temp;

}

void print( List *p, void ( *f ) ( void * ) )

{

while ( p )

{

( *f ) ( p -> data );

p = p -> next;

}

}

void printstr( void *str )

{

printf( " \"%s\"", ( char * ) str );

}

void printint( void *n )

{

printf( " %d", *( int * ) n );

}

void printchar( void *c )

{

printf( " %c", *( char * ) c );

}

void printcomp( void *comp )

{

struct check temp = *( struct check * )comp;

printf( " '%d:%c:%f ", temp.i, temp.c, temp.d );

}

6. How do you reverse a linked list
without using any C pointers?

One way is to reverse the data in the nodes without changing
the pointers themselves. One can also create a new linked list which is the
reverse of the original linked list. A simple C program can do that for you.
Please note that you would still use the "next" pointer fields to
traverse through the linked list (So in effect, you are using the pointers, but
you are not changing them when reversing the linked list).

7.How would you detect a loop in a
linked list? Write a C program to detect a loop in a linked list.

There are multiple answers to this problem. Here are a few C
programs to attack this

Problem.

Brute force method

Have a double loop, where you check the node pointed to by
the outer loop, with every

node of the inner loop.

typedef struct node

{

void *data;

struct node *next;

}mynode;

mynode * find_loop( NODE * head )

{

mynode *current = head;

while( current -> next != NULL )

{

mynode *temp = head;

while( temp -> next != NULL && temp != current )

{

if( current -> next == temp )

{

printf("\nFound a loop.");

return current;

} temp =

temp -> next;

}

current = current -> next;

}r

eturn NULL;

}

Visited flag

Have a visited flag in each node of the linked list. Flag it
as visited when you reach the

node. When you reach a node and the flag is already flagged
as visited, then you know

there is a loop in the linked list.

Fastest method

Have 2 pointers to start of the linked list. Increment one
pointer by 1 node and the other

by 2 nodes. If there's a loop, the 2nd pointer will meet the
1st pointer somewhere. If it

does, then you know there's one.

Here is some code

p = head;

q = head -> next;

while( p != NULL && q != NULL )

{

if( p == q )

{

//Loop detected!

exit( 0 );

}

p = p -> next;

q = ( q -> next ) ? ( q -> next -> next ) : q ->
next;

}

// No loop.

8.How do you find the middle of a linked list? Write a C
program to return the

middle of a linked list

Another popular interview question

Here are a few C program snippets to give you an idea of the
possible solutions.

Method1

p = head;

q = head;

if( q -> next -> next != NULL)

{

p = p -> next;

q = q -> next -> next;

}

printf("The middle element is %d",p->data);

Here p moves one step, where as q moves two steps, when q
reaches end, p will be at the

middle of the linked list.

Method2

struct node *middle(struct node *head)

{

struct node *middle=NULL;

int i;

for( i = 1 ; head ; head = head -> next , i++)

{

if( i == 1 )

middle = head ;

else if ( ( i % 2 ) == 1 )

middle = middle -> next ;

}r

eturn middle;

} In a

similar way, we can find the 1/3

th node of linked list by changing (

i

%

2

== 1

)

to (

i

% 3 == 1 ) and in the same way we can find nth node of list
by changing ( i % 2 == 1 ) to

( i % n == 1 ) but make sure ur ( n <= i ).

9.If you are using C language to implement the heterogeneous
linked list, what

pointer type will you use?

The heterogeneous linked list contains different data types
in its nodes and we

need a link, pointer to connect them. It is not possible to
use ordinary pointers for this. So

we go for void pointer. Void pointer is capable of storing
pointer to any type as it is a

generic pointer type.

Check out the C program to implement a Generic linked list
in the same FAQ.

10.How to compare two linked lists? Write a C program to
compare two linked lists.

Here is a simple C program to accomplish the same.

int compare_linked_lists( struct node *q, struct node *r )

{

static int flag ;

if ( ( q == NULL ) && ( r == NULL ) )

{

flag=1;

}

else

{

if ( q == NULL || r == NULL )

{

flag = 0 ;

}

if ( q -> data != r -> data )

{

flag = 0;

}

else

{

compare_linked_lists ( q -> link , r -> link ) ;

}

}r

eturn ( flag ) ;

}

Another way is to do it on similar lines as strcmp()
compares two strings, character by

character (here each node is like a character).

11.How to create a copy of a linked list? Write a C program
to create a copy of a

linked list.

Check out this C program which creates an exact copy of a
linked list.

copy_linked_lists ( struct node *q , struct node **s )

{

if ( q != NULL )

{

*s = malloc ( sizeof ( struct node ) ) ;

( *s ) -> data = q -> data ;

( *s ) -> link = NULL ;

copy_linked_list ( q -> link , & ( ( *s ) -> link
) );

}

}

12.Write a C program to free the nodes of a linked list

Before looking at the answer, try writing a simple C program
(with a for loop) to do this.

Quite a few people get this wrong.

This is the wrong way to do it:

struct list *listptr, *nextptr ;

for( listptr = head ; listptr != NULL ; listptr = listptr
-> next )

{

free( listptr ) ;

}

If you are thinking why the above piece of code is wrong,
note that once you free

the listptr node, you cannot do something like listptr =
listptr->next!. Since listptr is

already freed, using it to get listptr->next is illegal
and can cause unpredictable results

This is the right way to do it:

struct list *listptr, *nextptr;

for( listptr = head ; listptr != NULL ; listptr = nextptr )

{

nextptr = listptr -> next ;

free( listptr ) ;

}

13. Can we do a Binary search on a
linked list

The answer is ofcourse, you can write a C program to do
this. But, the question is, do you

really think it will be as efficient as a C program which
does a binary search on an array?

Think hard, real hard.

Do you know what exactly makes the binary search on an array
so fast and efficient? Its

the ability to access any element in the array in constant
time. This is what makes it so

fast. You can get to the middle of the array just by saying
array[middle]!. Now, can you

do the same with a linked list? The answer is No. You will
have to write your own,

possibly inefficient algorithm to get the value of the
middle node of a linked list. In a

linked list, you loosse the ability to get the value of any
node in a constant time.

One solution to the inefficiency of getting the middle of
the linked list during a binary

search is to have the first node contain one additional
pointer that points to the node in the

middle. Decide at the first node if you need to check the
first or the second half of the

linked list. Continue doing that with each half-list.

14.Write a C program to return the nth node from the end of
a linked list.

Here is a solution which is often called as the solution
that uses frames.

Suppose one needs to get to the 6th node from the end in
this LL. First, just keep on

incrementing the first pointer (ptr1) till the number of
increments cross n (which is 6 in

this case)

STEP 1 : 1(ptr1,ptr2) -> 2 -> 3 -> 4 -> 5 ->
6 -> 7 -> 8 -> 9 -> 10

STEP 2 : 1(ptr2) -> 2 -> 3 -> 4 -> 5 ->
6(ptr1) -> 7 -> 8 -> 9 -> 10

Now, start the second pointer (ptr2) and keep on
incrementing it till the first pointer (ptr1)

reaches the end of the LL.

STEP 3 : 1 -> 2 -> 3 -> 4(ptr2) -> 5 -> 6
-> 7 -> 8 -> 9 -> 10 (ptr1)

So here you have! the 6th node from the end pointed to by
ptr2!

Here is some C code..

struct node

{

int data;

struct node *next;

}mynode;

mynode * nthNode(mynode *head, int n /*pass 0 for last
node*/)

{

mynode *ptr1,*ptr2 ;

int count ;

if( !head )

{

return( NULL ) ;

}

ptr1 = head ;

ptr2 = head ;

count = 0 ;

while( count < n )

{

count++ ;

if ( ( ptr1 = ptr1 -> next ) == NULL )

{

//Length of the linked list less than n. Error.

return( NULL );

}

}

while( ( ptr1 = ptr1 -> next ) != NULL )

{

ptr2 = ptr2 -> next ;

}r

eturn( ptr2 );

}

15. How would you find out if one of
the pointers in a linked list is corrupted or not?

This is a really good interview question. The reason is that linked
lists are used in a wide variety of scenarios and being able to detect and
correct pointer corruptions might be a very valuable tool. For example, data
blocks associated with files in a file system are usually stored as linked
lists. Each data block points to the next data block. A single corrupt pointer
can cause the entire file to be lost!Discover and fix bugs when they corrupt
the linked list and not when effect becomes visible in some other part

of the program. Perform frequent consistency checks (to see if the
linked list is indeed holding the data that you inserted into it). · It is good
programming practice to set the pointer value to NULL immediately

after freeing the memory pointed at by the pointer. This will help in
debugging, because it will tell you that the object was freed somewhere
beforehand. Keep track of how many objects are pointing to a object using
reference counts if required. · Use a good debugger to see how the
datastructures are getting corrupted and trace down the problem. Debuggers like
ddd on linux and memory profilers like Purify, Electric fence are good starting
points. These tools should help you track down heap corruption issues easily. ·
Avoid global variables when traversing and manipulating linked lists. Imagine what
would happen if a function which is only supposed to traverse a linked list using
a global head pointer accidently sets the head pointer to NULL!. · Its a good
idea to check the addNode() and the deleteNode() routines and test them for all
types of scenarios. This should include tests for inserting/deleting nodes at
the front/middle/end of the linked list, working with an empty linked list, running
out of memory when using malloc() when allocating memory for new nodes, writing
through NULL pointers, writing more data into the node fields then they can
hold (resulting in corrupting the (probably adjacent) "prev" and
"next" pointer fields), make sure bug fixes and enhancements to the
linked list code are reviewed and well tested (a lot of bugs come from quick
and dirty bug fixing), log and handle all possible errors (this will help you a
lot while debugging), add multiple levels of logging so that you can dig
through the logs. The list is endless... · Each node can have an extra field
associated* Linked Lists

·How do you reverse a singly linked list? How do
you reverse a doubly linked

list? Write a C program to do the
same. Updated!

·Given only a pointer to a node to be deleted in
a singly linked list, how do you

delete it? Updated!

·How do you sort a linked list? Write a C program
to sort a linked list.

·How to declare a structure of a linked list?

·Write a C program to implement a Generic Linked
List.

·How do you reverse a linked list without using
any C pointers? Updated!

·How would you detect a loop in a linked list?
Write a C program to detect a loop in a linked list.

·How do you find the middle of a linked list?
Write a C program to return themiddle of a linked list

·If you are using C language to implement the
heterogeneous linked list, what pointer type will you use?

·How to compare two linked lists? Write a C
program to compare two linked lists.

·How to create a copy of a linked list? Write a C
program to create a copy of a linked list.

·Write a C program to free the nodes of a linked
list Updated!

·Can we do a Binary search on a linked list?

·Write a C program to return the nth node from
the end of a linked list. New!

·How would you find out if one of the pointers in
a linked list is corrupted or not? Write a C program to do the same.

Here are a few C programs to reverse a singly linked list.

Method1 (Iterative)

#include <stdio.h>

// Variables

typedef struct node

{

int value;

struct node *next;

}mynode;

// Globals (not required, though).

mynode *head, *tail, *temp;

// Functions

void add(int value);

void iterative_reverse();

void print_list();

// The main() function

int main()

{

head=(mynode *)0;

// Construct the linked list.

add(1);

add(2);

add(3);

//Print it

print_list();

// Reverse it.

iterative_reverse();

//Print it again

print_list();

return(0);

}

// The reverse function

void iterative_reverse()

{

mynode *p, *q, *r;

if(head == (mynode *)0)

{

return;

}

p = head;

q = p->next;

p->next = (mynode *)0;

while (q != (mynode *)0)

{

r = q->next;

q->next = p;

p = q;

q = r;

}

head = p;

}

// Function to add new nodes to the linked list

void add(int value)

{

temp = (mynode *) malloc(sizeof(struct node));

temp->next=(mynode *)0;

temp->value=value;

if(head==(mynode *)0)

{

head=temp;

tail=temp;

}

else

{

tail->next=temp;

tail=temp;

}

}

// Function to print the linked list.

void print_list()

{

printf("\n\n");

for(temp=head; temp!=(mynode *)0; temp=temp->next)

{

printf("[%d]->",(temp->value));

}

printf("[NULL]\n\n");

}

Method2 (Recursive, without using any temporary variable)

#include <stdio.h>

// Variables

typedef struct node

{

int value;

struct node *next;

}mynode;

// Globals.

mynode *head, *tail, *temp;

// Functions

void add(int value);

mynode* reverse_recurse(mynode *root);

void print_list();

// The main() function

int main()

{

head=(mynode *)0;

// Construct the linked list.

add(1);

add(2);

add(3);

//Print it

print_list();

// Reverse it.

if(head != (mynode *)0)

{

temp = reverse_recurse(head);

temp->next = (mynode *)0;

}

//Print it again

print_list();

return(0);

}

// Reverse the linked list recursively

//

// This function uses the power of the stack to make this

// *magical* assignment

//

// node->next->next=node;

//

// :)

mynode* reverse_recurse(mynode *root)

{

if(root->next!=(mynode *)0)

{

reverse_recurse(root->next);

root->next->next=root;

return(root);

}

else

{

head=root;

}

}

// Function to add new nodes to the linked list.

void add(int value)

{

temp = (mynode *) malloc(sizeof(struct node));

temp->next=(mynode *)0;

temp->value=value;

if(head==(mynode *)0)

{

head=temp;

tail=temp;

}

else

{

tail->next=temp;

tail=temp;

}

}

// Function to print the linked list.

void print_list()

{

printf("\n\n");

for(temp=head; temp!=(mynode *)0; temp=temp->next)

{

printf("[%d]->",(temp->value));

}

printf("[NULL]\n\n");

}

Method3 (Recursive, but without ANY global variables.
Slightly messy!)

#include <stdio.h>

// Variables

typedef struct node

{

int value;

struct node *next;

}mynode;

// Functions

void add(mynode **head, mynode **tail, int value);

mynode* reverse_recurse(mynode *current, mynode *next);

void print_list(mynode *);

int main()

{

mynode *head, *tail;

head=(mynode *)0;

// Construct the linked list.

add(&head, &tail, 1);

add(&head, &tail, 2);

add(&head, &tail, 3);

//Print it

print_list(head);

// Reverse it.

head = reverse_recurse(head, (mynode *)0);

//Print it again

print_list(head);

getch();

return(0);

}

// Reverse the linked list recursively

mynode* reverse_recurse(mynode *current, mynode *next)

{

mynode *ret;

if(current==(mynode *)0)

{

return((mynode *)0);

}

ret = (mynode *)0;

if (current->next != (mynode *)0)

{

ret = reverse_recurse(current->next, current);

}

else

{

ret = current;

}

current->next = next;

return ret;

}

// Function to add new nodes to the linked list.

// Takes pointers to pointers to maintain the

// *actual* head and tail pointers (which are local to
main()).

void add(mynode **head, mynode **tail, int value)

{

mynode *temp1, *temp2;

temp1 = (mynode *) malloc(sizeof(struct node));

temp1->next=(mynode *)0;

temp1->value=value;

if(*head==(mynode *)0)

{

*head=temp1;

*tail=temp1;

}

else

{

for(temp2 = *head; temp2->next!= (mynode *)0;
temp2=temp2->next);

temp2->next = temp1;

*tail=temp1;

}

}

// Function to print the linked list.

void print_list(mynode *head)

{

mynode *temp;

printf("\n\n");

for(temp=head; temp!=(mynode *)0; temp=temp->next)

{

printf("[%d]->",(temp->value));

}

printf("[NULL]\n\n");

}

Doubly linked lists

This is really easy, just keep swapping the prev and next
pointers and at the end swap the

head and the tail:)

#include<stdio.h>

#include<ctype.h>

typedef struct node

{

int value;

struct node *next;

struct node *prev;

}mynode ;

mynode *head, *tail;

void add_node(int value);

void print_list();

void reverse();

int main()

{

head=NULL;

tail=NULL;

add_node(1);

add_node(2);

add_node(3);

add_node(4);

add_node(5);

print_list();

reverse();

print_list();

return(1);

}

void add_node(int value)

{

mynode *temp, *cur;

temp = (mynode *)malloc(sizeof(mynode));

temp->next=NULL;

temp->prev=NULL;

if(head == NULL)

{

printf("\nAdding a head pointer\n");

head=temp;

tail=temp;

temp->value=value;

}

else

{

for(cur=head;cur->next!=NULL;cur=cur->next);

cur->next=temp;

temp->prev=cur;

temp->value=value;

tail=temp;

}

}

void print_list()

{

mynode *temp;

printf("\n--------------------------------\n");

for(temp=head;temp!=NULL;temp=temp->next)

{

printf("\n[%d]\n",temp->value);

}

}

void reverse()

{

mynode *cur, *temp, *save_next;

if(head==tail)return;

if(head==NULL || tail==NULL)

return;

for(cur=head;cur!=NULL;)

{

printf("\ncur->value : [%d]\n",cur->value);

temp=cur->next;

save_next=cur->next;

cur->next=cur->prev;

cur->prev=temp;

cur=save_next;

} temp=head;

head=tail;

tail=temp;

}

2. Given only a pointer to a node to
be deleted in a singly linked list, how do you delete it?

This is a very good interview question

The solution to this is to copy the data from the next node
into this node and delete the

next node!. Of course this won’t work if the node to be
deleted is the last node. Mark it as

Dummy in that case. If you have a Circular linked list, then
this might be all the more

Interesting. Try writing your own C program to solve this
problem. Having a doubly

Linked list is always better.

3. How do you sort a linked list?
Write a C program to sort a linked list.

This is a very popular interview question, which most people
go wrong. The ideal

Solution to this problem is to keep the linked list sorted
as you build it. This really saves a

Lot of time which would have been required to sort it.

However....

Method1 (Usual method)

The general idea is to decide upon a sorting algorithm (say
bubble sort). Then, one needs

to come up with different scenarios to swap two nodes in the
linked list when they are not

in the required order. The different scenarios would be
something like

1. When the nodes being compared are not adjacent and one of
them is the first node.

2. When the nodes being compared are not adjacent and none
of them is the first node

3. When the nodes being compared are adjacent and one of
them is the first node.

4. When the nodes being compared are adjacent and none of
them is the first node.

One example bubble sort for a linked list goes like this

for(i = 1; i < n; i++)

{

p1 = head;

p2 = head->next;

p3 = p2->next;

for(j = 1; j <= (n - i); j++)

{

if(p2->value < p3->value)

{

p2->next = p3->next;

p3->next = p2;

p1->next = p3;

p1 = p3;

p3 = p2->next;

}

else

{

p1 = p2;

p2 = p3;

p3 = p3->next;

}

}

}

As you can see, the code becomes quite messy because of the
pointer logic. Thats why I

have not elaborated too much on the code, nor on variations
such as soring a doubly

linked list. You have to do it yourself once to understand
it.

Method1 (Divide and Conquer using merge sort)

The pseudocode for this method is

typedef struct node

{

int value;

struct node *next;

}mynode;

mynode *head, *tail;

int size;

mynode *mergesort(mynode *list, int size);

void display(mynode *list);

mynode *mergesort(mynode *list, int size)

{

int size1, size2;

mynode *tempnode1, *tempnode2, *tempnode3;

if( size<=2 )

{

if(size==1)

{

// Nothing to sort!

return(list);

}

else

{

if(list->value < list->next->value

{

// These 2 nodes are already in right order, no need to sort

return(list);

}

else

{

// Need to swap these 2 nodes

/* Here we have 2 nodes

*

*node 1 -> node2 -> NULL

*

* This should be converted to

*

* node2 -> node1 -> NULL

*

*/

tempnode1 = list;

tempnode2 = list->next;

tempnode2->next = tempnode1;

tempnode1->next = NULL;

return(tempnode2);

}

}

}

else

{

// The size of the linked list is more than 2.

// Need to split this linked list, sort the

// left and right sub-linked lists and merge.

// Split.

// tempnode1 will have the first half of the linked list of
size "size1".

// tempnode2 will have the second half of the linked list of
size "size2".

<CODE TO SPLIT THE LINKED LIST INTO TWO>

// Sort the two halves recursively

tempnode1 = mergesort(tempnode1, size1);

tempnode2 = mergesort(tempnode2, size2);

// Now merge the sorted lists back, let tempnode3 point to
that new list.

<CODE TO MERGE THE 2 LINKED LISTS BACK INTO A SINGLE

SORTED LINKED LIST>

return(tempnode3);

}

}

The code to merge the two already sorted sub-linked lists
into a sorted linked list could be

something like this..

mynode * merge(mynode *a, mynode *b)

{

mynode *i, *j, *k, *c;

i = a;

j = b;

c = getNewNode();

k = getNewNode();

while(i != NULL && j != NULL)

{

if( i -> value < j -> value )

{

k -> next = i;

i = i -> next;

}

else

{

k -> next = j;

j = j -> next;

}

}

if( i != NULL)

k -> next = i ;

else

k -> next = j;

return( c -> next );

}

4.How to declare a structure of a
linked list?

The right way of declaring a structure for a linked list in
a C program is

struct node

{

int value;

struct node *next;

};

typedef struct node *mynode;

Note that the following are not correct

typedef struct

{

int value;

mynode next;

} *mynode;

The typedef is not defined at the point where the
"next" field is declared.

struct node

{

int value;

struct node next;

};

typedef struct node mynode;

You can only have pointer to structures, not the structure
itself as its recursive!

5.Write a C program to implement a
Generic Linked List.

Here is a C program which implements a generic linked list. The
crux of the solution is to use the void C

pointer to make it generic. Also notice how we use function
pointers to pass the address

of different functions to print the different generic data.

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

typedef struct list

{

void *data;

struct list *next;

} List;

struct check

{

int i;

char c;

double d;

}chk[] = { { 1, 'a', 1.1 },{ 2, 'b', 2.2 }, { 3, 'c', 3.3 }
};

void insert(List **, void *, unsigned int);

void print(List *, void (*)(void *));

void printstr(void *);

void printint(void *);

void printchar(void *);

void printcomp(void *);

List *list1, *list2, *list3, *list4;

int main(void)

{

char c[] = { 'a', 'b', 'c', 'd' };

int i[] = { 1, 2, 3, 4 };

char *str[] = { "hello1", "hello2",
"hello3", "hello4" };

list1 = list2 = list3 = list4 = NULL;

insert(&list1, &c[0], sizeof(char));

insert(&list1, &c[1], sizeof(char));

insert(&list1, &c[2], sizeof(char));

insert(&list1, &c[3], sizeof(char));

insert(&list2, &i[0], sizeof(int));

insert(&list2, &i[1], sizeof(int));

insert(&list2, &i[2], sizeof(int));

insert(&list2, &i[3], sizeof(int));

insert(&list3, str[0], strlen(str[0])+1);

insert(&list3, str[1], strlen(str[0])+1);

insert(&list3, str[2], strlen(str[0])+1);

insert(&list3, str[3], strlen(str[0])+1);

insert(&list4, &chk[0], sizeof chk[0]);

insert(&list4, &chk[1], sizeof chk[1]);

insert(&list4, &chk[2], sizeof chk[2]);

printf("Printing characters:");

print(list1, printchar);

printf(" : done\n\n");

printf("Printing integers:");

print(list2, printint);

printf(" : done\n\n");

printf("Printing strings:");

print(list3, printstr);

printf(" : done\n\n");

printf("Printing composite:");

print(list4, printcomp);

printf(" : done\n");

return 0;

}

void insert( List **p, void *data, unsigned int n )

{

List *temp;

int i;

/* Error check is ignored */

temp = malloc( sizeof ( List ) );

temp -> data = malloc( n );

for (i = 0; i < n; i++)

*( char * ) ( temp -> data + i ) = *( char * ) ( data + i
);

temp -> next = *p;

*p = temp;

}

void print( List *p, void ( *f ) ( void * ) )

{

while ( p )

{

( *f ) ( p -> data );

p = p -> next;

}

}

void printstr( void *str )

{

printf( " \"%s\"", ( char * ) str );

}

void printint( void *n )

{

printf( " %d", *( int * ) n );

}

void printchar( void *c )

{

printf( " %c", *( char * ) c );

}

void printcomp( void *comp )

{

struct check temp = *( struct check * )comp;

printf( " '%d:%c:%f ", temp.i, temp.c, temp.d );

}

6. How do you reverse a linked list
without using any C pointers?

One way is to reverse the data in the nodes without changing
the pointers themselves. One can also create a new linked list which is the
reverse of the original linked list. A simple C program can do that for you.
Please note that you would still use the "next" pointer fields to
traverse through the linked list (So in effect, you are using the pointers, but
you are not changing them when reversing the linked list).

7.How would you detect a loop in a
linked list? Write a C program to detect a loop in a linked list.

There are multiple answers to this problem. Here are a few C
programs to attack this

Problem.

Brute force method

Have a double loop, where you check the node pointed to by
the outer loop, with every

node of the inner loop.

typedef struct node

{

void *data;

struct node *next;

}mynode;

mynode * find_loop( NODE * head )

{

mynode *current = head;

while( current -> next != NULL )

{

mynode *temp = head;

while( temp -> next != NULL && temp != current )

{

if( current -> next == temp )

{

printf("\nFound a loop.");

return current;

} temp =

temp -> next;

}

current = current -> next;

}r

eturn NULL;

}

Visited flag

Have a visited flag in each node of the linked list. Flag it
as visited when you reach the

node. When you reach a node and the flag is already flagged
as visited, then you know

there is a loop in the linked list.

Fastest method

Have 2 pointers to start of the linked list. Increment one
pointer by 1 node and the other

by 2 nodes. If there's a loop, the 2nd pointer will meet the
1st pointer somewhere. If it

does, then you know there's one.

Here is some code

p = head;

q = head -> next;

while( p != NULL && q != NULL )

{

if( p == q )

{

//Loop detected!

exit( 0 );

}

p = p -> next;

q = ( q -> next ) ? ( q -> next -> next ) : q ->
next;

}

// No loop.

8.How do you find the middle of a linked list? Write a C
program to return the

middle of a linked list

Another popular interview question

Here are a few C program snippets to give you an idea of the
possible solutions.

Method1

p = head;

q = head;

if( q -> next -> next != NULL)

{

p = p -> next;

q = q -> next -> next;

}

printf("The middle element is %d",p->data);

Here p moves one step, where as q moves two steps, when q
reaches end, p will be at the

middle of the linked list.

Method2

struct node *middle(struct node *head)

{

struct node *middle=NULL;

int i;

for( i = 1 ; head ; head = head -> next , i++)

{

if( i == 1 )

middle = head ;

else if ( ( i % 2 ) == 1 )

middle = middle -> next ;

}r

eturn middle;

} In a

similar way, we can find the 1/3

th node of linked list by changing (

i

%

2

== 1

)

to (

i

% 3 == 1 ) and in the same way we can find nth node of list
by changing ( i % 2 == 1 ) to

( i % n == 1 ) but make sure ur ( n <= i ).

9.If you are using C language to implement the heterogeneous
linked list, what

pointer type will you use?

The heterogeneous linked list contains different data types
in its nodes and we

need a link, pointer to connect them. It is not possible to
use ordinary pointers for this. So

we go for void pointer. Void pointer is capable of storing
pointer to any type as it is a

generic pointer type.

Check out the C program to implement a Generic linked list
in the same FAQ.

10.How to compare two linked lists? Write a C program to
compare two linked lists.

Here is a simple C program to accomplish the same.

int compare_linked_lists( struct node *q, struct node *r )

{

static int flag ;

if ( ( q == NULL ) && ( r == NULL ) )

{

flag=1;

}

else

{

if ( q == NULL || r == NULL )

{

flag = 0 ;

}

if ( q -> data != r -> data )

{

flag = 0;

}

else

{

compare_linked_lists ( q -> link , r -> link ) ;

}

}r

eturn ( flag ) ;

}

Another way is to do it on similar lines as strcmp()
compares two strings, character by

character (here each node is like a character).

11.How to create a copy of a linked list? Write a C program
to create a copy of a

linked list.

Check out this C program which creates an exact copy of a
linked list.

copy_linked_lists ( struct node *q , struct node **s )

{

if ( q != NULL )

{

*s = malloc ( sizeof ( struct node ) ) ;

( *s ) -> data = q -> data ;

( *s ) -> link = NULL ;

copy_linked_list ( q -> link , & ( ( *s ) -> link
) );

}

}

12.Write a C program to free the nodes of a linked list

Before looking at the answer, try writing a simple C program
(with a for loop) to do this.

Quite a few people get this wrong.

This is the wrong way to do it:

struct list *listptr, *nextptr ;

for( listptr = head ; listptr != NULL ; listptr = listptr
-> next )

{

free( listptr ) ;

}

If you are thinking why the above piece of code is wrong,
note that once you free

the listptr node, you cannot do something like listptr =
listptr->next!. Since listptr is

already freed, using it to get listptr->next is illegal
and can cause unpredictable results

This is the right way to do it:

struct list *listptr, *nextptr;

for( listptr = head ; listptr != NULL ; listptr = nextptr )

{

nextptr = listptr -> next ;

free( listptr ) ;

}

13. Can we do a Binary search on a
linked list

The answer is ofcourse, you can write a C program to do
this. But, the question is, do you

really think it will be as efficient as a C program which
does a binary search on an array?

Think hard, real hard.

Do you know what exactly makes the binary search on an array
so fast and efficient? Its

the ability to access any element in the array in constant
time. This is what makes it so

fast. You can get to the middle of the array just by saying
array[middle]!. Now, can you

do the same with a linked list? The answer is No. You will
have to write your own,

possibly inefficient algorithm to get the value of the
middle node of a linked list. In a

linked list, you loosse the ability to get the value of any
node in a constant time.

One solution to the inefficiency of getting the middle of
the linked list during a binary

search is to have the first node contain one additional
pointer that points to the node in the

middle. Decide at the first node if you need to check the
first or the second half of the

linked list. Continue doing that with each half-list.

14.Write a C program to return the nth node from the end of
a linked list.

Here is a solution which is often called as the solution
that uses frames.

Suppose one needs to get to the 6th node from the end in
this LL. First, just keep on

incrementing the first pointer (ptr1) till the number of
increments cross n (which is 6 in

this case)

STEP 1 : 1(ptr1,ptr2) -> 2 -> 3 -> 4 -> 5 ->
6 -> 7 -> 8 -> 9 -> 10

STEP 2 : 1(ptr2) -> 2 -> 3 -> 4 -> 5 ->
6(ptr1) -> 7 -> 8 -> 9 -> 10

Now, start the second pointer (ptr2) and keep on
incrementing it till the first pointer (ptr1)

reaches the end of the LL.

STEP 3 : 1 -> 2 -> 3 -> 4(ptr2) -> 5 -> 6
-> 7 -> 8 -> 9 -> 10 (ptr1)

So here you have! the 6th node from the end pointed to by
ptr2!

Here is some C code..

struct node

{

int data;

struct node *next;

}mynode;

mynode * nthNode(mynode *head, int n /*pass 0 for last
node*/)

{

mynode *ptr1,*ptr2 ;

int count ;

if( !head )

{

return( NULL ) ;

}

ptr1 = head ;

ptr2 = head ;

count = 0 ;

while( count < n )

{

count++ ;

if ( ( ptr1 = ptr1 -> next ) == NULL )

{

//Length of the linked list less than n. Error.

return( NULL );

}

}

while( ( ptr1 = ptr1 -> next ) != NULL )

{

ptr2 = ptr2 -> next ;

}r

eturn( ptr2 );

}

15. How would you find out if one of
the pointers in a linked list is corrupted or not?

This is a really good interview question. The reason is that linked
lists are used in a wide variety of scenarios and being able to detect and
correct pointer corruptions might be a very valuable tool. For example, data
blocks associated with files in a file system are usually stored as linked
lists. Each data block points to the next data block. A single corrupt pointer
can cause the entire file to be lost!Discover and fix bugs when they corrupt
the linked list and not when effect becomes visible in some other part

of the program. Perform frequent consistency checks (to see if the
linked list is indeed holding the data that you inserted into it). · It is good
programming practice to set the pointer value to NULL immediately

after freeing the memory pointed at by the pointer. This will help in
debugging, because it will tell you that the object was freed somewhere
beforehand. Keep track of how many objects are pointing to a object using
reference counts if required. · Use a good debugger to see how the
datastructures are getting corrupted and trace down the problem. Debuggers like
ddd on linux and memory profilers like Purify, Electric fence are good starting
points. These tools should help you track down heap corruption issues easily. ·
Avoid global variables when traversing and manipulating linked lists. Imagine what
would happen if a function which is only supposed to traverse a linked list using
a global head pointer accidently sets the head pointer to NULL!. · Its a good
idea to check the addNode() and the deleteNode() routines and test them for all
types of scenarios. This should include tests for inserting/deleting nodes at
the front/middle/end of the linked list, working with an empty linked list, running
out of memory when using malloc() when allocating memory for new nodes, writing
through NULL pointers, writing more data into the node fields then they can
hold (resulting in corrupting the (probably adjacent) "prev" and
"next" pointer fields), make sure bug fixes and enhancements to the
linked list code are reviewed and well tested (a lot of bugs come from quick
and dirty bug fixing), log and handle all possible errors (this will help you a
lot while debugging), add multiple levels of logging so that you can dig
through the logs. The list is endless... · Each node can have an extra field
associated with it. This field indicates the

number of nodes after this node in the linked list. This extra field
needs to be kept up-to-date when we inserte or delete nodes in the linked list
(It might become slightly complicated when insertion or deletion happens not at
end, but anywhere in the linked list). Then, if for any node, p->field >
0 and p->next == NULL, it surely points to a pointer corruption. · You could
also keep the count of the total number of nodes in a linked list and use it to
check if the list is indeed having those many nodes or not.

The problem in detecting such pointer corruptions in C is that its only
the programmer who knows that the pointer is corrupted. The program has no way
of knowing that something is wrong. So the best way to fix these errors is
check your logic and test your code to the maximum possible extent. I am not
aware of ways in C to recover the lost Nodes of a corrupted linked list. I have
a hunch that interviewers who ask this question are probably hinting at
something Called Smart Pointers in C++. Smart pointers are particularly useful
in the face of exceptions as they ensure proper destruction of dynamically
allocated objects. They can also be used to keep track of dynamically allocated
objects shared by multiple owners. This topic is out of scope here, but you can
find lots of material on the Internet for Smart Pointers. If you have bett* Linked Lists

·How do you reverse a singly linked list? How do
you reverse a doubly linked

list? Write a C program to do the
same. Updated!

·Given only a pointer to a node to be deleted in
a singly linked list, how do you

delete it? Updated!

·How do you sort a linked list? Write a C program
to sort a linked list.

·How to declare a structure of a linked list?

·Write a C program to implement a Generic Linked
List.

·How do you reverse a linked list without using
any C pointers? Updated!

·How would you detect a loop in a linked list?
Write a C program to detect a loop in a linked list.

·How do you find the middle of a linked list?
Write a C program to return themiddle of a linked list

·If you are using C language to implement the
heterogeneous linked list, what pointer type will you use?

·How to compare two linked lists? Write a C
program to compare two linked lists.

·How to create a copy of a linked list? Write a C
program to create a copy of a linked list.

·Write a C program to free the nodes of a linked
list Updated!

·Can we do a Binary search on a linked list?

·Write a C program to return the nth node from
the end of a linked list. New!

·How would you find out if one of the pointers in
a linked list is corrupted or not? Write a C program to do the same.

Here are a few C programs to reverse a singly linked list.

Method1 (Iterative)

#include <stdio.h>

// Variables

typedef struct node

{

int value;

struct node *next;

}mynode;

// Globals (not required, though).

mynode *head, *tail, *temp;

// Functions

void add(int value);

void iterative_reverse();

void print_list();

// The main() function

int main()

{

head=(mynode *)0;

// Construct the linked list.

add(1);

add(2);

add(3);

//Print it

print_list();

// Reverse it.

iterative_reverse();

//Print it again

print_list();

return(0);

}

// The reverse function

void iterative_reverse()

{

mynode *p, *q, *r;

if(head == (mynode *)0)

{

return;

}

p = head;

q = p->next;

p->next = (mynode *)0;

while (q != (mynode *)0)

{

r = q->next;

q->next = p;

p = q;

q = r;

}

head = p;

}

// Function to add new nodes to the linked list

void add(int value)

{

temp = (mynode *) malloc(sizeof(struct node));

temp->next=(mynode *)0;

temp->value=value;

if(head==(mynode *)0)

{

head=temp;

tail=temp;

}

else

{

tail->next=temp;

tail=temp;

}

}

// Function to print the linked list.

void print_list()

{

printf("\n\n");

for(temp=head; temp!=(mynode *)0; temp=temp->next)

{

printf("[%d]->",(temp->value));

}

printf("[NULL]\n\n");

}

Method2 (Recursive, without using any temporary variable)

#include <stdio.h>

// Variables

typedef struct node

{

int value;

struct node *next;

}mynode;

// Globals.

mynode *head, *tail, *temp;

// Functions

void add(int value);

mynode* reverse_recurse(mynode *root);

void print_list();

// The main() function

int main()

{

head=(mynode *)0;

// Construct the linked list.

add(1);

add(2);

add(3);

//Print it

print_list();

// Reverse it.

if(head != (mynode *)0)

{

temp = reverse_recurse(head);

temp->next = (mynode *)0;

}

//Print it again

print_list();

return(0);

}

// Reverse the linked list recursively

//

// This function uses the power of the stack to make this

// *magical* assignment

//

// node->next->next=node;

//

// :)

mynode* reverse_recurse(mynode *root)

{

if(root->next!=(mynode *)0)

{

reverse_recurse(root->next);

root->next->next=root;

return(root);

}

else

{

head=root;

}

}

// Function to add new nodes to the linked list.

void add(int value)

{

temp = (mynode *) malloc(sizeof(struct node));

temp->next=(mynode *)0;

temp->value=value;

if(head==(mynode *)0)

{

head=temp;

tail=temp;

}

else

{

tail->next=temp;

tail=temp;

}

}

// Function to print the linked list.

void print_list()

{

printf("\n\n");

for(temp=head; temp!=(mynode *)0; temp=temp->next)

{

printf("[%d]->",(temp->value));

}

printf("[NULL]\n\n");

}

Method3 (Recursive, but without ANY global variables.
Slightly messy!)

#include <stdio.h>

// Variables

typedef struct node

{

int value;

struct node *next;

}mynode;

// Functions

void add(mynode **head, mynode **tail, int value);

mynode* reverse_recurse(mynode *current, mynode *next);

void print_list(mynode *);

int main()

{

mynode *head, *tail;

head=(mynode *)0;

// Construct the linked list.

add(&head, &tail, 1);

add(&head, &tail, 2);

add(&head, &tail, 3);

//Print it

print_list(head);

// Reverse it.

head = reverse_recurse(head, (mynode *)0);

//Print it again

print_list(head);

getch();

return(0);

}

// Reverse the linked list recursively

mynode* reverse_recurse(mynode *current, mynode *next)

{

mynode *ret;

if(current==(mynode *)0)

{

return((mynode *)0);

}

ret = (mynode *)0;

if (current->next != (mynode *)0)

{

ret = reverse_recurse(current->next, current);

}

else

{

ret = current;

}

current->next = next;

return ret;

}

// Function to add new nodes to the linked list.

// Takes pointers to pointers to maintain the

// *actual* head and tail pointers (which are local to
main()).

void add(mynode **head, mynode **tail, int value)

{

mynode *temp1, *temp2;

temp1 = (mynode *) malloc(sizeof(struct node));

temp1->next=(mynode *)0;

temp1->value=value;

if(*head==(mynode *)0)

{

*head=temp1;

*tail=temp1;

}

else

{

for(temp2 = *head; temp2->next!= (mynode *)0;
temp2=temp2->next);

temp2->next = temp1;

*tail=temp1;

}

}

// Function to print the linked list.

void print_list(mynode *head)

{

mynode *temp;

printf("\n\n");

for(temp=head; temp!=(mynode *)0; temp=temp->next)

{

printf("[%d]->",(temp->value));

}

printf("[NULL]\n\n");

}

Doubly linked lists

This is really easy, just keep swapping the prev and next
pointers and at the end swap the

head and the tail:)

#include<stdio.h>

#include<ctype.h>

typedef struct node

{

int value;

struct node *next;

struct node *prev;

}mynode ;

mynode *head, *tail;

void add_node(int value);

void print_list();

void reverse();

int main()

{

head=NULL;

tail=NULL;

add_node(1);

add_node(2);

add_node(3);

add_node(4);

add_node(5);

print_list();

reverse();

print_list();

return(1);

}

void add_node(int value)

{

mynode *temp, *cur;

temp = (mynode *)malloc(sizeof(mynode));

temp->next=NULL;

temp->prev=NULL;

if(head == NULL)

{

printf("\nAdding a head pointer\n");

head=temp;

tail=temp;

temp->value=value;

}

else

{

for(cur=head;cur->next!=NULL;cur=cur->next);

cur->next=temp;

temp->prev=cur;

temp->value=value;

tail=temp;

}

}

void print_list()

{

mynode *temp;

printf("\n--------------------------------\n");

for(temp=head;temp!=NULL;temp=temp->next)

{

printf("\n[%d]\n",temp->value);

}

}

void reverse()

{

mynode *cur, *temp, *save_next;

if(head==tail)return;

if(head==NULL || tail==NULL)

return;

for(cur=head;cur!=NULL;)

{

printf("\ncur->value : [%d]\n",cur->value);

temp=cur->next;

save_next=cur->next;

cur->next=cur->prev;

cur->prev=temp;

cur=save_next;

} temp=head;

head=tail;

tail=temp;

}

2. Given only a pointer to a node to
be deleted in a singly linked list, how do you delete it?

This is a very good interview question

The solution to this is to copy the data from the next node
into this node and delete the

next node!. Of course this won’t work if the node to be
deleted is the last node. Mark it as

Dummy in that case. If you have a Circular linked list, then
this might be all the more

Interesting. Try writing your own C program to solve this
problem. Having a doubly

Linked list is always better.

3. How do you sort a linked list?
Write a C program to sort a linked list.

This is a very popular interview question, which most people
go wrong. The ideal

Solution to this problem is to keep the linked list sorted
as you build it. This really saves a

Lot of time which would have been required to sort it.

However....

Method1 (Usual method)

The general idea is to decide upon a sorting algorithm (say
bubble sort). Then, one needs

to come up with different scenarios to swap two nodes in the
linked list when they are not

in the required order. The different scenarios would be
something like

1. When the nodes being compared are not adjacent and one of
them is the first node.

2. When the nodes being compared are not adjacent and none
of them is the first node

3. When the nodes being compared are adjacent and one of
them is the first node.

4. When the nodes being compared are adjacent and none of
them is the first node.

One example bubble sort for a linked list goes like this

for(i = 1; i < n; i++)

{

p1 = head;

p2 = head->next;

p3 = p2->next;

for(j = 1; j <= (n - i); j++)

{

if(p2->value < p3->value)

{

p2->next = p3->next;

p3->next = p2;

p1->next = p3;

p1 = p3;

p3 = p2->next;

}

else

{

p1 = p2;

p2 = p3;

p3 = p3->next;

}

}

}

As you can see, the code becomes quite messy because of the
pointer logic. Thats why I

have not elaborated too much on the code, nor on variations
such as soring a doubly

linked list. You have to do it yourself once to understand
it.

Method1 (Divide and Conquer using merge sort)

The pseudocode for this method is

typedef struct node

{

int value;

struct node *next;

}mynode;

mynode *head, *tail;

int size;

mynode *mergesort(mynode *list, int size);

void display(mynode *list);

mynode *mergesort(mynode *list, int size)

{

int size1, size2;

mynode *tempnode1, *tempnode2, *tempnode3;

if( size<=2 )

{

if(size==1)

{

// Nothing to sort!

return(list);

}

else

{

if(list->value < list->next->value

{

// These 2 nodes are already in right order, no need to sort

return(list);

}

else

{

// Need to swap these 2 nodes

/* Here we have 2 nodes

*

*node 1 -> node2 -> NULL

*

* This should be converted to

*

* node2 -> node1 -> NULL

*

*/

tempnode1 = list;

tempnode2 = list->next;

tempnode2->next = tempnode1;

tempnode1->next = NULL;

return(tempnode2);

}

}

}

else

{

// The size of the linked list is more than 2.

// Need to split this linked list, sort the

// left and right sub-linked lists and merge.

// Split.

// tempnode1 will have the first half of the linked list of
size "size1".

// tempnode2 will have the second half of the linked list of
size "size2".

<CODE TO SPLIT THE LINKED LIST INTO TWO>

// Sort the two halves recursively

tempnode1 = mergesort(tempnode1, size1);

tempnode2 = mergesort(tempnode2, size2);

// Now merge the sorted lists back, let tempnode3 point to
that new list.

<CODE TO MERGE THE 2 LINKED LISTS BACK INTO A SINGLE

SORTED LINKED LIST>

return(tempnode3);

}

}

The code to merge the two already sorted sub-linked lists
into a sorted linked list could be

something like this..

mynode * merge(mynode *a, mynode *b)

{

mynode *i, *j, *k, *c;

i = a;

j = b;

c = getNewNode();

k = getNewNode();

while(i != NULL && j != NULL)

{

if( i -> value < j -> value )

{

k -> next = i;

i = i -> next;

}

else

{

k -> next = j;

j = j -> next;

}

}

if( i != NULL)

k -> next = i ;

else

k -> next = j;

return( c -> next );

}

4.How to declare a structure of a
linked list?

The right way of declaring a structure for a linked list in
a C program is

struct node

{

int value;

struct node *next;

};

typedef struct node *mynode;

Note that the following are not correct

typedef struct

{

int value;

mynode next;

} *mynode;

The typedef is not defined at the point where the
"next" field is declared.

struct node

{

int value;

struct node next;

};

typedef struct node mynode;

You can only have pointer to structures, not the structure
itself as its recursive!

5.Write a C program to implement a
Generic Linked List.

Here is a C program which implements a generic linked list. The
crux of the solution is to use the void C

pointer to make it generic. Also notice how we use function
pointers to pass the address

of different functions to print the different generic data.

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

typedef struct list

{

void *data;

struct list *next;

} List;

struct check

{

int i;

char c;

double d;

}chk[] = { { 1, 'a', 1.1 },{ 2, 'b', 2.2 }, { 3, 'c', 3.3 }
};

void insert(List **, void *, unsigned int);

void print(List *, void (*)(void *));

void printstr(void *);

void printint(void *);

void printchar(void *);

void printcomp(void *);

List *list1, *list2, *list3, *list4;

int main(void)

{

char c[] = { 'a', 'b', 'c', 'd' };

int i[] = { 1, 2, 3, 4 };

char *str[] = { "hello1", "hello2",
"hello3", "hello4" };

list1 = list2 = list3 = list4 = NULL;

insert(&list1, &c[0], sizeof(char));

insert(&list1, &c[1], sizeof(char));

insert(&list1, &c[2], sizeof(char));

insert(&list1, &c[3], sizeof(char));

insert(&list2, &i[0], sizeof(int));

insert(&list2, &i[1], sizeof(int));

insert(&list2, &i[2], sizeof(int));

insert(&list2, &i[3], sizeof(int));

insert(&list3, str[0], strlen(str[0])+1);

insert(&list3, str[1], strlen(str[0])+1);

insert(&list3, str[2], strlen(str[0])+1);

insert(&list3, str[3], strlen(str[0])+1);

insert(&list4, &chk[0], sizeof chk[0]);

insert(&list4, &chk[1], sizeof chk[1]);

insert(&list4, &chk[2], sizeof chk[2]);

printf("Printing characters:");

print(list1, printchar);

printf(" : done\n\n");

printf("Printing integers:");

print(list2, printint);

printf(" : done\n\n");

printf("Printing strings:");

print(list3, printstr);

printf(" : done\n\n");

printf("Printing composite:");

print(list4, printcomp);

printf(" : done\n");

return 0;

}

void insert( List **p, void *data, unsigned int n )

{

List *temp;

int i;

/* Error check is ignored */

temp = malloc( sizeof ( List ) );

temp -> data = malloc( n );

for (i = 0; i < n; i++)

*( char * ) ( temp -> data + i ) = *( char * ) ( data + i
);

temp -> next = *p;

*p = temp;

}

void print( List *p, void ( *f ) ( void * ) )

{

while ( p )

{

( *f ) ( p -> data );

p = p -> next;

}

}

void printstr( void *str )

{

printf( " \"%s\"", ( char * ) str );

}

void printint( void *n )

{

printf( " %d", *( int * ) n );

}

void printchar( void *c )

{

printf( " %c", *( char * ) c );

}

void printcomp( void *comp )

{

struct check temp = *( struct check * )comp;

printf( " '%d:%c:%f ", temp.i, temp.c, temp.d );

}

6. How do you reverse a linked list
without using any C pointers?

One way is to reverse the data in the nodes without changing
the pointers themselves. One can also create a new linked list which is the
reverse of the original linked list. A simple C program can do that for you.
Please note that you would still use the "next" pointer fields to
traverse through the linked list (So in effect, you are using the pointers, but
you are not changing them when reversing the linked list).

7.How would you detect a loop in a
linked list? Write a C program to detect a loop in a linked list.

There are multiple answers to this problem. Here are a few C
programs to attack this

Problem.

Brute force method

Have a double loop, where you check the node pointed to by
the outer loop, with every

node of the inner loop.

typedef struct node

{

void *data;

struct node *next;

}mynode;

mynode * find_loop( NODE * head )

{

mynode *current = head;

while( current -> next != NULL )

{

mynode *temp = head;

while( temp -> next != NULL && temp != current )

{

if( current -> next == temp )

{

printf("\nFound a loop.");

return current;

} temp =

temp -> next;

}

current = current -> next;

}r

eturn NULL;

}

Visited flag

Have a visited flag in each node of the linked list. Flag it
as visited when you reach the

node. When you reach a node and the flag is already flagged
as visited, then you know

there is a loop in the linked list.

Fastest method

Have 2 pointers to start of the linked list. Increment one
pointer by 1 node and the other

by 2 nodes. If there's a loop, the 2nd pointer will meet the
1st pointer somewhere. If it

does, then you know there's one.

Here is some code

p = head;

q = head -> next;

while( p != NULL && q != NULL )

{

if( p == q )

{

//Loop detected!

exit( 0 );

}

p = p -> next;

q = ( q -> next ) ? ( q -> next -> next ) : q ->
next;

}

// No loop.

8.How do you find the middle of a linked list? Write a C
program to return the

middle of a linked list

Another popular interview question

Here are a few C program snippets to give you an idea of the
possible solutions.

Method1

p = head;

q = head;

if( q -> next -> next != NULL)

{

p = p -> next;

q = q -> next -> next;

}

printf("The middle element is %d",p->data);

Here p moves one step, where as q moves two steps, when q
reaches end, p will be at the

middle of the linked list.

Method2

struct node *middle(struct node *head)

{

struct node *middle=NULL;

int i;

for( i = 1 ; head ; head = head -> next , i++)

{

if( i == 1 )

middle = head ;

else if ( ( i % 2 ) == 1 )

middle = middle -> next ;

}r

eturn middle;

} In a

similar way, we can find the 1/3

th node of linked list by changing (

i

%

2

== 1

)

to (

i

% 3 == 1 ) and in the same way we can find nth node of list
by changing ( i % 2 == 1 ) to

( i % n == 1 ) but make sure ur ( n <= i ).

9.If you are using C language to implement the heterogeneous
linked list, what

pointer type will you use?

The heterogeneous linked list contains different data types
in its nodes and we

need a link, pointer to connect them. It is not possible to
use ordinary pointers for this. So

we go for void pointer. Void pointer is capable of storing
pointer to any type as it is a

generic pointer type.

Check out the C program to implement a Generic linked list
in the same FAQ.

10.How to compare two linked lists? Write a C program to
compare two linked lists.

Here is a simple C program to accomplish the same.

int compare_linked_lists( struct node *q, struct node *r )

{

static int flag ;

if ( ( q == NULL ) && ( r == NULL ) )

{

flag=1;

}

else

{

if ( q == NULL || r == NULL )

{

flag = 0 ;

}

if ( q -> data != r -> data )

{

flag = 0;

}

else

{

compare_linked_lists ( q -> link , r -> link ) ;

}

}r

eturn ( flag ) ;

}

Another way is to do it on similar lines as strcmp()
compares two strings, character by

character (here each node is like a character).

11.How to create a copy of a linked list? Write a C program
to create a copy of a

linked list.

Check out this C program which creates an exact copy of a
linked list.

copy_linked_lists ( struct node *q , struct node **s )

{

if ( q != NULL )

{

*s = malloc ( sizeof ( struct node ) ) ;

( *s ) -> data = q -> data ;

( *s ) -> link = NULL ;

copy_linked_list ( q -> link , & ( ( *s ) -> link
) );

}

}

12.Write a C program to free the nodes of a linked list

Before looking at the answer, try writing a simple C program
(with a for loop) to do this.

Quite a few people get this wrong.

This is the wrong way to do it:

struct list *listptr, *nextptr ;

for( listptr = head ; listptr != NULL ; listptr = listptr
-> next )

{

free( listptr ) ;

}

If you are thinking why the above piece of code is wrong,
note that once you free

the listptr node, you cannot do something like listptr =
listptr->next!. Since listptr is

already freed, using it to get listptr->next is illegal
and can cause unpredictable results

This is the right way to do it:

struct list *listptr, *nextptr;

for( listptr = head ; listptr != NULL ; listptr = nextptr )

{

nextptr = listptr -> next ;

free( listptr ) ;

}

13. Can we do a Binary search on a
linked list

The answer is ofcourse, you can write a C program to do
this. But, the question is, do you

really think it will be as efficient as a C program which
does a binary search on an array?

Think hard, real hard.

Do you know what exactly makes the binary search on an array
so fast and efficient? Its

the ability to access any element in the array in constant
time. This is what makes it so

fast. You can get to the middle of the array just by saying
array[middle]!. Now, can you

do the same with a linked list? The answer is No. You will
have to write your own,

possibly inefficient algorithm to get the value of the
middle node of a linked list. In a

linked list, you loosse the ability to get the value of any
node in a constant time.

One solution to the inefficiency of getting the middle of
the linked list during a binary

search is to have the first node contain one additional
pointer that points to the node in the

middle. Decide at the first node if you need to check the
first or the second half of the

linked list. Continue doing that with each half-list.

14.Write a C program to return the nth node from the end of
a linked list.

Here is a solution which is often called as the solution
that uses frames.

Suppose one needs to get to the 6th node from the end in
this LL. First, just keep on

incrementing the first pointer (ptr1) till the number of
increments cross n (which is 6 in

this case)

STEP 1 : 1(ptr1,ptr2) -> 2 -> 3 -> 4 -> 5 ->
6 -> 7 -> 8 -> 9 -> 10

STEP 2 : 1(ptr2) -> 2 -> 3 -> 4 -> 5 ->
6(ptr1) -> 7 -> 8 -> 9 -> 10

Now, start the second pointer (ptr2) and keep on
incrementing it till the first pointer (ptr1)

reaches the end of the LL.

STEP 3 : 1 -> 2 -> 3 -> 4(ptr2) -> 5 -> 6
-> 7 -> 8 -> 9 -> 10 (ptr1)

So here you have! the 6th node from the end pointed to by
ptr2!

Here is some C code..

struct node

{

int data;

struct node *next;

}mynode;

mynode * nthNode(mynode *head, int n /*pass 0 for last
node*/)

{

mynode *ptr1,*ptr2 ;

int count ;

if( !head )

{

return( NULL ) ;

}

ptr1 = head ;

ptr2 = head ;

count = 0 ;

while( count < n )

{

count++ ;

if ( ( ptr1 = ptr1 -> next ) == NULL )

{

//Length of the linked list less than n. Error.

return( NULL );

}

}

while( ( ptr1 = ptr1 -> next ) != NULL )

{

ptr2 = ptr2 -> next ;

}r

eturn( ptr2 );

}

15. How would you find out if one of
the pointers in a linked list is corrupted or not?

This is a really good interview question. The reason is that linked
lists are used in a wide variety of scenarios and being able to detect and
correct pointer corruptions might be a very valuable tool. For example, data
blocks associated with files in a file system are usually stored as linked
lists. Each data block points to the next data block. A single corrupt pointer
can cause the entire file to be lost!Discover and fix bugs when they corrupt
the linked list and not when effect becomes visible in some other part

of the program. Perform frequent consistency checks (to see if the
linked list is indeed holding the data that you inserted into it). · It is good
programming practice to set the pointer value to NULL immediately

after freeing the memory pointed at by the pointer. This will help in
debugging, because it will tell you that the object was freed somewhere
beforehand. Keep track of how many objects are pointing to a object using
reference counts if required. · Use a good debugger to see how the
datastructures are getting corrupted and trace down the problem. Debuggers like
ddd on linux and memory profilers like Purify, Electric fence are good starting
points. These tools should help you track down heap corruption issues easily. ·
Avoid global variables when traversing and manipulating linked lists. Imagine what
would happen if a function which is only supposed to traverse a linked list using
a global head pointer accidently sets the head pointer to NULL!. · Its a good
idea to check the addNode() and the deleteNode() routines and test them for all
types of scenarios. This should include tests for inserting/deleting nodes at
the front/middle/end of the linked list, working with an empty linked list, running
out of memory when using malloc() when allocating memory for new nodes, writing
through NULL pointers, writing more data into the node fields then they can
hold (resulting in corrupting the (probably adjacent) "prev" and
"next" pointer fields), make sure bug fixes and enhancements to the
linked list code are reviewed and well tested (a lot of bugs come from quick
and dirty bug fixing), log and handle all possible errors (this will help you a
lot while debugging), add multiple levels of logging so that you can dig
through the logs. The list is endless... · Each node can have an extra field
associated with it. This field indicates the

number of nodes after this node in the linked list. This extra field
needs to be kept up-to-date when we inserte or delete nodes in the linked list
(It might become slightly complicated when insertion or deletion happens not at
end, but anywhere in the linked list). Then, if for any node, p->field >
0 and p->next == NULL, it surely points to a pointer corruption. · You could
also keep the count of the total number of nodes in a linked list and use it to
check if the list is indeed having those many nodes or not.

The problem in detecting such pointer corruptions in C is that its only
the programmer who knows that the pointer is corrupted. The program has no way
of knowing that something is wrong. So the best way to fix these errors is
check your logic and test your code to the maximum possible extent. I am not
aware of ways in C to recover the lost Nodes of a corrupted linked list. I have
a hunch that interviewers who ask this question are probably hinting at
something Called Smart Pointers in C++. Smart pointers are particularly useful
in the face of exceptions as they ensure proper destruction of dynamically
allocated objects. They can also be used to keep track of dynamically allocated
objects shared by multiple owners. This topic is out of scope here, but you can
find lots of material on the Internet for Smart Pointers. If you have better
answers to this question, let me know!

er
answers to this question, let me know!

with it. This field indicates the

number of nodes after this node in the linked list. This extra field
needs to be kept up-to-date when we inserte or delete nodes in the linked list
(It might become slightly complicated when insertion or deletion happens not at
end, but anywhere in the linked list). Then, if for any node, p->field >
0 and p->next == NULL, it surely points to a pointer corruption. · You could
also keep the count of the total number of nodes in a linked list and use it to
check if the list is indeed having those many nodes or not.

The problem in detecting such pointer corruptions in C is that its only
the programmer who knows that the pointer is corrupted. The program has no way
of knowing that something is wrong. So the best way to fix these errors is
check your logic and test your code to the maximum possible extent. I am not
aware of ways in C to recover the lost Nodes of a corrupted linked list. I have
a hunch that interviewers who ask this question are probably hinting at
something Called Smart Pointers in C++. Smart pointers are particularly useful
in the face of exceptions as they ensure proper destruction of dynamically
allocated objects. They can also be used to keep track of dynamically allocated
objects shared by multiple owners. This topic is out of scope here, but you can
find lots of material on the Internet for Smart Pointers. If you have better
answers to this question, let me know!