In this tutorial, we will learn about How to find the minimum and maximum in the list in C++. A list, in this context, refers to a collection of elements stored in a sequential manner. It can also be thought of as an array. In C++, you can use data structures like `std::vector`

or plain arrays (`int[]`

) to represent lists.

## Different Approaches to find min and max in the list

One approach involves directly comparing the elements in the array. This involves examining each element individually and determining the maximum and minimum values through comparisons.

You can achieve this through two distinct methods:

- The Iterative Approach
- The Recursive Approach

## By using the Iterative Approach

Iterative methods use loops, typically for or while loops, to address a problem by executing a defined set of instructions repeatedly until they satisfy a specific condition or reach a specific number of iterations. In this scenario, a loop is used to traverse the list and identify its minimum and maximum values.

In the iterative method of discovering the list’s minimum and maximum values, you usually set variables like `min_value`

and `max_value`

to initial values (such as the first element in the list). Then, you employ a loop to traverse the list, where you compare each element with these variables and modify them whenever you come across a smaller or larger value.

### Example:

```
#include <iostream>
#include <vector>
int main() {
std::vector<int> numbers = {5, 2, 8, 1, 9, 4};
if (numbers.empty()) {
std::cout << "List is empty." << std::endl;
return 1; // Exit with an error code
}
int min_value = numbers[0]; // Assume the first element is the minimum
int max_value = numbers[0]; // Assume the first element is the maximum
for (int i = 1; i < numbers.size(); ++i) {
if (numbers[i] < min_value) {
min_value = numbers[i];
}
if (numbers[i] > max_value) {
max_value = numbers[i];
}
}
std::cout << "Minimum: " << min_value << std::endl;
std::cout << "Maximum: " << max_value << std::endl;
return 0;
}
```

### Output:

```
Minimum: 1
Maximum: 9
```

This code iterates through the list and updates the `min_value`

and `max_value`

variables as it encounters smaller or larger elements, respectively. It starts with the assumption that the first element is both the minimum and maximum. It compares each subsequent element to find the actual minimum and maximum values.

## By using the Recursive Approach

This recursive approach efficiently divides the problem into smaller subproblems, reducing the number of comparisons needed to find the minimum and maximum values in the list.

**Problem Statement:**Given a list (or array) of integers, we want to find the minimum and maximum values in the list.**Recursive Function (**The recursive function`findMinMax`

):`findMinMax`

takes the following parameters:`numbers`

: The list of integers.`start`

: The index representing the start of the current sublist.`end`

: The index representing the end of the current sublist.

**Base Cases:**- If
`start`

is equal to`end`

, which means that there is only one element in the current sublist. In this case, we return an instance of the`MinMax`

struct where both`min_val`

and`max_val`

are set to this single element. - If
`start`

is one less than`end`

, it means there are two elements in the current sublist. In this case, we compare the two elements and return an instance of the`MinMax`

struct with the smaller element as`min_val`

and the larger element as`max_val`

.

- If
**Recursive Case:**- If the current sublist has more than two elements, we divide it into two halves. We calculate the midpoint index
`mid`

as`(start + end) / 2`

. - We recursively call
`findMinMax`

on the left half of the sublist (from`start`

to`mid`

) and the right half of the sublist (from`mid + 1`

to`end`

). - We obtain the minimum and maximum values from both the left and right sublists.
- Finally, we combine the minimum and maximum values from the left and right sublists to compute. It overall minimum and maximum values for the entire sublist.

- If the current sublist has more than two elements, we divide it into two halves. We calculate the midpoint index
**Result:**The`findMinMax`

function returns an instance of the`MinMax`

struct that contains the minimum and maximum values found within the specified sublist.**Main Function:**In the`main`

function, we initialize the list of integers, call the`findMinMax`

function on the entire list, and print out the minimum and maximum values.

### Example:

```
#include <iostream>
#include <vector>
struct MinMax {
int min_val;
int max_val;
};
MinMax findMinMax(const std::vector<int>& numbers, int start, int end) {
MinMax result;
// Base case: If the list has only one element
if (start == end) {
result.min_val = numbers[start];
result.max_val = numbers[start];
return result;
}
// Base case: If the list has two elements
if (start == end - 1) {
result.min_val = std::min(numbers[start], numbers[end]);
result.max_val = std::max(numbers[start], numbers[end]);
return result;
}
// Recursive case: Divide the list into two halves
int mid = (start + end) / 2;
MinMax left = findMinMax(numbers, start, mid);
MinMax right = findMinMax(numbers, mid + 1, end);
// Combine the results from the left and right sublists
result.min_val = std::min(left.min_val, right.min_val);
result.max_val = std::max(left.max_val, right.max_val);
return result;
}
int main() {
std::vector<int> numbers = {5, 2, 8, 1, 9, 4};
if (numbers.empty()) {
std::cout << "List is empty." << std::endl;
return 1; // Exit with an error code
}
MinMax result = findMinMax(numbers, 0, numbers.size() - 1);
std::cout << "Minimum: " << result.min_val << std::endl;
std::cout << "Maximum: " << result.max_val << std::endl;
return 0;
}
```

### Output:

```
Minimum: 1
Maximum: 9
```

In this code, the `findMinMax`

function takes a range of indices (`start`

and `end`

) and recursively divides the list into smaller sublists until it reaches the base cases (a single element or two elements). It then combines the minimum and maximum values from the left and right sublists to find the overall minimum and maximum for the entire list.