laba.3.3.(C++)

#include <iostream>
#include <fstream>
#include <string>

const int MIN_SIZE = 2;
const int MAX_SIZE = 10;
const int MIN_VALUE = -1000;
const int MAX_VALUE = 1000;

void outputOfTaskInfo() {
  std::cout << "Данная программа сортирует введенную последовательность методом бинарных вставок. \n"
    << "Диапазон ввода значений размера последовательности: " << MIN_SIZE << "..." << MAX_SIZE << ". \n"
    << "Диапазон для ввода чисел: " << MIN_VALUE << "..." << MAX_VALUE << ". \n";
}

int getVerificationOfChoice() {
  int choice;
  bool isIncorrect;

  do {
    isIncorrect = false;
    std::cin >> choice;

    if (std::cin.fail())
    {
      std::cin.clear();
      while (std::cin.get() != '\n');
      isIncorrect = true;
      std::cout << "Проверьте корректность ввода данных! \n";
    }

    if (!isIncorrect && std::cin.get() != '\n')
    {
      std::cin.clear();
      while (std::cin.get() != '\n');

      std::cout << "Проверьте корректность ввода данных! \n";
      isIncorrect = true;
    }

    if (isIncorrect || (choice != 0 && choice != 1))
    {
      isIncorrect = true;
      std::cout << "Для выбора введите 0 или 1! \n";
    }
  } while (isIncorrect);

  return choice;
}

std::string inputPathToFile() {
  std::string path;
  bool isIncorrect;

  std::cout << "Укажите путь к файлу: ";

  do
  {
    isIncorrect = false;
    std::cin >> path;
    std::ifstream file(path);

    if (!file.is_open())
    {
      std::cout << "По указанному пути файл не найден! Укажите правильный путь: ";
      isIncorrect = true;
    }
  } while (isIncorrect);

  return path;
}

int readSizeFromConsole() {
  int size;
  bool isIncorrect;

  std::cout << "Введите количество элементов последовательности: ";

  do
  {
    isIncorrect = false;
    std::cin >> size;
    if (std::cin.fail())
    {
      isIncorrect = true;
      std::cout << "Проверьте корректность ввода данных! \n";
      std::cin.clear();
      while (std::cin.get() != '\n');
    }
    if (!isIncorrect && (size < MIN_SIZE || size >> MAX_SIZE))
    {
      isIncorrect = true;
      std::cout << "Введите число от " << MIN_SIZE << " до " << MAX_SIZE << "! \n";
    }
  } while (isIncorrect);

  return size;
}

int readSizeFromFile(const std::string path) {
  int size;
  std::string sizeInp;
  bool isIncorrect = true;
  std::ifstream fin(path);

  std::cout << "Происходит чтение количества членов последовательности... \n";
  fin >> sizeInp;

  try
  {
    size = atoi(sizeInp.c_str());
  }
  catch (...)
  {
    isIncorrect = false;
    std::cout << "Ошибка при чтении данных! Введите количество с консоли! \n";
    size = readSizeFromConsole();
  }

  if (!isIncorrect && (size < MIN_SIZE || size > MAX_SIZE))
  {
    std::cout << "Введите значение от " << MIN_SIZE << " до " << MAX_SIZE << "! \n";
    size = readSizeFromConsole();
  }

  fin.close();

  return size;
}

int readSize(const int choice, const std::string path) {
  int size;

  if (choice == 0)
    size = readSizeFromConsole();
  if (choice == 1)
    size = readSizeFromFile(path);

  return size;
}

void outputSizeInConsole(const int size) {
  std::cout << "Количество членов последовательности равно: " << size << ". \n";
}

void outputSizeInFile(std::string path, const int size) {
  std::ofstream fout(path);
  bool isIncorrect;

  std::cout << "Вывод количества членов последовательности в файл... \n";

  do
  {
    isIncorrect = false;
    std::ofstream fout(path);

    try
    {
      fout << size << "\n";
    }
    catch (...)
    {
      std::cout << "Ошибка! Измените параметры файла или укажите новую ссылку! \n";
      isIncorrect = true;
      path = inputPathToFile();
    }

    fout.close();
  } while (isIncorrect);

  std::cout << "Данные успешно записаны в файл! \n";
}

