Government College Narela , Bhopal

Session 2023 24
Class –BCA First Year
Subject –Major 2 ( Programming Methodology & Data Structures)
CCE – II Submitted to Dr. Teerath Prasad patel
Note – Long term answer type questions
Q.1 what is Array? Explain type with Suitable example.
Q.2 Explain Stack with operation and Algorithms.
Q.3 Explain Linked List with its Types.
Q.4 Explain tree with its types.
Q.5 What is sorting? explain
1) Bubble sort 2) selection sort 3) Quick Sort
Question: 1.

What is Array? Explain type with Suitable example.

Answer: 1.

An array is a data structure that stores a collection of elements, where each

element can be accessed using an index or a key. Arrays provide a way to organize
and store data of the same type in contiguous memory locations, making it
efficient to perform operations on the elements.

There are two main types of arrays: one dimensional arrays and
multidimensional arrays.

1. One Dimensional Array:

A one dimensional array is a collection of elements stored in a single line or row.
Elements in a one dimensional array are accessed using a single index.

Example in Python:
python
# Creating a one dimensional array (list in Python)
numbers = [1, 2, 3, 4, 5]

# Accessing elements using index

print(numbers[0]) # Output: 1
print(numbers[2]) # Output: 3
```
2. Multidimensional Array:
A multidimensional array is a collection of elements arranged in a table or
matrix format.
Elements in a multidimensional array are accessed using multiple indices.

Example in Python (using a nested list for a 2D array):

```python
# Creating a 2D array (list of lists in Python)
matrix = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]

# Accessing elements using indices

print(matrix[0][1]) # Output: 2
print(matrix[2][0]) # Output: 7
```

Arrays are widely used in programming to store and manipulate collections of

data efficiently. They provide a convenient way to access elements based on their
position in the collection, making it easier to perform various operations such as
sorting, searching, and iterating through the data.
Question: 2.

Explain Stack with operation and Algorithms.

Answer: 2.

A stack is a fundamental data structure that follows the Last In, First Out (LIFO)
principle. This means that the last element added to the stack is the first one to
be removed. Think of it as a collection of elements with two main operations:
push (to add an element) and pop (to remove the last added element).

Basic Operations on a Stack:

1. Push: This operation is used to add an element to the top of the stack.

2. Pop: This operation is used to remove the element from the top of the
stack.

3. Peek (or Top): This operation returns the element at the top of the stack
without removing it.

4. isEmpty: This operation checks if the stack is empty or not.

Algorithms using Stacks:

1. Balanced Parentheses:
 Using a stack, you can check if a given expression has balanced
parentheses. The algorithm involves iterating through the expression and
pushing opening parentheses onto the stack and popping when a closing
parenthesis is encountered. At the end, the stack should be empty for the
expression to be balanced.

2. Expression Evaluation:
 Stacks can be used to evaluate expressions in postfix or prefix notation. For
example, in postfix notation, you iterate through the expression and push
operands onto the stack. When an operator is encountered, you pop the
required number of operands, perform the operation, and push the result
back onto the stack.

3. Depth First Search (DFS) in Graphs

 Stacks are used in the iterative implementation of depth first search in
graph traversal. The algorithm involves pushing nodes onto the stack,
visiting them, and then exploring their neighbors.

4. Function Call Management:

 The call stack is a specific use of a stack in computer memory that keeps
track of function calls and returns in a program. Each function call is pushed
onto the stack, and when a function completes, it is popped off the stack.
Example of a Stack in Python:
```python
class Stack:
def __init__(self):
self.items = []

def isEmpty(self):
return len(self.items) == 0

def push(self, item):

self.items.append(item)

def pop(self):
if not self.isEmpty():
return self.items.pop()
else:
raise IndexError("pop from an empty stack")

def peek(self):
if not self.isEmpty():
return self.items[ 1]
else:
raise IndexError("peek from an empty stack")
 def size(self):
return len(self.items)

# Example Usage:
stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)

print("Top of the stack:", stack.peek()) # Output: 3

print("Stack size:", stack.size()) # Output: 3

