C++ Rearranging numbers in an array into ascending order - c++

Question

So I have a C++ lab that requires me to print out an array, remove some digits, and then insert some digits. I've managed to remove the correct digits and then insert the digits at the end but I need to sort the array into ascending order, Ex:1,2,3,4. I thought this would be the easy part but it is giving me more trouble than I thought. I tried using a for loop with nested if loops that would work for a normal array but I guess involving pointers in the mix has stumped me. The current code runs and does everything but sort. Any hints or help is appreciated. Code and output is posted below. This is an image of the assignment description
#include <iostream>
using namespace std;
class Array //The array class
{
private:
//Data members capacity, size, arr (a pointer that points to the first element of the array in the heap)v and two functions to move integers in the array.
int capacity{};
int size{};
int* arr{};
void moveTowardFront(int index);
void moveTowardEnd(int index);
public:
Array(int capacity);//parameter
~Array();//destructor
//two member function declarations
void insert(int num);
void print() const;
void remove(int num);
};
//insert method
void Array::insert(int num)
{
{
//if size is 0, then move number taken from insert call into the first element of the array and increment size before returning
if (size == 0)
{
arr[0] = num;
size++;
return;
}
int index = 0;
while (&num < &arr[index] && index < size) //while the address of the number taken from insert function call is less than the address of the element [index] in the arr array
//and the index is less than the size of the array
{
index++; //then we increment the index
}
moveTowardEnd(index); //move value of element toward the end
//after the while loop we move the value of the number taken from main insert call into the arr element [index] after it has been incremented so we don't overwrite values
arr[index] = num;
size++;
//then we increment the size of the array because a new value has been inserted
}
}
// Delete member function
void Array::remove(int num)
{
int index = 0; //start index at 0
//while number from main is not equal to the array element of index and the index is smaller than the size, we increment the index
while (num != arr[index] && index < size)
{
index++;
}
//if index is equal to the size then output the number from main and say it isn't on the list so no removal
if (index == size)
{
cout << num << " is not in the list. ";
cout << "No removal." << endl;
return;
}
//move toward front function call on index value and post-increment. Then post-decrement size
moveTowardFront(index++);
size--;
}
//print method
void Array::print() const
{
//rearrange the digits in ascending order
for (int i = 0; i < size; i++)
{
//print out values based on value of size taken from insert method
cout << *(arr+i) << " "; //arr points to first element in heap and then moves over by i to the next element for each iteration
}
}
// Helper function to move the elements of array towards end
void Array::moveTowardEnd(int index)
{
int* temp = &arr[index];
int* temp2 = &arr[size-1];
arr[index] = *temp2;
arr[size] = *temp;
return;
}
// Helper function to move the elements of array towards front
void Array::moveTowardFront(int index)
{
int* temp = &arr[index];
int* temp2 = &arr[size-1];
arr[index] = *temp2;
arr[size] = *temp;
return;
}
//Destructor to clean up by deleting the space allocated
Array::~Array()
{
delete[]arr;
}
//Parameter constructor to allocate space
Array::Array(int cap)
:capacity(cap)
{
//move space allocated by array with capacity being taken from main into the arr pointer so pointer can point to first element in heap
arr = { new int[capacity] {} };//allocating memory with the new operator
size = 0;//initialize size to 0
}
int main()
{
// Declaration of any array of capacity 20
Array array(20);
// Inserting some elements and printing array
array.insert(15);
array.insert(13);
array.insert(10);
array.insert(14);
array.insert(11);
array.insert(17);
array.insert(14);
cout << "Printing array after insertions: " << endl;
array.print();
cout << endl;
// Removing two elements and printing array
array.remove(13);
array.remove(11);
cout << "Printing array after removals: " << endl;
array.print();
cout << endl;
// Inserting two more elements and printing array
array.insert(8);
array.insert(22);
cout << "Printing array after more insertion" << endl;
array.print();
cout << endl;
// Try to remove an element, which is not in the array
array.remove(31);
return 0;
}

Answer 1

There are many ways to sort an array. Commonly used is the algorithm known as quicksort: https://en.wikipedia.org/wiki/Quicksort
Psuedo-code taken from the wikipedia page:
algorithm quicksort(A, lo, hi) is
// first we check if the lo and hi
// are natural numbers (without this check, you
// will get an overflow error because, at some point
// the program will access something like A[-1]
// which does not exists !
if lo >= 0 && hi >= 0 then
// if the indexes are in correct order, continue
if lo < hi then
// we find the index of the pivot and...
p := partition(A, lo, hi)
// ...apply quicksort for the left side and the
// right side of the array
quicksort(A, lo, p - 1)
quicksort(A, p + 1, hi)
algorithm partition(A, lo, hi) is
// we set the pivot value to the
// final value of the array
pivot := A[hi]
// we set the pivotIndex (i) to
// the start of the array
// ! NOTICE that A[i] != pivot
// aka. A[pivotIndex] != pivotValue
i := lo - 1
// we traverse the array from the start
// to the end (inclusive) aka. we traverse
// the array in this interval: [lo, hi]
for j := lo to hi do
// if the current element is
// less than the value of the pivot
// (or equal to it), then increment the i
// and swap it with the element at i (pivotIndex)
// ! NOTICE that j is automatically incremented
if A[j] <= pivot then
i := i + 1
swap A[i] with A[j]
return i
You would have to translate the pseudo-code to C++ yourself. They appear to be using the name algorithm to denote a function definition, and the := operator to do assignment, but otherwise it's not terribly different from C++ syntax. They have written in one place swap A[i] with A[j], which would for you probably look more like:
int temp = A[i];
A[i] = A[j];
A[j] = temp;