void outputSize(const int choice, const std::string path, const int size) {

  if (choice == 0)
    outputSizeInConsole(size);
  if (choice == 1)
    outputSizeInFile(path, size);
}

int* fillSequenceFromConsole(const int size) {
  int* sequence = new int [size];
  bool isIncorrect;

  for (int i = 0; i < size; i++)
  {
    std::cout << "Введите значение " << i + 1 << "-го элемента последовательности: ";

    do
    {
      isIncorrect = false;
      std::cin >> sequence[i];

      if (std::cin.fail())
      {
        isIncorrect = true;
        std::cout << "Проверьте корректность ввода данных! \n";
        std::cin.clear();
        while (std::cin.get() != '\n');
      }

      if (!isIncorrect && (sequence[i] < MIN_VALUE || sequence[i] >> MAX_VALUE))
      {
        isIncorrect = true;
        std::cout << "Введите число от " << MIN_VALUE << " до " << MAX_VALUE << "! \n";
      }
    } while (isIncorrect);
  }

  return sequence;
}

int* fillSequenceFromFile(const int size, const std::string path) {
  int* sequence = new int[size];
  bool isIncorrect;
  std::string matrixInp;
  std::ifstream fin(path);

  std::cout << "Чтение последовательности... \n";
  fin >> matrixInp;

  for (int i = 0; i < size; i++)
  {
      do
      {
        isIncorrect = false;

        try
        {
          fin >> sequence[i];
        }
        catch (...)
        {
          std::cout << "Ошибка при чтении последовательности! Введите последовательность с консоли! \n";
          isIncorrect = true;
          sequence = fillSequenceFromConsole(size);
        }

        if (!isIncorrect && (sequence[i] < MIN_VALUE || sequence[i] > MAX_VALUE))
        {
          std::cout << "Ошибка при чтении последовательности! Введите последовательность с консоли! \n";
          isIncorrect = true;
          sequence = fillSequenceFromConsole(size);
        }
      } while (isIncorrect);
  }

  fin.close();

  return sequence;
}

int* fillSequence(const int choice, const std::string path, const int size) {
  int* sequence = new int[size];

  if (choice == 0)
    sequence = fillSequenceFromConsole(size);
  if (choice == 1)
    sequence = fillSequenceFromFile(size, path);

  return sequence;
}

void outputSequenceInConsole(int* sequence, const int size) {
  std::cout << "Вывод начальной последовательности: \n";

  for (int i = 0; i < size; i++)
    std::cout << sequence[i] << "\t";
  std::cout << "\n";
}

void outputSequenceInFile(std::string path, int* sequence, const int size) {
  bool isIncorrect;
  std::ofstream fout;

  std::cout << "Вывод начальной последовательности в файл... \n";

  fout.open(path, std::ios::app);
  fout << "\n";

  do
  {
    isIncorrect = false;

    try
    {
      for (int i = 0; i < size; i++)
      {
        for (int j = 0; j < size; j++)
          fout << sequence[i] << "\t";
        fout << "\n";
      }

      fout << "\n";
    }
    catch (...)
    {
      std::cout << "Ошибка! Измените параметры файла или укажите новую ссылку! \n";
      isIncorrect = true;
      path = inputPathToFile();
    }
  } while (isIncorrect);

  fout.close();
  std::cout << "Данные успешно записаны в файл! \n";
}

void outputSequence(const int choice, const std::string path,const int size, int* sequence) {

  if (choice == 0)
    outputSequenceInConsole(sequence, size);
  if (choice == 1)
    outputSequenceInFile(path, sequence, size);
}

