# C++ Part 8

``````// ---------- C++ TUTORIAL 8 ----------

// Add this to Project Properties -std=c++14

// ---------- BUBBLE SORT ----------

#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
#include <numeric>
#include <sstream>
#include <ctime>
#include <cmath>

std::vector<int> GenerateRandVec(int numOfNums,
int min, int max);

void BubbleSort(std::vector<int>& theVec);

int main() {

// Generate a random vector of 10 values between 1 and 50
std::vector<int> vecVals = GenerateRandVec(10, 1, 50);

BubbleSort(vecVals);

// Output the sorted vector
for(auto x: vecVals)
std::cout << x << "\n";

return 0;

}

std::vector<int> GenerateRandVec(int numOfNums,
int min, int max){
std::vector<int> vecValues;

// Seed the random number generator
srand(time(NULL));

int i = 0, randVal = 0;

while(i < numOfNums){
// The min added on increases result based on min
// The remainder of modulus can't be greater
// then the divisor. We have to adjust down
// based on the addition from min
randVal = min + std::rand() % ((max + 1) - min);
vecValues.push_back(randVal);
i++;
}
return vecValues;
}

void BubbleSort(std::vector<int>& theVec){

// ----- SORT A LIST : BUBBLE SORT -----
// The Bubble sort is a way to sort a list
// It works this way
// 1. An outer loop decreases in size each time
// 2. The goal is to have the largest number at
// the end of the list when the outer loop
// completes 1 cycle
// 3. The inner loop starts comparing indexes
// at the beginning of the loop
// 4. Check if list[Index] > list[Index + 1]
// 5. If so swap the index values
// 6. When the inner loop completes the largest number is at
// the end of the list
// 7. Decrement the outer loop by 1

// Create the value that will decrement for the outer loop
// Its value is the last index in the list
int i = theVec.size() - 1;

while(i >= 1){
int j = 0;

while(j < i){
printf("\nIs %d > %d\n", theVec[j], theVec[j + 1]);

if(theVec[j] >= theVec[j+1]){
std::cout << "Switch\n";

int temp = theVec[j];
theVec[j] = theVec[j+1];
theVec[j+1] = temp;
} else {
std::cout << "Don't Switch\n";
}
j += 1;

for(auto k: theVec){
std::cout << k << ", ";
}
}
std::cout << "\nEnd of Round\n";
i -= 1;
}

// ---------- END OF BUBBLE SORT ----------

// ---------- RECURSION CALCULATING FACTORIALS ----------

int Factorial(int number);

int main() {

// A recursive function is one that calls itself
// You must have an exit condition or you'll have
// an infinite loop
// GetFactorial(3) = 3 * 2 * 1
std::cout << "Factorial 3 = " << Factorial(3) << "\n";

return 0;
}

// 1. 3 * Factorial(2) (2) = 6
// 2. 2 * Factorial(1) (1)
// 3. 1 Return 1

int Factorial(int number){
if(number == 1){
return 1;
} else {
int result = number * Factorial(number - 1);
return result;
}
}

// ---------- END RECURSION CALCULATING FACTORIALS ----------

// ----- PROBLEM PRINT ARRAY HORIZONTALLY -----

------------------
|  0  |  1  |  2  |
------------------
| 10  |  8  |  2  |
------------------

void PrintHorzVector(std::vector<int>& theVec);

int main() {

std::vector<int> theVec = {10,8,2,5,9,11,6,14};
PrintHorzVector(theVec);

return 0;
}

void PrintHorzVector(std::vector<int>& theVec){
int dashes = std::ceil(theVec.size() * 6);

for(int n = 0; n < dashes; n++)
std::cout << "-";
std::cout << "\n";

for(int n = 0; n < theVec.size(); n++)
printf("| %2d  ", n);
std::cout << "|\n";

for(int n = 0; n < dashes; n++)
std::cout << "-";
std::cout << "\n";

for(int n = 0; n < theVec.size(); n++)
printf("| %2d  ", theVec[n]);
std::cout << "|\n";

for(int n = 0; n < dashes; n++)
std::cout << "-";
std::cout << "\n";

}
// ----- END PROBLEM PRINT ARRAY HORIZONTALLY -----

// ----- PROBLEM : GENERATE FIBONACCI NUMBER -----
// Use recursion to generate the following results
// fib(0) = 0, fib(1) = 1, fib(2) = 1, fib(3) = 2,
// fib(4) = 3, fib(5) = 5, fib(6) = 8, fib(7) = 13

int Fib(int index);

int main() {
int index;
std::cout << "Get Fibonacci Index : ";
std::cin >> index;
printf("fib(%d) = %d\n", index, Fib(index));

return 0;

}

int Fib(int index){
if (index < 2){
return index;
} else {
return Fib(index - 1) + Fib(index - 2);
}
}

// ----- END PROBLEM : GENERATE FIBONACCI NUMBER -----

// Overloaded functions have the same names and
// return types, but have different parameters
double Area(double height, double width);

int main() {
std::cout << "Area Circle (c) or Rectangle (r) : ";
char areaType;
std::cin >> areaType;

switch(areaType){
case 'c' :
std::cout << "Enter Radius : ";
std::cout << "Area = " << Area(radius) << "\n";
break;
case 'r' :
std::cout << "Enter Height : ";
double height, width;
std::cin >> height;
std::cout << "Enter Width : ";
std::cin >> width;
std::cout << "Area = " << Area(height,width) << "\n";
break;
default : std::cout << "Please Enter c or r\n";
}
return 0;
}