Lab Sort Bytes

#include <iostream>

using namespace std;

typedef int (*CompareFunctionType)(void *, void *);

//Теперь переменную это типа можно объявить так:

//CompareFunctionType compare_function_pointer = &Compare;

//В отдельной функции организуйте ввод элементов массива:

void InputIntArray(int input_data[], int length){

for (int i=0;i<length;i++){

cin>>input_data[i];

}

}

void InputCharArray(char my_char_array[], int length){

for (int i=0;i<length;i++){

cin>>my_char_array[i];

}

}

int CompareInt0to9(void *first_pointer, void *second_pointer ) {

int *first_element_int_pointer = (int *)first_pointer;

int *second_element_int_pointer = (int *)second_pointer;

return *first_element_int_pointer - *second_element_int_pointer;

}

int CompareInt9to0(void *first_pointer, void *second_pointer ) {

int *first_element_int_pointer = (int *)first_pointer;

int *second_element_int_pointer = (int *)second_pointer;

return *second_element_int_pointer - *first_element_int_pointer;

}

int CompareCharAtoZ(void *first_pointer, void *second_pointer ) {

char *first_element_int_pointer = (char *)first_pointer;

char *second_element_int_pointer = (char *)second_pointer;

return *first_element_int_pointer - *second_element_int_pointer;

}

int CompareCharZtoA(void *first_pointer, void *second_pointer) {

char *first_element_int_pointer = (char *)first_pointer;

char *second_element_int_pointer = (char *)second_pointer;

return *second_element_int_pointer - *first_element_int_pointer;

}

//В отдельной функции организуйте поиск индекса минимального элемента на подмассиве:

int FindMinimumIndex_old(long input_data[], int first_index, int last_index, CompareFunctionType compare_function_pointer){

int target=first_index;

for (int j=first_index;j<last_index;j++){

if ((*compare_function_pointer)(&input_data[j], &input_data[target])<0) {

target=j;

}

}

//cout<<target<<endl;

return target;

}

//В отдельной функции реализуйте обмен элементов массива.

void Swap_old(long &first_element, long &second_element){

long c=first_element;

first_element=second_element;

second_element=c;

}

//В отдельной функции организуйте вывод элементов упорядоченного

//массива:

void OutputIntArray(int input_data[], int length){

for (int i=0;i<length;i++){

cout<<input_data[i]<<" ";

}

cout<<endl;

}

void OutputCharArray(char input_data[], int length){

for (int i=0;i<length;i++){

cout<<input_data[i];

}

cout<<endl;

}

///////////////////

void SwapChar(char *first_pointer, char *second_pointer) {

char temp = *first_pointer;

*first_pointer = *second_pointer;

*second_pointer = temp;

return;

}

void Swap(void *first_pointer, void *second_pointer, int width) {

for (int byte_number = 0; byte_number < width; ++byte_number)

SwapChar((char *)first_pointer + byte_number, (char *)second_pointer + byte_number);

return;

}

int FindTargetIndex(char *bytevise_array, int width, CompareFunctionType compare_function_pointer, int first_index, int last_index) {

int target_index = first_index;

int target_byte_number = target_index * width;

int current_byte_number = 0;

for (int element_number = first_index; element_number < last_index; ++element_number) {

current_byte_number = element_number * width;

if ((*compare_function_pointer)(&bytevise_array[current_byte_number],&bytevise_array[target_byte_number]) < 0)

target_byte_number = current_byte_number;

//cout<<target_byte_number<<" ";

}

//cout<<endl;

target_index = target_byte_number / width;

return target_index;

}

//В отдельной функции организуйте сортировку.

void SelectionSort(void *input_data, int width, int length, CompareFunctionType compare_function_pointer){

char *byte_data=(char *)input_data;

//OutputIntArray((int *)input_data,length);

for (int i=0;i<length;i++){

int target=FindTargetIndex(byte_data,width,compare_function_pointer,i,length);

//cout<<i<<" "<<target<<" "<<width<<endl;

Swap(&byte_data[i*width],&byte_data[target*width],width);

//OutputIntArray((int *)input_data,length);

}

}

int main() {

int CompareInt0to9(void *first_pointer, void *second_pointer);

int CompareInt9to0(void *first_pointer, void *second_pointer);

int CompareCharAtoZ(void *first_pointer, void *second_pointer);

int CompareCharZtoA(void *first_pointer, void *second_pointer);

//Заполнение массивов пропущено...

//Вызов функции сортировки

//SelectionSort((void *)my_int_array, kLength, 4, &CompareInt0to9);

const int kFunctionsCount = 4;

//CompareFunctionType compare_function_pointers[kFunctionsCount];

//compare_function_pointers[0]=CompareInt0to9;

//compare_function_pointers[1]=CompareInt9to0;

CompareFunctionType compare_function_pointers[kFunctionsCount];

compare_function_pointers[0]=CompareCharAtoZ;

compare_function_pointers[1]=CompareCharZtoA;

compare_function_pointers[2]=CompareInt0to9;

compare_function_pointers[3]=CompareInt9to0;

int type; cin>>type;

int n; cin>>n; int m; cin>>m;

char *my_char_array=new char[n];

int *my_int_array=new int[m];

InputCharArray(my_char_array, n);

InputIntArray(my_int_array, m);

SelectionSort((void *)my_char_array, sizeof (my_char_array [0]), n, compare_function_pointers[type]);

SelectionSort((void *)my_int_array, 4, m, compare_function_pointers[type+2]);

OutputCharArray(my_char_array,n);

OutputIntArray(my_int_array,m);

return 0;

}