MOUNT KENYA UNIVERSITY

SCHOOL OF COMPUTING AND INFORMATICS

DEPARTMENT OF INFORMATION TECHNOLOGY
BIT 2203 DATA STRUCTURE AND ALGORITHM CLASS DISCUSION –
20/06/2024.
Instructions: Discuss the following questions into groups of 5 – 7 members.

MEMBERS PRESENT:

NAME REG. NO.

1 JAMES CHEGE NYAMBURA BEDA/2022/50725
2 ROY KIRIMA BEDA/2022/31661
3 PHYLIS WESONGA BSNE/2022/70540
4 JORAM MWAURA BIT/2023/54183
5 HANS KIPROP YEGO BEDA/2022/70663
6 JAMES CHEGE N BEDA/2022/50725
7 LUCY SILA BEDA/2022/52406

1. A programmer wants to store 1000 items in 64-bit computer. The

programmer needs to determine memory requirements before selecting the
data structure to use. Compute the memory requirements for storing the
above data using:
i. Array
ii. Singly Linked list
iii. Doubly linked list

Given:
 1000 items
 On a 64-bit computer
i. Array:
 Each item typically requires memory for its data (let's assume an integer for simplicity).
 Size of each integer (assuming 4 bytes for simplicity, but could vary based on data type):
o 4 bytes (32 bits)
Total memory for 1000 items in an array: Total memory=Size of each item×Number of items\
text {Total memory} = \text {Size of each item} \times \text{Number of
items}Total memory=Size of each item×Number of items
Total memory=4 bytes×1000=4000 bytes=4 KB\text{Total memory} = 4 \text{ bytes} \times
1000 = 4000 \text{ bytes} = 4 \text{ KB}Total memory=4 bytes×1000=4000 bytes=4 KB
ii. Singly Linked List:
 Each node consists of:
o Data (integer, assumed 4 bytes)
 oPointer/reference to the next node (8 bytes on a 64-bit system)
Total memory for 1000 items in a singly linked list:
 Assuming only data is stored in the nodes (pointers are separate):
Total memory=Size of each item×Number of items\text{Total memory} = \text{Size of
each item} \times \text{Number of
items}Total memory=Size of each item×Number of items
Total memory=4 bytes×1000=4000 bytes=4 KB\text{Total memory} = 4 \text{ bytes} \
times 1000 = 4000 \text{ bytes} = 4 \
text{ KB}Total memory=4 bytes×1000=4000 bytes=4 KB
iii. Doubly Linked List:
 Each node consists of:
o Data (integer, assumed 4 bytes)
o Pointer/reference to the next node (8 bytes)
o Pointer/reference to the previous node (8 bytes)
Total memory for 1000 items in a doubly linked list:
Total memory=Size of each item×Number of items\text{Total memory} = \text{Size of each
item} \times \text{Number of items}Total memory=Size of each item×Number of items
Total memory=(4+8+8) bytes×1000=20 KB\text{Total memory} = (4 + 8 + 8) \text{ bytes} \
times 1000 = 20 \text{ KB}Total memory=(4+8+8) bytes×1000=20 KB

2. Illustrate how linked list can be used to represent a stack.

3. An engineering team at a tech company in developing a photo editing app

that applies filters to each pixel of an image. They need to determine the best
way to store and process the image data. How would team store and process
the image data using arrays?

a. Image Representation: In digital image processing, images are

typically represented as 2D arrays of pixels. Each pixel contains color
information (RGB values, for example) that determines its appearance.

b. Array Structure: The team can use multi-dimensional arrays to

represent the image data. For example, a 2D array can be used where each
element represents a pixel in the image. The dimensions of the array
would correspond to the width and height of the image.

ii. Data Storage: The RGB values of each pixel can be stored in the array elements.
Depending on the precision required, these values can be stored as integers (0-
255) or floating-point numbers (0.0-1.0).

iii. Processing Algorithms: Various image processing algorithms can be applied

to manipulate the image data stored in the arrays. For example, filters like
blurring, sharpening, edge detection, color correction, etc., can be applied to the
pixel values in the array.
 iv. Iterating Through Pixels: To process the image, the team would iterate
through the 2D array of pixels. Depending on the filter or operation being
applied, the team would access the pixel values, perform calculations, and update
the pixel values accordingly.

v. Performance Optimization: For performance optimization, the team can

consider parallel processing techniques or utilizing specialized libraries that offer
optimized image processing functions to speed up the processing of large images.

vi. Memory Management: Proper memory management is crucial when working

with image data in arrays. The team should ensure efficient allocation and
deallocation of memory to avoid memory leaks and optimize performance.

4. A software development team is tasked with creating a music playlist

application that allows users to add, remove, and reorder songs efficiently.
How would team implement the playlist using the linked lists?

i. Define Node Structure: The team should define a node structure representing
a playlist song. Each node would contain information about the song (such as
song title, artist, duration, etc.) and a pointer to the next node in the playlist.

ii. Create Linked List Class: Create a linked list class that manages the playlist.
This class should have methods to add songs to the playlist, remove songs from
the playlist, and reorder songs within the playlist.

iii. Add Songs: To add a song to the playlist, the team can create a new node with
the song information and append it to the end of the linked list. This operation is
efficient in a linked list as it involves updating pointers without the need to shift
elements like in an array.

iv. Remove Songs: To remove a song from the playlist, the team can traverse the
linked list to find the node to be removed and adjust the pointers to exclude the
node from the list. This operation is also efficient in a linked list as it only
requires updating pointers.

v. Reorder Songs: To reorder songs within the playlist, the team can manipulate
the pointers in the linked list to change the order of nodes. This operation can be
done efficiently by adjusting pointers without the need to physically move
elements like in an array.

vi. Efficient Operations: Linked lists are efficient for adding and removing
elements at any position in the list. The team can take advantage of this feature to
provide users with efficient ways to manage their playlists.

vii. User Interface Integration: Integrate the linked list operations with the user
interface of the music playlist application to provide users with a seamless
experience in adding, removing, and reordering songs in their playlists.
5. A group of developers is working on a text editor that requires an efficient
undo feature, allowing users to revert their last actions. How would
developer use a stack to implement the undo functionality?

i. Define a Stack: The developers would start by defining a stack data structure to
store the actions performed by the user. Each action would be represented as a
"command" object or a data structure that encapsulates the information needed
to revert the action.

ii. Push Actions onto the Stack: Whenever a user performs an action that can be
undone (such as typing, deleting text, formatting, etc.), the corresponding
command object representing that action is pushed onto the stack.

iii. Undo Operation: When a user triggers the undo operation, the top command
object from the stack is popped. This command object contains information on
how to revert the action. The text editor then applies this reversal operation to
undo the last action.

iv. Redo Operation: If the user wishes to redo an action after undoing it, the
command object popped during the undo operation can be stored in a separate
stack specifically for redo operations. The redo operation would involve popping
the top command object from the redo stack and applying the action again.

v. Efficiency: Using a stack for the undo feature ensures that the most recent
actions are easily accessible and quickly reversible. The LIFO (Last In, First Out)
nature of a stack aligns well with the concept of undoing actions in the reverse
order they were performed.

vi. Memory Management: To prevent the stack from growing indefinitely and
consuming excessive memory, developers can limit the size of the stack. Once the
stack reaches the maximum size, older actions can be removed as new actions are
pushed onto the stack.

vii. User Interface Integration: The undo and redo functionality should be
seamlessly integrated into the user interface of the text editor, allowing users to
easily undo and redo actions with familiar keyboard shortcuts or menu options.

6. An algorithm design class is tasked with solving the coin change problem,
where the goal is to minimize the number of coins used to make a given
amount. How would a class approach this problem using a greedy algorithm

Problem Definition:
Given a set of coin denominations and a target amount, the goal is to find the minimum
number of coins needed to make the target amount.

Greedy Algorithm Approach:

 a. Sort the Coins: Ensure that the coin denominations are sorted in
descending order. This allows the algorithm to always consider the largest
coin first.
b. Select Coins: Starting with the largest denomination, select as many
coins of that denomination as possible without exceeding the target
amount.
c. Update the Amount: Subtract the value of the selected coins from the
target amount.
d. Repeat: Move to the next largest denomination and repeat the process
until the target amount is zero.

Detailed Steps:
1. Sort the Coin Denominations:
- Given coin denominations: d1, d2, d3, ..., dn (where \(d1 > d2 > d3 > ... > dn\)).
- Example: If the coin denominations are \([1, 5, 10, 25]\), sort them in descending
order to get \([25, 10, 5, 1]\).

2. Initialize Variables:
- target_amount: The amount we want to make.
- coin_count: A counter to keep track of the number of coins used.

3. Greedy Selection:
- For each coin denomination di in the sorted list:
- While target_amount >= di:
- Use one coin of denomination di.
- Subtract di from target_amount.
- Increment coin_count.

4. Stop Condition:
- The algorithm stops when the target_amount becomes zero.

Example Walkthrough:
Let's assume the coin denominations are \([1, 5, 10, 25]\) and the target amount is 63.

1. Sort the Coin Denominations: \([25, 10, 5, 1]\).

2. Initialize:
- target_amount = 63
- coin_count = 0
3. Selection Process:
- Largest coin is 25:
- \(63 \geq 25\), use 1 coin of 25.
- New target_amount = 63 - 25 = 38
- Increment coin_count to 1.
- \(38 \geq 25\), use another coin of 25.
- New target_amount = 38 - 25 = 13
- Increment coin_count to 2.
- Next largest coin is 10:
- \(13 \geq 10\), use 1 coin of 10.
 - New target_amount = 13 - 10 = 3
- Increment coin_count to 3.
- Next largest coin is 5:
- \(3 < 5\), skip this denomination.
- Next largest coin is 1:
- \(3 \geq 1\), use 1 coin of 1.
- New target_amount = 3 - 1 = 2
- Increment coin_count to 4.
- \(2 \geq 1\), use another coin of 1.
- New target_amount = 2 - 1 = 1
- Increment coin_count to 5.
- \(1 \geq 1\), use another coin of 1.
- New target_amount = 1 - 1 = 0
- Increment coin_count to 6.

4. Result:
- Total coins used: 6.
- Denominations used: 2 coins of 25, 1 coin of 10, and 3 coins of 1.

7. A data science teams needs to sort a large dataset of customer records and is
considering different sorting algorithm. How would the data science team
use a divide and conquer to sort the dataset?

Merge Sort Algorithm

Concept:
Merge Sort works by dividing the dataset into smaller sub-datasets, sorting those sub-
datasets, and then merging them back together in sorted order.

Steps:
1. Divide: Split the dataset into two halves.
2. Conquer: Recursively sort each half.
3. Combine: Merge the two sorted halves back together.

Detailed Steps:

1. Divide the Dataset:

- If the dataset has more than one record, split it into two roughly equal parts.
- Example: For a dataset of 8 records, split it into two parts of 4 records each.

2. Recursively Sort Each Part:

- Apply Merge Sort to each part.
- This process continues until each part contains only one record, which is inherently
sorted.

3. Merge Sorted Parts:

- Merge the two sorted parts into one sorted dataset.
 - This is done by comparing the smallest elements of each part and sequentially
building a new sorted list.

Implementation Outline:

Pseudocode:
plaintext
function mergeSort(dataset):
if length of dataset <= 1:
return dataset
middle = length of dataset // 2
left_half = dataset[0:middle]
right_half = dataset[middle:]
sorted_left = mergeSort(left_half)
sorted_right = mergeSort(right_half)
return merge(sorted_left, sorted_right)

function merge(left, right):

sorted_list = []
while left is not empty and right is not empty:
if left[0] <= right[0]:
append left[0] to sorted_list
remove left[0] from left
else:
append right[0] to sorted_list
remove right[0] from right
while left is not empty:
append left[0] to sorted_list
remove left[0] from left
while right is not empty:
append right[0] to sorted_list
remove right[0] from right
return sorted_list

Example Walkthrough:
Assume the dataset of customer records is \([C, B, A, E, D, F]\).

1. Initial Split:
- Split into \([C, B, A]\) and \([E, D, F]\).

2. Recursive Sorting:
- Sort \([C, B, A]\):
- Split into \([C]\) and \([B, A]\).
- \([C]\) is already sorted.
- Sort \([B, A]\):
 - Split into \([B]\) and \([A]\).
- \([B]\) and \([A]\) are already sorted.
- Merge \([B]\) and \([A]\) into \([A, B]\).
- Merge \([C]\) and \([A, B]\) into \([A, B, C]\).
- Sort \([E, D, F]\):
- Split into \([E]\) and \([D, F]\).
- \([E]\) is already sorted.
- Sort \([D, F]\):
- Split into \([D]\) and \([F]\).
- \([D]\) and \([F]\) are already sorted.
- Merge \([D]\) and \([F]\) into \([D, F]\).
- Merge \([E]\) and \([D, F]\) into \([D, E, F]\).

3. Final Merge:
- Merge \([A, B, C]\) and \([D, E, F]\) into \([A, B, C, D, E, F]\).

Advantages:
- Stable Sorting: Merge Sort preserves the relative order of records with equal keys.
- Performance: It has a predictable time complexity of \(O(n \log n)\), which is efficient
for large datasets.
- Memory Usage: Merge Sort requires additional space proportional to the dataset size.

8. A software engineering team is optimizing an algorithm that processes large

datasets in a financial application. They need to evaluate its efficiency. How
would the team analyze and optimize the time and space complexity of your
algorithm?
Analysis

1. Understand the Algorithm: Begin by thoroughly understanding the algorithm's

purpose and functionality. Break down its operations, inputs, and outputs.

2. Identify the Key Operations: Focus on the most critical operations that contribute
to the algorithm's running time and memory usage, such as loops, recursive calls, and
data structure manipulations.

3. Big O Notation: Use Big O notation to express the time and space complexity. This
involves:
- Time Complexity: Determine how the running time increases with the size of the
input \( n \). Identify the worst-case, average-case, and best-case scenarios.
- Space Complexity: Determine how the memory usage increases with the size of the
input \( n \). Consider both the stack space for recursive algorithms and the heap space
for data structures.

4. Empirical Analysis: Implement the algorithm and measure its performance using
real datasets. Record the execution time and memory usage for different input sizes to
validate theoretical complexities.

Optimization
1. Profile the Algorithm: Use profiling tools to identify bottlenecks and hotspots in
the code. These tools can help pinpoint specific lines or functions that consume the most
time or memory.

2. Optimize Hotspots: Focus on optimizing the identified hotspots. Common

optimization techniques include:
- Improving Loop Efficiency: Reduce the complexity of nested loops or replace them
with more efficient algorithms.
- Efficient Data Structures: Use appropriate data structures that offer optimal
performance for the required operations (e.g., hash tables for quick lookups, heaps for
priority queues).
- Algorithmic Improvements: Replace inefficient algorithms with more efficient ones
(e.g., using merge sort instead of bubble sort).

3. Reduce Redundancy: Eliminate redundant computations by storing intermediate

results (memoization) or by refining the logic to avoid unnecessary work.

4. Space Optimization:
- In-place Algorithms: Modify the algorithm to work in place, reducing the need for
additional memory.
- Data Structure Optimization: Use data structures that consume less memory or
dynamically adjust their size.

5. Parallelism and Concurrency: If the algorithm can be parallelized, use multi-

threading or distributed computing to improve performance. Tools like MapReduce can
be helpful for processing large datasets.

6. Code Refactoring: Simplify and refactor code to make it more efficient. Ensure that
the code is clean and maintainable, which can also reduce hidden inefficiencies.

Validation

1. Testing: Rigorously test the optimized algorithm to ensure correctness. Use unit tests,
integration tests, and performance tests.

2. Benchmarking: Compare the performance of the optimized algorithm against the

original version using various datasets. Ensure that improvements in time and space
complexity translate to practical performance gains.

3. Documentation: Document the analysis, optimizations, and testing results. This

helps in maintaining the algorithm and in further future optimizations.

Continuous Improvement

1. Monitoring: In a production environment, monitor the performance of the algorithm

regularly. Use logging and monitoring tools to detect any performance degradation over
time.
 2. Feedback Loop: Create a feedback loop with stakeholders to gather insights and
identify areas for further improvement based on real-world usage.

9. A computer science class is learning about algorithm efficiency and needs to

compare the different sorting algorithms. How should the class use Big O
notation to describe the worst-time complexity of sorting algorithms?
Common Sorting Algorithms and Their Worst-Case Time Complexities

1. Bubble Sort:
- Description: Repeatedly steps through the list, compares adjacent elements, and
swaps them if they are in the wrong order.
- Worst-Case Complexity: \(O(n^2)\)
- Explanation: In the worst case, for each element, the algorithm makes a pass through
the entire list, resulting in \(n(n-1)/2\) comparisons and swaps.

2. Selection Sort:
- Description: Divides the list into a sorted and an unsorted region and repeatedly
selects the smallest (or largest) element from the unsorted region and moves it to the end
of the sorted region.
- Worst-Case Complexity: \(O(n^2)\)
- Explanation: It always performs \(n(n-1)/2\) comparisons regardless of the input.

3. Insertion Sort:
- Description: Builds the sorted list one item at a time, with each new item being
inserted into the correct position among the previously sorted items.
- Worst-Case Complexity: \(O(n^2)\)
- Explanation: In the worst case, every new element must be compared to all those
already sorted, leading to \(n(n-1)/2\) comparisons and shifts.

4. Merge Sort:
- Description: Divides the list into two halves, recursively sorts each half, and then
merges the two sorted halves.
- Worst-Case Complexity: \(O(n \log n)\)
- Explanation: Each division step is \(O(\log n)\) and merging two halves takes \
(O(n)\), leading to \(O(n \log n)\) in total.

5. Quick Sort:
- Description: Picks a pivot element, partitions the list into elements less than the pivot
and elements greater than the pivot, and recursively sorts the sublists.
- Worst-Case Complexity: \(O(n^2)\)
- Explanation: The worst case occurs when the pivot always ends up being the smallest
or largest element, causing the partitions to be highly unbalanced, leading to
\(n(n-1)/2\) comparisons.

6. Heap Sort:
- Description: Converts the list into a heap data structure, repeatedly removes the
maximum element from the heap, and rebuilds the heap until all elements are sorted.
 - Worst-Case Complexity: \(O(n \log n)\)
- Explanation: Building the heap takes \(O(n)\) and each extraction takes \(O(\log
n)\), resulting in \(O(n \log n)\).

7. Counting Sort:
- Description: Assumes that the input elements are in a fixed range, counts the
occurrences of each element, and then uses this information to place each element in its
correct position.
- Worst-Case Complexity: \(O(n + k)\) (where \(k\) is the range of the input values)
- Explanation: Counting each element takes \(O(n)\) and placing them into the output
array takes \(O(k)\).

8. Radix Sort:
- Description: Processes the digits of the numbers to be sorted, starting from the least
significant digit to the most significant digit, using a stable sorting algorithm (e.g.,
counting sort) at each digit level.
- Worst-Case Complexity: \(O(d(n + k))\) (where \(d\) is the number of digits and \
(k\) is the range of digit values)
- Explanation: Sorting by each digit takes \(O(n + k)\) and there are \(d\) digits to
process, resulting in \(O(d(n + k))\).

Using Big O Notation in Class

1. Define Big O Notation: Explain that Big O notation describes the upper bound of an
algorithm’s running time, focusing on the worst-case scenario as the input size \( n \)
grows.

2. Discuss Worst-Case Scenarios: For each sorting algorithm, discuss the specific
situations that lead to the worst-case time complexity.

3. Compare Complexities: Create a table or chart to compare the worst-case time

complexities of the sorting algorithms:
| Algorithm | Worst-Case Time Complexity |
|-----------------|----------------------------|
| Bubble Sort | \(O(n^2)\) |
| Selection Sort | \(O(n^2)\) |
| Insertion Sort | \(O(n^2)\) |
| Merge Sort | \(O(n \log n)\) |
| Quick Sort | \(O(n^2)\) |
| Heap Sort | \(O(n \log n)\) |
| Counting Sort | \(O(n + k)\) |
| Radix Sort | \(O(d(n + k))\) |

4. Illustrate with Examples: Provide examples with small datasets to visually

demonstrate how the sorting algorithms behave and why certain algorithms perform
better or worse in their worst-case scenarios.
 5. Discuss Practical Implications: Emphasize that while worst-case complexity is
important, average-case complexity and the constants hidden in Big O notation also play
crucial roles in practical performance.

10. are implementing a browser history feature where users can go back and
forth between pages. How would you use a linked list to manage the browser
history? Sure, here is the implementation of the browser history feature in
C++ using a doubly linked list:
cpp
#include <iostream>
#include <string>

class Node {
public:
std::string url;
Node* prev;
Node* next;

Node(const std::string& url) : url(url), prev(nullptr), next(nullptr) {}

};

class BrowserHistory {
private:
Node* current;

public:
BrowserHistory(const std::string& homepage) {
current = new Node(homepage);
}

~BrowserHistory() {
while (current->prev) {
current = current->prev;
}
while (current) {
Node* temp = current;
current = current->next;
delete temp;
}
}

void visit(const std::string& url) {

Node* newPage = new Node(url);
newPage->prev = current;
if (current) {
current->next = newPage;
 }
current = newPage;
}

std::string back(int steps) {

while (current->prev && steps > 0) {
current = current->prev;
steps--;
}
return current->url;
}

std::string forward(int steps) {

while (current->next && steps > 0) {
current = current->next;
steps--;
}
return current->url;
}
};

int main() {
BrowserHistory browserHistory("homepage.com");
browserHistory.visit("page1.com");
browserHistory.visit("page2.com");
browserHistory.visit("page3.com");

std::cout << "Current URL: " << browserHistory.back(1) << std::endl; //

page2.com
std::cout << "Current URL: " << browserHistory.back(1) << std::endl; //
page1.com
std::cout << "Current URL: " << browserHistory.forward(1) <<
std::endl; // page2.com
std::cout << "Current URL: " << browserHistory.visit("page4.com") <<
std::endl; // page4.com
std::cout << "Current URL: " << browserHistory.back(2) << std::endl; //
homepage.com
std::cout << "Current URL: " << browserHistory.forward(2) <<
std::endl; // page4.com
 return 0;
}
```

Explanation

1. Node Class:
- Each node represents a webpage with the URL, and pointers to the
previous and next nodes.
- Constructor initializes the URL and sets the `prev` and `next` pointers to
`nullptr`.

2. BrowserHistory Class:
- Manages the doubly linked list with a pointer to the current node.
- Constructor initializes the browser history with the homepage.
- Destructor ensures that all nodes are properly deleted to avoid memory
leaks.

3. visit Method:
- Creates a new node for the visited URL.
- Sets the `prev` pointer of the new node to the current node and updates
the `next` pointer of the current node.
- Updates the current pointer to the new node
4. back Method:
- Moves the current pointer to the previous node up to the given number of
steps, ensuring it does not move past the beginning of the list.
- Returns the URL of the node where the current pointer ends up.

5. forward Method:
- Moves the current pointer to the next node up to the given number of
steps, ensuring it does not move past the end of the list.
- Returns the URL of the node where the current pointer ends up.

6. main Function:
- Demonstrates the usage of the `BrowserHistory` class with a sequence of
visits, back, and forward operations
11 You are developing a calculator app that needs to evaluate mathematical
expressions. How would you use a stack to evaluate infix expressions?

Here’s a step-by-step breakdown of how to achieve this:

Step 1: Convert Infix Expression to Postfix Expression

1. Initialize:
- An empty stack for operators.
- An empty list for the output.

2. Process the Expression:

- Read tokens (operands, operators, and parentheses) from left to right.
- Use the following rules to handle each token:
- Operand: Add it to the output list.
- Left Parenthesis: Push it onto the stack.
- Right Parenthesis: Pop from the stack to the output list until a left parenthesis is
encountered.
- Operator: Pop operators from the stack to the output list until an operator with less
precedence or a left parenthesis is at the top of the stack. Then push the current operator
onto the stack.

3. End of Expression:
- Pop any remaining operators from the stack to the output list.

Step 2: Evaluate the Postfix Expression

1. Initialize:
- An empty stack for evaluation.

2. Process the Postfix Expression:

- Read tokens from left to right.
- Use the following rules to handle each token:
- Operand: Push it onto the stack.
- Operator: Pop the required number of operands from the stack, perform the
operation, and push the result back onto the stack.

3. End of Expression:
- The final result will be the only element remaining on the stack.

#include <iostream>
#include <stack>
#include <string>
#include <cctype>
#include <vector>

int precedence(char op) {

if (op == '+' || op == '-') {
 return 1;
}
if (op == '*' || op == '/') {
return 2;
}
return 0;
}

int applyOp(int a, int b, char op) {

switch (op) {
case '+': return a + b;
case '-': return a - b;
case '*': return a * b;
case '/': return a / b;
}
return 0;
}

std::vector<std::string> infixToPostfix(const std::string& expression) {

std::stack<char> stack;
std::vector<std::string> output;
std::string token;

for (char ch : expression) {

if (isdigit(ch)) { // Operand
token += ch;
} else {
if (!token.empty()) {
output.push_back(token);
token.clear();
}
if (ch == '(') { // Left Parenthesis
stack.push(ch);
} else if (ch == ')') { // Right Parenthesis
while (!stack.empty() && stack.top() != '(') {
output.push_back(std::string(1, stack.top()));
stack.pop();
}
stack.pop(); // Remove '('
} else { // Operator
while (!stack.empty() && precedence(stack.top()) >= precedence(ch)) {
output.push_back(std::string(1, stack.top()));
Explanation

1. Tokenization:
- The tokens list splits the expression into individual characters.
- In a real-world scenario, you would need a more sophisticated tokenizer to handle
multi-digit numbers and whitespace.
 2. Conversion:
- infix_to_postfix converts the infix expression to postfix notation using a stack to
handle operators and parentheses.
3. Evaluation:
- evaluate_postfix evaluates the postfix expression by using a stack to store operands
and applying operators as they are encountered.

4. Usage:
- The evaluate_expression function combines these steps, converting the infix
expression to postfix and then evaluating it.
11. You need to find the closest pair of points in a 2D plane from a large set of
points. How would you use a divide and conquer approach to solve this
problem?
Steps

1. Sort Points:
- Sort the points based on their x-coordinates. Let's call this sorted list \( P_x \).
- Sort the points based on their y-coordinates. Let's call this sorted list \( P_y \).

2. Divide:
- Find the median point in \( P_x \) to divide the set of points into two halves: left and
right.
- Split \( P_y \) into two lists: \( P_{yL} \) and \( P_{yR} \), which contain points
from the left and right halves, respectively.

3. Conquer:
- Recursively find the closest pair of points in the left half.
- Recursively find the closest pair of points in the right half.
- Find the minimum distance \( \delta \) between these two pairs.

4. Combine:
- Create a strip array containing points that are within a distance \( \delta \) from the
median line (the vertical line that divides the points into two halves).
- Sort the strip array based on the y-coordinates.
- Check each point in the strip against the next few points (at most 7 points) to find the
closest pair in the strip.

5. Return:
- The closest pair found either in the left half, right half, or within the strip.

Detailed Explanation and Pseudocode

Here’s the detailed breakdown and pseudocode of the algorithm:

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cfloat>

struct Point {
int x, y;
};

// Compare points by x-coordinate

bool compareX(const Point& a, const Point& b) {
return a.x < b.x;
}

// Compare points by y-coordinate

bool compareY(const Point& a, const Point& b) {
return a.y < b.y;
}

// Function to calculate the distance between two points

double dist(const Point& p1, const Point& p2) {
return sqrt((p1.x - p2.x) * (p1.x - p2.x) +
(p1.y - p2.y) * (p1.y - p2.y));
}

// Brute force method to find the smallest distance between points in a small array
double bruteForce(std::vector<Point>& points, int left, int right) {
double minDist = DBL_MAX;
for (int i = left; i < right; ++i) {
for (int j = i + 1; j <= right; ++j) {
minDist = std::min(minDist, dist(points[i], points[j]));
}
}
return minDist;
}

// Find the closest distance in the strip

double stripClosest(std::vector<Point>& strip, double d) {
double minDist = d;
std::sort(strip.begin(), strip.end(), compareY);

for (size_t i = 0; i < strip.size(); ++i) {

for (size_t j = i + 1; j < strip.size() && (strip[j].y - strip[i].y) < minDist; ++j) {
minDist = std::min(minDist, dist(strip[i], strip[j]));
}
}
return minDist;
}

// Recursive function to find the smallest distance

double closestUtil(std::vector<Point>& points, int left, int right) {
if (right - left <= 3) {
return bruteForce(points, left, right);
}

int mid = left + (right - left) / 2;

Point midPoint = points[mid];

double dl = closestUtil(points, left, mid);

double dr = closestUtil(points, mid + 1, right);

double d = std::min(dl, dr);

std::vector<Point> strip;
for (int i = left; i <= right; ++i) {
if (abs(points[i].x - midPoint.x) < d) {
strip.push_back(points[i]);
}
}

return std::min(d, stripClosest(strip, d));

}

// Main function to find the smallest distance

double closest(std::vector<Point>& points) {
std::sort(points.begin(), points.end(), compareX);
return closestUtil(points, 0, points.size() - 1);
}

int main() {
std::vector<Point> points = { {2, 3}, {12, 30}, {40, 50}, {5, 1}, {12, 10}, {3, 4} };
std::cout << "The smallest distance is " << closest(points) << std::endl;
return 0;
}

Explanation:

1. Sorting:
- Initially, the points are sorted by x-coordinates (Px) and y-coordinates (Py). This
sorting allows the divide step to efficiently divide the points and the combine step to
quickly find the points in the strip.

2. Divide:
- The points are divided into left and right halves using the median of the x-
coordinates.

3. Conquer:
 - Recursively find the closest pairs in the left and right halves. This recursion continues
until the base case, where the number of points is 3 or fewer, at which point a brute force
approach is used.

4. Combine:
- The strip contains points within distance \( \delta \) from the dividing line. The
closest pair in the strip is found by comparing each point to the next few points in the
sorted strip (y-coordinate).

5. Return:
- The closest pair is determined by comparing the distances from the left half, right
half, and the strip.