Question

In: Computer Science

// This program uses a bubble sort to arrange an array of integers in // ascending...

// This program uses a bubble sort to arrange an array of integers in

// ascending order (smallest to largest). It then display the array

// before the sorting and after the sorting. Modify the program so it orders

// integers in descending order (largest to smallest). Then add some code

// to display the array at each step of the algorithm. You don't have to

// modify anything in the main() function. All modification are inside

// the bubbleSortArray() function.

// EXAMPLE:

// The values before the bubble sort is performed are: 9 2 0 11 5

// The values are: 9 2 0 11 5

// The values are: 9 2 0 11 5

// The values are: 9 2 11 0 5

// The values are: 9 2 11 5 0

// The values are: 9 2 11 5 0

// The values are: 9 11 2 5 0

// The values are: 9 11 5 2 0

// The values are: 11 9 5 2 0

// The values are: 11 9 5 2 0

// The values are: 11 9 5 2 0

// The values after the bubble sort is performed are: 11 9 5 2 0

#include<iostream>

using namespace std;

// Function prototypes

void bubbleSortArray(int[], int);

const int SIZE = 5;

int main()

{

        int values[SIZE] = {9,2,0,11,5};

        // Displays the array before sorting

        cout << "The values before the bubble sort is performed are: ";

        for (int count = 0; count < SIZE; count++)

               cout << values[count] << " ";

        cout << endl;

        // Sort the array in ascending order using bubble sort algorithm

        bubbleSortArray(values,SIZE);

        // Display the array after sorting

        cout << "\n\nThe values after the bubble sort is performed are: ";

        for (int count = 0; count < SIZE; count++)

               cout << values[count] << " ";

        return 0;

}

//******************************************************************

//                      bubbleSortArray

//

// task:               to sort values of an array in ascending order

// data in:       the array, the array size

// data out:      the sorted array

//

//******************************************************************

void bubbleSortArray(int array[], int elems)

{

        bool swap;

        int temp;

        int bottom = elems - 1;     // Bottom indicates the end part of the

                                    // array where the largest values have

                                    // settled in order

do

        {

               swap = false;

               for (int count = 0; count < bottom; count++)

               {

                       if (array[count] > array[count+1])

                       { // The next three lines swap the two elements

                          temp = array[count];

                          array[count] = array[count+1];

                          array[count+1] = temp;

                          swap = true;        // Indicates that a swap occurred

                       }

                      

                       // Display array at each each step

                       cout << "\nThe values are: TO BE IMPLEMENTED";                 

                       // Add code here to diplay the complete array at each step

                       // Hint: for-loop similar to the one in the main() function               

               }

        bottom--;    // Bottom is decremented by 1 since each pass through

                         // the array adds one more value that is set in order

                           

        // Loop repeats until a pass through the array with no swaps occurs           

        } while(swap != false);

}

Solutions

Expert Solution

#include<iostream>
using namespace std;
// Function prototypes
void bubbleSortArray(int[], int);
const int SIZE = 5;
int main()
{
int values[SIZE] = {9,2,0,11,5};
// Displays the array before sorting
cout << "The values before the bubble sort is performed are: ";
for (int count = 0; count < SIZE; count++)
cout << values[count] << " ";
cout << endl;
// Sort the array in ascending order using bubble sort algorithm
bubbleSortArray(values,SIZE);
// Display the array after sorting
cout << "\n\nThe values after the bubble sort is performed are: ";
for (int count = 0; count < SIZE; count++)
cout << values[count] << " ";
return 0;
}

void bubbleSortArray(int array[], int elems)
{
for(int i=0; i<elems-1; i++){   //iterating all elements
           for(int j=0; j<(elems-i-1); j++){
               if(array[j]>array[j+1]){   //for every iteration checking previous array value is greater than next value in array
                   temp=array[j];   //putting larger value in temp variable
                   array[j]=array[j+1];   //putting smaller value in previous element's place
                   array[j+1]=temp;   //putting larger value in next element's place
               }
               //displaying the elements at every step of algorithms tells which elements are swapped
               cout<<"\nThe values are: ";
               for(int i=0;i<elems;i++){
                   cout<<array[i]<<" ";   //displaying elements
               }
           }
          
       }
}

--------------------------------------------------------------------------------------------------------------------------


Related Solutions