int** BinaryInsertionSort(const int size, int* sequence) {
  int* newSequence = new int[size];
  int** detailingMatrix = new int* [size];
  for (int i = 0; i < size; i++)
    detailingMatrix[i] = new int[size];

  for (int i = 0; i < size; i++)
  {
    newSequence[i] = sequence[i];
    detailingMatrix[0][i] = sequence[i];
  }

  for (int i = 1; i < size; i++)
  {
    if (newSequence[i - 1] > newSequence[i])
    {
      int temp = newSequence[i];
      int left = 0;
      int right = i - 1;
      int j;

      do
      {
        int middle = (left + right) / 2;

        if (newSequence[middle] < temp)
          left = middle + 1;
        else
          right = middle - 1;
      } while (left < right + 1);

      for (j = i - 1; j + 1 > left; j--)
        newSequence[j + 1] = newSequence[j];
      newSequence[left] = temp;
    }

    for (int j = 0; j < size; j++)
      detailingMatrix[i][j] = newSequence[j];
  }

  return detailingMatrix;
}

void outputDetailingMatrixInConsole(int** detailingMatrix, const int size) {
  std::cout << "Вывод пошаговой детализации: \n";

  for (int i = 0; i < size; i++)
  {
    for (int j = 0; j < size; j++)
      std::cout << detailingMatrix[i][j] << "\t";
    std::cout << "\n";
  }
  std::cout << "\n";
}

void outputDetailingMatrixInFile(std::string path, int** detailingMatrix, const int size) {
  bool isIncorrect;
  std::ofstream fout;

  std::cout << "Вывод пошаговой детализации в файл... \n";

  fout.open(path, std::ios::app);
  fout << "\n";

  do
  {
    isIncorrect = false;

    try
    {
      for (int i = 0; i < size; i++)
      {
        for (int j = 0; j < size; j++)
          fout << detailingMatrix[i][j] << "\t";
        fout << "\n";
      }

      fout << "\n";
    }
    catch (...)
    {
      std::cout << "Ошибка! Измените параметры файла или укажите новую ссылку! \n";
      isIncorrect = true;
      path = inputPathToFile();
    }
  } while (isIncorrect);

  fout.close();
  std::cout << "Данные успешно записаны в файл! \n";
}

void outputDetailingMatrix(const int choice, const std::string path, const int size, int** detailingMatrix) {

  if (choice == 0)
    outputDetailingMatrixInConsole(detailingMatrix, size);
  if (choice == 1)
    outputDetailingMatrixInFile(path, detailingMatrix, size);
}

void processUserInput(int& choiceForInput, std::string& pathToIn, int& size) {
  std::cout << "Вы желаете ввести данные с консоли(0) или взять данные из файла(1)? \n";
  choiceForInput = getVerificationOfChoice();
  if (choiceForInput == 1)
    pathToIn = inputPathToFile();

  size = readSize(choiceForInput, pathToIn);
}

void processUserOutput(int& choiceForOutput, std::string& pathToOut, int& size, int*& sequence, int**& detailingMatrix) {
  std::cout << "Вы желаете получить результат в консоли(0) или в файле(1)? \n";
  choiceForOutput = getVerificationOfChoice();
  if (choiceForOutput == 1)
    pathToOut = inputPathToFile();

  outputSize(choiceForOutput, pathToOut, size);
  outputSequence(choiceForOutput, pathToOut, size, sequence);
  outputDetailingMatrix(choiceForOutput, pathToOut, size, detailingMatrix);
}

int main() {
  setlocale(LC_ALL, "Rus");
  int choiceForInput, choiceForOutput, size;
  std::string pathToIn, pathToOut;

  outputOfTaskInfo();
  processUserInput(choiceForInput, pathToIn, size);

  int* sequence = new int[size];
  sequence = fillSequence(choiceForInput, pathToIn, size);

  int** detailingMatrix = new int* [size];
  for (int i = 0; i < size; i++)
    detailingMatrix[i] = new int[size];

  detailingMatrix = BinaryInsertionSort(size, sequence);

  processUserOutput(choiceForOutput, pathToOut, size, sequence, detailingMatrix);

  return 0;
}