Question

Using the various sorting methods discussed create arrays of integers, doubles and strings with at least 25 values in each. Query the user on what array they want to sort and how they want to sort each array.

–Bubble sort

–Selection sort

–Insertion sort

–Quicksort

Part II with your arrays creates a means to search the arrays for values using sequential and binary searches.

Answer 1

#include<bits/stdc++.h>
#include <iostream>
#include <string>

void swap(int *xp, int *yp) //swap function
{
int temp = *xp;
*xp = *yp;
*yp = temp;
}

void bubbleSort(int arr[], int n) // bubblesort
{
int i, j;
for (i = 0; i < n-1; i++)
  
  
for (j = 0; j < n-i-1; j++)
if (arr[j] > arr[j+1])
swap(&arr[j], &arr[j+1]);
}
void selectionSort(int arr[], int n) // selectionSort
{
int i, j, min_idx;
  

for (i = 0; i < n-1; i++)
{
  
min_idx = i;
for (j = i+1; j < n; j++)
if (arr[j] < arr[min_idx])
min_idx = j;
  
  
swap(&arr[min_idx], &arr[i]);
}
}
void insertionSort(int arr[], int n) // insertionSort
{
int i, key, j;
for (i = 1; i < n; i++)
{
key = arr[i];
j = i - 1;
  
  
while (j >= 0 && arr[j] > key)
{
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key;
}
}
int part (int arr[], int low, int high) // partition to use in quick sort
{
int pivot = arr[high];   
int i = (low - 1);
  
for (int j = low; j <= high - 1; j++)
{
  
if (arr[j] < pivot)
{
i++;   
swap(&arr[i], &arr[j]);
}
}
swap(&arr[i + 1], &arr[high]);
return (i + 1);
}
  

void quickSort(int arr[], int low, int high) //quickSort
{
if (low < high)
{

int pi = part(arr, low, high);
  

quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}

int main()
{
int arr[25];
for(int i=0;i<25;i++){
cout<<"Enter the values";
cin>>arr[i];
}
double array[25];
for(int j=0;j<25;j++)
cout<<"Enter only double values";
cin>>array[j];
  
string arrays[25];
for(int s=0;s<25;s++){
cout<<"Enter string values";
cin>>arrays[s];
}
// Call functions by query
int n;

cin>>n;

switch(n)

{

case 1:

bubbleSort(arr,n);
break;

case2:
selectionSort(arr,n);
break;

case3:

insertionSort(arr ,n);

Insertion
break;

case(4):

quickSort(arr,n);
break;
}
}

This is the answer for the first part. For array of integers you can do it.

For other strings and doubles change the function call by the required data type.

For the 2nd part. You need to call the functions of linear search and binary search

int binarySearch(int arr[], int l, int r, int x)

{

    if (r >= l) {

        int mid = l + (r - l) / 2;

if (arr[mid] == x)

            return mid;

        // If element is smaller than mid, then

        // it can only be present in left subarray

        if (arr[mid] > x)

            return binarySearch(arr, l, mid - 1, x);

      // in right subarray

        return binarySearch(arr, mid + 1, r, x);

    }

    // We reach here when element is not

    // present in array

    return -1;

}

int linear_search(int arr[], int n, int x)

{

    int i;

    for (i = 0; i < n; i++)

        if (arr[i] == x)

            return i;

    return -1;

}

By calling these functions you can easily find the elements of an array