2. Which of the following is faster?
A binary search of an ordered set of elements in an array
or a sequential search of the elements?
Question No : 1
3. The binary search is faster than the sequential
search.
The complexity of binary search is 'log n' whereas the
complexity of a sequential search is 'n'.
In a binary search, each time we proceed, we have to deal
with only half of the elements of the array compared to the
previous one. So the search is faster.
Answer
4. List out the areas in which data structures are
applied extensively?
Question No : 2
7. Stack.
Because of its LIFO (Last In First Out) property it remembers
its caller and hence knows where to return to when the
function has to return.
Recursion makes use of system stack for storing the return
addresses of the function calls. Every recursive function
has its equivalent iterative (non-recursive) function.
Even when such equivalent iterative procedures are written,
explicit stack is to be used.
Answer
8. Tree can have duplicate values :
True (or) False?
Question No : 4
9. True
Tree defines the structure of an acyclic graph but does not
disallow duplicates.
Answer
10. The size of a Tree is the number of nodes in the
Tree : True (or) False?
Question No : 5
11. True
The size denotes the number of nodes, height denotes the
longest path from leaf node to root node.
Answer
12. Ram is told to sort a set of Data using Data structure.
He has been told to use one of the following Methods
a. Insertion
b. Selection
c. Exchange
d. Linear
Now Ram says a Method from the above can not be
used to sort. Which is the method?
Question No : 6
13. d. Linear
Using insertion we can perform insertion sort, using
selection we can perform selection sort, and using
exchange we can perform bubble sort.
But no sorting method is possible using linear method;
Linear is a searching method
Answer
14. Ashok is told to manipulate an Arithmetic
Expression. What is the data structure he will use?
a. Linked List
b. Tree
c. Graph
d. Stack
Question No : 7
15. d. Stack
Stacks are used to evaluate the algebraic or arithmetic
expressions using prefix or postfix notations
Answer
16. There are 8,15,13,14 nodes in 4 different trees.
Which of them could form a full binary tree?
a. 8
b. 15
c. 13
d. 14
Question No : 8
17. In general, there are 2n – 1 nodes in a full
binary tree.
By the method of elimination: Full binary tree contains
odd number of nodes.
So there cannot be a full binary tree with 8 or 14 nodes.
With 13 nodes, you can form a complete binary tree but
not a full binary tree.
Full and complete binary trees are different
All full binary trees are complete binary trees but not vice
versa
Answer
18. Full binary Tree:
A binary tree is a full binary tree if and only if:
Each non leaf node has exactly two child nodes
All leaf nodes have identical path length
It is called full since all possible node slots are
occupied A
B C
D E F G
Answer
19. Complete binary Tree:
A complete binary tree (of height h) satisfies the
following conditions:
Level 0 to h-1 represent a full binary tree of height h-1
One or more nodes in level h-1 may have 0, or 1 child
nodes
Answer
A
B C
D E F G
H I J K
20. How many null branches are there in a binary tree
with 20 nodes?
Question No : 9
21. 21 (null branches)
Let’s consider a tree with 5 nodes
So the total number of null nodes in a binary tree of n
nodes is n+1
Answer
Null branches
22. Write an algorithm to detect loop in a linked list.
You are presented with a linked list, which may have a
"loop" in it. That is, an element of the linked list may
incorrectly point to a previously encountered element,
which can cause an infinite loop when traversing the list.
Devise an algorithm to detect whether a loop exists in a
linked list. How does your answer change if you cannot
change the structure of the list elements?
Question No : 10
23. One possible answer is to add a flag to each element of
the list.
You could then traverse the list, starting at the head
and tagging each element as you encounter it.
If you ever encountered an element that was already
tagged, you would know that you had already visited it
and that there existed a loop in the linked list.
What if you are not allowed to alter the structure of the
elements of the linked list?
Answer
24. The following algorithm will find the loop:
a) Start with two pointers ptr1 and ptr2.
b) Set ptr1 and ptr2 to the head of the linked list.
c) Traverse the linked list with ptr1 moving twice as fast as ptr2
(for every two elements that ptr1 advances within the list,
advance ptr2 by one element).
d) Stop when ptr1 reaches the end of the list, or when ptr1 = ptr2.
e) If ptr1 and ptr2 are ever equal, then there must be a loop in the
linked list. If the linked list has no loops, ptr1 should reach the
end of the linked list ahead of ptr2
Answer
25. The Operation that is not allowed in a binary search
tree is
a. Location Change
b. Search
c. Deletion
d. Insertion
Question No : 11
27. Array is a type of ________________ data structure.
a. Non Homogenous
b. Non Linear
c. Homogenous but not Linear
d. Both Homogenous and Linear
Question No : 12
41. If every node u in Graph (G) is adjacent to every
other node v in G, it is called as _____ graph.
a. Directed Graph
b. Complete Graph
c. Connected Graph
d. Multi Graph
Question No : 19
43. Bubble sort is an example of
a. Selection sort technique
b. Exchange sort technique
c. Quick sort technique
d. None of the options
Question No : 20
45. How do you chose the best algorithm among
available algorithms to solve a problem
a. Based on space complexity
b. Based on programming requirements
c. Based on time complexity
d. All the above
Question No : 21
47. Which of the following are called descendants?
a. All the leaf nodes
b. Parents, grandparents
c. Root node
d. Children, grandchildren
Question No : 22
49. Choose the limitation of an array from the below
options.
a. Memory Management is very poor
b. Searching is slower
c. Insertion and deletion are costlier
d. Insertion and Deletion is not possible
Question No : 23
50. c. Insertion and deletion are costlier
(It involves shifting rest of the elements)
Answer
51. Areas where stacks are popularly used are.
a. Subroutines
b. Expression Handling
c. Recursion
d. All the above
Question No : 24
53. How would you implement queue using stack(s)?
Question No : 25
54. Use a temp stack
Data In into queue
Push the element into the original stack
Data Out from queue
Pop all the elements from stack into a temp stack
pop out the first element from the temp stack
Answer
55. Write a C program to compare two linked lists.
Question No : 26
57. Write a C program to return the nth node from the
end of a linked list.
Question No : 27
58. Suppose one needs to get to the 6th node from the end in the 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!
Answer
59. 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;
Answer
60. 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;
}
return(ptr2);
}
Answer
61. Write a C program to insert nodes into a linked list
in a sorted fashion?
Question No : 28
62. Answer
// Special case code for the head end
void linkedListInsertSorted(struct node**
headReference, struct node* newNode)
{
// Special case for the head end
if (*headReference == NULL || (*headReference)->data
>= newNode->data)
{
newNode->next = *headReference;
The solution is to iterate down the list looking for the correct place to
insert the new node. That could be the end of the list, or a point just
before a node which is larger than the new node.
Let us assume the memory for the new node has already been
allocated and a pointer to that memory is being passed to this
function.
63. Answer
*headReference = newNode;
}
else {
// Locate the node before which the insertion is to
happen!
struct node* current = *headReference;
while (current->next!=NULL && current->next->data <
newNode->data)
{
current = current->next;
}
newNode->next = current->next;
current->next = newNode;
}
}
64. Write a C program to remove duplicates from a
sorted linked list?
Question No : 29
65. Answer
// Remove duplicates from a sorted list
void RemoveDuplicates(struct node* head) {
struct node* current = head;
if (current == NULL) return; // do nothing if the
list is empty
// Compare current node with next node
while(current->next!=NULL)
{
As the linked list is sorted, we can start from the beginning of
the list and compare adjacent nodes.
When adjacent nodes are the same, remove the second one.
There's a tricky case where the node after the next node needs
to be noted before the deletion.
66. Answer
if (current->data == current->next->data)
{
struct node* nextNext = current->next->next;
free(current->next);
current->next = nextNext;
}
else
{
current = current->next; // only advance if no
deletion
}
}
}
67. Write a C program to find the depth or height of a
tree.
Question No : 30
69. Write C code to determine if two trees are identical
Question No : 31
70. Answer
struct Bintree {
int element;
struct Bintree *left;
struct Bintree *right;
};
typedef struct Bintree* Tree;
int CheckIdentical( Tree T1, Tree T2 )
{
if(!T1 && !T2) // If both tree are NULL then return true
return 1;
71. Answer
else if((!T1 && T2) || (T1 && !T2)) //If either of one is
NULL, return false
return 0;
else
return ((T1->element == T2->element) &&
CheckIdentical(T1->left, T2-i>left)
&& CheckIdentical(T1->right, T2->right));
// if element of both tree are same and left and right
tree is also same then both
trees are same
}
72. Write a C code to create a copy of a Tree
Question No : 32
74. Which of the following are called siblings
a. Children of the same parent
b. All nodes in the given path upto leaf node
c. All nodes in a sub tree
d. Children, Grand Children
Question No : 33
80. Data structure using sequential allocation is called
a. Linear Data Structure
b. Non-Linear Data Structure
c. Non-primitive Data Structure
d. Sequence Data Structure
Question No : 36
82. A linear list in which elements can be added or
removed at either end but not in the middle is
known as
a. Tree
b. Queue
c. Dequeue
d. Stack
Question No : 37
84. The average number of key comparisons done in a
successful sequential search in list of length n is
a. n+1/2
b. n-1/2
c. n/2
d. log n
Question No : 38
88. If a node has positive outdegree and zero indegree,
it is called a __________.
a. Source
b. Sink
c. outdegree node
d. indegree node
Question No : 40
92. If you are using C language to implement the
heterogeneous linked list, what pointer type will
you use?
Question No : 42
93. The heterogeneous linked list contains different
data types in its nodes and we need a pointer to
connect them.
It is not possible to use ordinary pointers for this.
So we use void pointer.
Void pointer is capable of storing pointer to any
type of data (eg., integer or character) as it is a
generic pointer type.
Answer
95. A Heap is an almost complete binary tree. In this tree, if the
maximum level is i, then, upto the (i-1)th level should be complete.
At level i, the number of nodes can be less than or equal to 2^i. If
the number of nodes is less than 2^i, then the nodes in that level
should be completely filled, only from left to right
The property of an ascending heap is that, the root is the lowest and
given any other node i, that node should be less than its left child
and its right child. In a descending heap, the root should be the
highest and given any other node i, that node should be greater than
its left child and right child.
Answer
96. To sort the elements, one should create the heap first. Once the
heap is created, the root has the highest value. Now we need to
sort the elements in ascending order. The root can not be
exchanged with the nth element so that the item in the nth
position is sorted. Now, sort the remaining (n-1) elements. This
can be achieved by reconstructing the heap for (n-1) elements.
Answer
97. heapsort() {
n = array(); // Convert the tree into
an array.
makeheap(n); // Construct the
initial heap.
for(i=n; i>=2; i--) {
swap(s[1],s[i]);
heapsize--;
keepheap(i);
}
}
makeheap(n) {
heapsize=n;
for(i=n/2; i>=1; i--)
keepheap(i);
}
keepheap(i) {
l = 2*i;
r = 2*i + 1;
p = s[l];
q = s[r];
t = s[i];
Answer
98. Answer
if(l<=heapsize && p->value > t->value)
largest = l;
else
largest = i;
m = s[largest];
if(r<=heapsize && q->value > m->value)
largest = r;
if(largest != i) {
swap(s[i], s[largest]);
keepheap(largest);
}
}
99. Implement the bubble sort algorithm. How can it
be improved? Write the code for selection sort,
quick sort, insertion sort.
Question No : 44
101. void bubble_sort(int a[], int n)
{
int i, j, temp;
int flag;
for(j = 1; j < n; j++) {
flag = 0;
for(i = 0; i < (n - j); i++) {
if(a[i] >= a[i + 1])
{
//Swap a[i], a[i+1]
flag = 1;
}
}
if(flag==0)break;
}
}
To improvise this basic algorithm, keep track of whether a
particular pass results in any swap or not.
If not, you can break out without wasting more cycles.
Answer
102. Selection Sort Algorithm
void selection_sort(int a[],
int n) {
int i, j, small, pos, temp;
for(i = 0; i < (n - 1); i++)
{
small = a[i];
pos = i;
for(j = i + 1; j < n; j++)
{
if(a[j] < small)
{
small = a[j];
pos = j;
}
}
temp = a[pos];
a[pos] = a[i];
a[i] = temp;
}
}
Answer
103. Quick Sort Algorithm
int partition(int a[], int low, int high)
{
int i, j, temp, key;
key = a[low];
i = low + 1;
j = high;
while(1) {
while(i < high && key >= a[i])i++;
while(key < a[j])j--;
if(i < j) {
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
else {
temp = a[low];
a[low] = a[j];
a[j] = temp;
return(j);
}
}
}
Answer
104. Answer
void quicksort(int a[], int low, int high)
{
int j;
if(low < high) {
j = partition(a, low, high);
quicksort(a, low, j - 1);
quicksort(a, j + 1, high);
}
}
int main() {
// Populate the array a
quicksort(a, 0, n - 1);
}