stack.pop()
print("After pop, new top:", stack.peek()) # Output: 2
```

This is a basic implementation of a stack in Python. You can use it to perform

various operations like push, pop, peek, and check if the stack is empty.
Question: 3.

Explain Linked List with its Types.

Answer: 3.

A linked list is a linear data structure used for organizing and storing data. Unlike
arrays, elements in a linked list are not stored in contiguous memory locations;
instead, each element (node) points to the next one. This structure provides
flexibility in terms of size and allows for efficient insertions and deletions, though
accessing elements by index can be slower compared to arrays.

Here are the main types of linked lists:

1. Singly Linked List:

 In a singly linked list, each node contains data and a reference (or link) to
the next node in the sequence.
 The last node in the list typically has a null reference, indicating the end of
the list.

2. Doubly Linked List:

 In a doubly linked list, each node contains data, a reference to the next
node, and a reference to the previous node.
  This allows for more efficient traversal in both directions, but it requires
more memory due to the extra reference.

3. Circular Linked List:

 In a circular linked list, the last node in the list points back to the first node,
creating a loop.
 This structure is useful in certain scenarios, such as implementing a circular
buffer.

4. Singly Linked List with Tail Pointer:

 Similar to a singly linked list, but it maintains a reference to the last node
(tail).
 This makes appending to the list more efficient since there's no need to
traverse the entire list to find the last node.

5. Skip List:
 A more advanced type of linked list that incorporates multiple layers of
linked lists to allow for faster search operations.
  Skip lists are typically used in scenarios where a balance between simplicity
and search efficiency is needed.

Linked lists have various applications, and the choice of which type to use
depends on the specific requirements of a given problem. Each type has its own
advantages and trade offs in terms of memory usage, ease of implementation,
and performance for different operations.
Question: 4.

Explain tree with its types.

Answer: 4.

A tree, in the context of data structures, is a hierarchical data structure composed

of nodes connected by edges. Each node in a tree has a parent child relationship
with another node, except for the topmost node called the root, which has no
parent, and the nodes without children, known as leaves.

Here are some key terms associated with trees:

1. Node: A fundamental building block of a tree that contains data and may have
a reference to one or more child nodes.
2. Root: The topmost node in a tree; it has no parent.
3. Parent: A node that has one or more child nodes.
4. Child: A node that has a parent.
5. Leaf: A node that has no children, i.e., it is a node without any descendants.
6. Subtree: A tree formed by a node and all its descendants.
7. Depth: The level or distance of a node from the root. The root is considered to
be at depth 0, and its children are at depth 1, and so on.
8. Height: The length of the longest path from a node to a leaf. The height of the
tree is the height of the root.
#Types of Trees:

1. Binary Tree:
 Each node has at most two children, referred to as the left child and the
right child.
 Useful for representing hierarchical relationships, such as in expression
trees or binary search trees.

2. Binary Search Tree (BST):

 A binary tree where for each node, all elements in its left subtree are less
than the node, and all elements in its right subtree are greater.
 Allows for efficient search, insertion, and deletion operations.

3. AVL Tree:
 A self balancing binary search tree where the height difference between
the left and right subtrees of any node (called the balance factor) is limited
to { 1, 0, 1}.
 Maintains balance to ensure efficient operations.

4. B Tree:
 A balanced tree structure designed for efficient searching and retrieval in
large datasets.
 Widely used in databases and file systems.

5. Trie (Prefix Tree):

 A tree structure used to store a dynamic set of strings where the keys are
usually sequences, such as words.
 Commonly used in dictionaries and autocomplete systems.
6. N ary Tree:
 A tree in which each node can have more than two children.
 Generalizes the binary tree concept to allow for a variable number of child
nodes.

7. Red Black Tree:

 A type of self balancing binary search tree with additional properties to
maintain balance during insertion and deletion operations.
 Used to ensure worst case time complexity for operations in certain
applications.

8. Quadtree and Octree:

 Specialized tree structures used in computer graphics and spatial
indexing for efficient representation of two dimensional and three
dimensional space, respectively.

These are just a few examples, and there are many other types of trees used in
various applications based on specific requirements and use cases.
Question: 5.

What is sorting? explain

1) Bubble sort 2) selection sort 3) Quick Sort

Answer: 5.

Sorting is a fundamental operation in computer science that involves arranging

elements in a specific order, typically in either ascending or descending order
based on some criteria. The goal of sorting is to organize data to make it easier to
search, retrieve, and analyze. Efficient sorting algorithms are crucial for optimizing
the performance of various applications and algorithms that rely on ordered data.

There are various sorting algorithms, each with its own advantages and
disadvantages in terms of time complexity, space complexity, and stability. Here
are some commonly used sorting algorithms:

1. Bubble Sort:
 A simple sorting algorithm that repeatedly steps through the list,
compares adjacent elements, and swaps them if they are in the wrong
order.
 It has a time complexity of O(n^2) in the worst and average cases.

2. Selection Sort:
 An in place comparison sorting algorithm that divides the input list into a
sorted and an unsorted region.
 It has a time complexity of O(n^2) in all cases.
3. Insertion Sort:
 Builds the final sorted array one item at a time by repeatedly taking
elements from the unsorted part and inserting them into their correct
position in the sorted part.
 It has a time complexity of O(n^2) in the worst and average cases.

4. Merge Sort:
 A divide and conquer algorithm that divides the input into smaller parts,
recursively sorts them, and then merges them to produce a sorted output.
 It has a time complexity of O(n log n) in all cases, making it more efficient
than the previous algorithms for large datasets.

5. Quick Sort:
 Another divide and conquer algorithm that works by selecting a 'pivot'
element and partitioning the other elements into two sub arrays according
to whether they are less than or greater than the pivot.
 It has a time complexity of O(n log n) on average, but its worst case time
complexity is O(n^2).

6. Heap Sort:
 A comparison based sorting algorithm that uses a binary heap data
structure.
 It has a time complexity of O(n log n) in all cases, and it is often used where
a stable sort is not required.
7. Radix Sort:
 A non comparative integer sorting algorithm that distributes elements into
buckets according to their individual digits.
 It has linear time complexity O(nk) for integers with k digits.

Choosing the right sorting algorithm depends on the specific requirements of the
task at hand, such as the size of the dataset, the desired order, and the
characteristics of the data.