ASSEMBLY PROGRAM!!! QtSpim Sorting Data Add the Bubble Sort to minMaxArray.asm to sort the array into...
ASSEMBLY PROGRAM!!! QtSpim Sorting Data Add the Bubble Sort to minMaxArray.asm to sort the array into ascending order. Use the Bubble Sort algorithm from the lecture. You can use either Base Addressing or Indexed Addressing for the arrays. For this assignment, make sure you prompt the user for the numbers. Do not hard-code them in the data section. NOTE: Declare the array last in the Data section.
Write a MIPS program that uses an implementation of quick sort to sort an array of...
Write a MIPS program that uses an implementation of quick sort to sort an array of numbers (Translate the following code into (Mars Assembly language). Quicksort Implementation - C int partition(int arr [] , int left , int right) { int i=left, j=right; int tmp; int pivot = arr[(left + right) / 2]; while (i <= j) { while (arr [ i ] < pivot) i ++; while (arr [ j ] > pivot) j −−; if (i <= j)...
C++ Program (Using 2D array and bubble sort to sort data) A company pays its salespeople...
C++ Program (Using 2D array and bubble sort to sort data) A company pays its salespeople on a commission basis.  The salespeople each receive $250 per week plus 11 percent of their gross sales for the sales period.  For example, a salesperson who grosses $5000 in sales in the period receives $250 plus 11 percent of $5000, or a total of $812.21.  Write a program (using an array of counters) determines for each salesperson their total sales, their salary and additional data points.  There...
Write a MIPS program using the Bubble Sort algorithm, that sorts an input list of integers...
Write a MIPS program using the Bubble Sort algorithm, that sorts an input list of integers by repeatedly calling a “swap” subroutine. The original unsorted list of integers should be received from the keyboard input. Your program should first prompt the user “Please input an integer for the number of elements:”. After the user enters a number and return, your program outputs message “Now input each element and then a return:”. For example, if the user enters 5 as the...
Radix sortCome up with an unsorted array of numbers (integer array). Sort the numbers in ascending...
Radix sortCome up with an unsorted array of numbers (integer array). Sort the numbers in ascending order and descending order and display them using radix sort. First sort in ascending, then reset the array to its original order and finally sort the array again in descending order. I need this in java language.
Radix sortCome up with an unsorted array of numbers (integer array). Sort the numbers in ascending...
Radix sortCome up with an unsorted array of numbers (integer array). Sort the numbers in ascending order and descending order and display them using radix sort. First sort in ascending, then reset the array to its original order and finally sort the array again in descending order. I need this in java language. Radix Sort assignment (CISP430 ignore this part) This is only for those who are using Java How many classes do I need? A: Node, Queue, Radix, Driver...
1.   Bubble Sort Implement a bubble sort program that will read from a file “pp2.txt” from...
1.   Bubble Sort Implement a bubble sort program that will read from a file “pp2.txt” from the current directory a list of intergers (10 numbers to be exact), and the sort them, and print them to the screen. You can use redirection to read data from a given file through standard input, as opposed to reading the data from the file with the read API (similar to Lab #1). You can assume the input data will only have 10 numbers...
Java : Modify the selection sort algorithm to sort an array of integers in descending order....
Java : Modify the selection sort algorithm to sort an array of integers in descending order. describe how the skills you have gained could be applied in the field. Please don't use an already answered solution from chegg. I've unfortunately had that happen at many occasion ....... ........ sec01/SelectionSortDemo.java import java.util.Arrays; /** This program demonstrates the selection sort algorithm by sorting an array that is filled with random numbers. */ public class SelectionSortDemo { public static void main(String[] args) {...
Following is the algorithm of Quicksort for sorting an array of integers in ascending order. Partition(numbers,...
Following is the algorithm of Quicksort for sorting an array of integers in ascending order. Partition(numbers, lowIndex, highIndex) {    midpoint = lowIndex + (highIndex - lowIndex) / 2    pivot = numbers[midpoint]    done = false    while (!done) {       while (numbers[lowIndex] < pivot)          lowIndex++       while (pivot < numbers[highIndex])          highIndex--       if (lowIndex >= highIndex) {          done = true       }       else {          temp = numbers[lowIndex]          numbers[lowIndex] = numbers[highIndex]          numbers[highIndex] = temp                 lowIndex++          highIndex--       }    }    return highIndex } Quicksort(numbers, lowIndex, highIndex) {    if (lowIndex...
The bubble sort described in AS 7e is inefficient when perform on a larger array. To...
The bubble sort described in AS 7e is inefficient when perform on a larger array. To improve the efficiency, we have to observe the basic mechanism of Bubble Sort. Each inner loop of the Bubble sort always move the largest item on the unsorted left side to the sorted right side. When a list is sorted, we say the list is in ascending order by convention. We can enhance the efficiency of traditional Bubble sort by making only one swapping...
ADVERTISEMENT
ADVERTISEMENT
ADVERTISEMENT