Language: C++  Write a Program with Comments for your code to improve quick sort. The quick sort algorithm presented in the ClassNotes-Sorting, it selects the first element in the list as the pivot. Revise it by selecting the median among the first, middle, and last elements in the list. Explain your Outputs or Answers for the following: (A)  Analyze your algorithm, and give the results using order notation. (B)  Give a list of n items (for example, an array of 10 integers) representing a scenario.   Please compile your answers in a file including all source code with comments, Explain your running Outputs or Answers in (A) and (B).

Database System Concepts
7th Edition
ISBN:9780078022159
Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan
Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan
Chapter1: Introduction
Section: Chapter Questions
Problem 1PE
icon
Related questions
Question

Language: C++ 

Write a Program with Comments for your code to improve quick sort. The quick sort algorithm presented in the ClassNotes-Sorting, it selects the first element in the list as the pivot. Revise it by selecting the median among the first, middle, and last elements in the list.
Explain your Outputs or Answers for the following:

    1. (A)  Analyze your algorithm, and give the results using order notation.
    2. (B)  Give a list of n items (for example, an array of 10 integers) representing a scenario.

 

Please compile your answers in a file including all source code with comments, Explain your running Outputs or Answers in (A) and (B).

 

Quicksort that was mentioned in the ClassNotes:

#include <iostream>
using namespace std;

// Function prototypes
void quickSort(int list[], int arraySize);
void quickSort(int list[], int first, int last);
int partition(int list[], int first, int last);

void quickSort(int list[], int arraySize)
{
quickSort(list, 0, arraySize - 1);
}

void quickSort(int list[], int first, int last)
{
if (last > first)
{
int pivotIndex = partition(list, first, last);
quickSort(list, first, pivotIndex - 1);
quickSort(list, pivotIndex + 1, last);
}
}

// Partition the array list[first..last]
int partition(int list[], int first, int last)
{
int pivot = list[first]; // Choose the first element as the pivot
int low = first + 1; // Index for forward search
int high = last; // Index for backward search

while (high > low)
{
// Search forward from left
while (low <= high && list[low] <= pivot)
low++;

// Search backward from right
while (low <= high && list[high] > pivot)
high--;

// Swap two elements in the list
if (high > low)
{
int temp = list[high];
list[high] = list[low];
list[low] = temp;
}
}

while (high > first && list[high] >= pivot)
high--;

// Swap pivot with list[high]
if (pivot > list[high])
{
list[first] = list[high];
list[high] = pivot;
return high;
}
else
{
return first;
}
}

int main()
{
const int SIZE = 9;
int list[] = {1, 7, 3, 4, 9, 3, 3, 1, 2};
quickSort(list, SIZE);
for (int i = 0; i < SIZE; i++)
cout << list[i] << " ";

return 0;
}

```cpp
#include <iostream>
using namespace std;

// Function prototypes
void quickSort(int list[], int arraySize);
void quickSort(int list[], int first, int last);
int partition(int list[], int first, int last);

void quickSort(int list[], int arraySize)
{
    quickSort(list, 0, arraySize - 1);
}

void quickSort(int list[], int first, int last)
{
    if (last > first)
    {
        int pivotIndex = partition(list, first, last);
        quickSort(list, first, pivotIndex - 1);
        quickSort(list, pivotIndex + 1, last);
    }
}

// Partition the array list[first..last]
int partition(int list[], int first, int last)
{
    int pivot = list[first]; // Choose the first element as the pivot
    int low = first + 1; // Index for forward search
    int high = last; // Index for backward search

    while (high > low)
    {
        // Search forward from left
        while (low <= high && list[low] <= pivot)
            low++;

        // Search backward from right
        while (low <= high && list[high] > pivot)
            high--;

        // Swap two elements in the list
        if (high > low)
        {
            int temp = list[high];
            list[high] = list[low];
            list[low] = temp;
        }
    }

    while (high > first && list[high] >= pivot)
        high--;

    // Swap pivot with list[high]
    if (pivot > list[high])
    {
        list[first] = list[high];
        list[high] = pivot;
        return high;
    }
    else
    {
        return first;
    }
}

int main()
{
    const int SIZE = 9;
    int list[] = {1, 7, 3, 4, 9, 3, 3, 1, 2};
    quickSort(list, SIZE);
    for (int i = 0; i < SIZE; i++)
        cout << list[i] << " ";
    return 0;
}
```

**Code Explanation:**

This C++ program demonstrates the QuickSort algorithm for sorting an array of integers. 

- It starts by including the `<iostream>` library and using the `std` namespace.
-
Transcribed Image Text:```cpp #include <iostream> using namespace std; // Function prototypes void quickSort(int list[], int arraySize); void quickSort(int list[], int first, int last); int partition(int list[], int first, int last); void quickSort(int list[], int arraySize) { quickSort(list, 0, arraySize - 1); } void quickSort(int list[], int first, int last) { if (last > first) { int pivotIndex = partition(list, first, last); quickSort(list, first, pivotIndex - 1); quickSort(list, pivotIndex + 1, last); } } // Partition the array list[first..last] int partition(int list[], int first, int last) { int pivot = list[first]; // Choose the first element as the pivot int low = first + 1; // Index for forward search int high = last; // Index for backward search while (high > low) { // Search forward from left while (low <= high && list[low] <= pivot) low++; // Search backward from right while (low <= high && list[high] > pivot) high--; // Swap two elements in the list if (high > low) { int temp = list[high]; list[high] = list[low]; list[low] = temp; } } while (high > first && list[high] >= pivot) high--; // Swap pivot with list[high] if (pivot > list[high]) { list[first] = list[high]; list[high] = pivot; return high; } else { return first; } } int main() { const int SIZE = 9; int list[] = {1, 7, 3, 4, 9, 3, 3, 1, 2}; quickSort(list, SIZE); for (int i = 0; i < SIZE; i++) cout << list[i] << " "; return 0; } ``` **Code Explanation:** This C++ program demonstrates the QuickSort algorithm for sorting an array of integers. - It starts by including the `<iostream>` library and using the `std` namespace. -
Expert Solution
steps

Step by step

Solved in 3 steps with 1 images

Blurred answer
Knowledge Booster
Function Arguments
Learn more about
Need a deep-dive on the concept behind this application? Look no further. Learn more about this topic, computer-science and related others by exploring similar questions and additional content below.
Similar questions
  • SEE MORE QUESTIONS
Recommended textbooks for you
Database System Concepts
Database System Concepts
Computer Science
ISBN:
9780078022159
Author:
Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan
Publisher:
McGraw-Hill Education
Starting Out with Python (4th Edition)
Starting Out with Python (4th Edition)
Computer Science
ISBN:
9780134444321
Author:
Tony Gaddis
Publisher:
PEARSON
Digital Fundamentals (11th Edition)
Digital Fundamentals (11th Edition)
Computer Science
ISBN:
9780132737968
Author:
Thomas L. Floyd
Publisher:
PEARSON
C How to Program (8th Edition)
C How to Program (8th Edition)
Computer Science
ISBN:
9780133976892
Author:
Paul J. Deitel, Harvey Deitel
Publisher:
PEARSON
Database Systems: Design, Implementation, & Manag…
Database Systems: Design, Implementation, & Manag…
Computer Science
ISBN:
9781337627900
Author:
Carlos Coronel, Steven Morris
Publisher:
Cengage Learning
Programmable Logic Controllers
Programmable Logic Controllers
Computer Science
ISBN:
9780073373843
Author:
Frank D. Petruzella
Publisher:
McGraw-Hill Education