Step by Step solution about How to resolve the algorithm JortSort step by step in the C++ programming language

The provided C++ code defines a jortSort class to check if an input array is sorted and demonstrates its usage with different data types. Here's a detailed explanation:

1. jortSort Class:
   • It contains methods to sort and check arrays of various data types (T).
2. jortSort::jort_sort:
   • This template method takes an input array o and its size s as arguments.
   • It creates a copy of the input array n using the copy_array method, sorts the copy using sort_array, and checks if the sorted copy matches the original array using check.
   • If the arrays match, it returns true, indicating that the input array is sorted; otherwise, it returns false.
3. jortSort::copy_array:
   • Template method that creates a copy of the input array o of size s.
4. jortSort::sort_array:
   • Template method that sorts the input array n of size s using the standard library's std::sort.
5. jortSort::check:
   • Template method that compares two arrays n and o. If all elements match, it returns true; otherwise, it returns false.
6. jortSort Object:
   • An instance of the jortSort class (js) is created for usage.
7. displayTest Function:
   • This template function takes an array o and its size s as arguments.
   • It displays the original array, calls js.jort_sort to check if the array is sorted, and prints the result.
8. main Function:
   • Defines test arrays of strings (oStr) and integers (oInt).
   • Calls displayTest to check and display the sorting status of these arrays before and after swapping their first two elements.
9. Code Execution:
   • Two arrays of strings and integers are created.
   • The jortSort class is used to check if the arrays are sorted.
   • After swapping the first two elements in each array, the sorting status is checked again.
   • The program prints the original arrays, the sorting status before and after the swap, and a message indicating whether the array is sorted or not.

In summary, the code defines a class that provides a method to check if an array is sorted and demonstrates its usage on arrays of different data types, displaying whether the arrays are sorted before and after swapping their first two elements.

#include <algorithm>
#include <string>
#include <iostream>
#include <iterator> 

class jortSort {
public:
    template<class T>
    bool jort_sort( T* o, size_t s ) {
        T* n = copy_array( o, s );
        sort_array( n, s );
        bool r = false;

        if( n ) {
            r = check( o, n, s );
            delete [] n;
        }
        return r;
    }

private:
    template<class T>
    T* copy_array( T* o, size_t s ) {
        T* z = new T[s];
        memcpy( z, o, s * sizeof( T ) );
        //std::copy( o, o + s, z );
        return z;
    }
    template<class T>
    void sort_array( T* n, size_t s ) {
        std::sort( n, n + s );
    }
    template<class T>
    bool check( T* n, T* o, size_t s ) {
        for( size_t x = 0; x < s; x++ )
            if( n[x] != o[x] ) return false;
        return true;
    }
};

jortSort js;

template<class T>
void displayTest( T* o, size_t s ) {
    std::copy( o, o + s, std::ostream_iterator<T>( std::cout, " " ) );
    std::cout << ": -> The array is " << ( js.jort_sort( o, s ) ? "sorted!" : "not sorted!" ) << "\n\n";
}

int main( int argc, char* argv[] ) {
    const size_t s = 5;
    std::string oStr[] = { "5", "A", "D", "R", "S" };
    displayTest( oStr, s );
    std::swap( oStr[0], oStr[1] );
    displayTest( oStr, s );

    int oInt[] = { 1, 2, 3, 4, 5 };
    displayTest( oInt, s );
    std::swap( oInt[0], oInt[1] );
    displayTest( oInt, s );

    return 0;
}