API tools faq
paste
Advertisement
VictoriaLodochkina

КАК ЖЕ БЕСИТ!

VictoriaLodochkina
Sep 20th, 2020
167
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 16.88 KB | None | 0 0
raw download clone embed print report
  1. #include <iostream>
  2. #include <dos.h>
  3. //#include <ctime>
  4. //#include <stdio.h>
  5. #include "Sort.h"
  6. void gettime(struct time*);
  7. struct time {
  8.     unsigned char ti_min;   /* минуты */
  9.     unsigned char ti_hour;  /* часы */
  10.     unsigned char ti_hund;  /* сотые доли секунды */
  11.     unsigned char ti_sec;   /* секунды */
  12. };
  13. //void gettime(struct time* timep);
  14.  
  15. int main()
  16. {
  17.     /*int num;
  18.     std::cout << "Enter the size of array: ";
  19.     std::cin >> num;
  20.     int* arr = new int[num];
  21.     int* arr1 = new int[num];
  22.     int* arr2 = new int[num];
  23.     std::cout << "Enter array: " << std::endl;
  24.     for (int i = 0; i < num; i++)
  25.     {
  26.         std::cin >> arr[i];
  27.         arr1[i] = arr[i];
  28.         arr2[i] = arr[i];
  29.     }
  30.     std::cout << "THIS IS SORT BY INSERTS:" << std::endl;
  31.     vstavka(arr, num);
  32.     for (int i = 0; i < num; i++)
  33.     {
  34.         std::cout << arr[i] << " ";
  35.     }
  36.     std::cout << std::endl;
  37.     std::cout << "THIS IS SORT BY SHAKER:" << std::endl;
  38.     shaker(arr1, 1, num);
  39.     for (int i = 0; i < num; i++)
  40.     {
  41.         std::cout << arr1[i] << " ";
  42.     }
  43.     std::cout << std::endl;
  44.     std::cout << "THIS IS SORT BY SIMPLE DECISION:" << std::endl;
  45.     simple_decision(arr2, num);
  46.     for (int i = 0; i < num; i++)
  47.     {
  48.         std::cout << arr2[i] << " ";
  49.     }
  50.     std::cout << std::endl;
  51.     return 0;*/
  52.     int number;
  53.     std::cout << "Enter number: ";
  54.     std::cin >> number;
  55.     int* mas_vozr = new int[number];
  56.     for (int i = 0; i < number; i++)
  57.     {
  58.         mas_vozr[i] = i;
  59.     }
  60.     int* mas_yb = new int[number];
  61.     for (int i = number-1; i >= 0; i--)
  62.     {
  63.         mas_yb[i] = i;
  64.     }
  65.     int* mas_rand = new int[number];
  66.     for (int i = 0; i<number; i++)
  67.     {
  68.         mas_rand[i] = rand() % 50;
  69.     }
  70.     struct time t1, t2;
  71.     double t_copy, t_sort;
  72.     int* arr = new int[number];
  73.     int* arr1 = new int[number];
  74.     int* arr2 = new int[number];
  75.     //long n;
  76.     char ex = 'n';
  77.     do {
  78.     char sort;
  79.     std::cout << "Enter 'v' for increased array..." << std::endl << "Enter 'y' for decreased array..." << std::endl << "Enter 'r' for random array...";
  80.     std::cin >> sort;
  81.     switch (sort) {
  82.     case 'v'://////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  83.         gettime(&t1);
  84.         //int* arr = new int[number];
  85.         std::cout << "Original array: " << std::endl;
  86.         for (int i = 0; i < number; i++)
  87.         {
  88.             arr[i] = mas_vozr[i];
  89.             std::cout << arr[i] << " ";
  90.         }
  91.         std::cout << std::endl;
  92.         // Копирование из массива arr1 в массив arr.
  93.         gettime(&t2);
  94.  
  95.         t_copy = (t2.ti_hour * 360000. + t2.ti_min * 6000. +
  96.             t2.ti_sec * 100. + t2.ti_hund - (t1.ti_hour * 360000. +
  97.                 t1.ti_min * 6000. + t1.ti_sec * 100. + t1.ti_hund)) / 100.;
  98.         gettime(&t1);
  99.         // Цикл сортировки из большого числа проходов.
  100.         vstavka(arr, number);
  101.         gettime(&t2);
  102.         t_sort = (t2.ti_hour * 360000. + t2.ti_min * 6000. +
  103.             t2.ti_sec * 100. + t2.ti_hund - (t1.ti_hour * 360000. +
  104.                 t1.ti_min * 6000. + t1.ti_sec * 100. + t1.ti_hund)) / 100.;
  105.         t_sort -= t_copy;
  106.         std::cout << "THIS IS SORT BY INSERTS:" << std::endl;
  107.         for (int i = 0; i < number; i++)
  108.         {
  109.             std::cout << arr[i] << " ";
  110.         }
  111.         std::cout << "Time sort: " << t_sort << std::endl;
  112.  
  113.  
  114.         gettime(&t1);
  115.         //int* arr1 = new int[number];
  116.         std::cout << "Original array: " << std::endl;
  117.         for (int i = 0; i < number; i++)
  118.         {
  119.             arr1[i] = mas_vozr[i];
  120.             std::cout << arr1[i] << " ";
  121.         }
  122.         std::cout << std::endl;
  123.         // Копирование из массива arr1 в массив arr.
  124.         gettime(&t2);
  125.  
  126.         t_copy = (t2.ti_hour * 360000. + t2.ti_min * 6000. +
  127.             t2.ti_sec * 100. + t2.ti_hund - (t1.ti_hour * 360000. +
  128.                 t1.ti_min * 6000. + t1.ti_sec * 100. + t1.ti_hund)) / 100.;
  129.         gettime(&t1);
  130.         // Цикл сортировки из большого числа проходов.
  131.         shaker(arr1, 1, number);
  132.         gettime(&t2);
  133.         t_sort = (t2.ti_hour * 360000. + t2.ti_min * 6000. +
  134.             t2.ti_sec * 100. + t2.ti_hund - (t1.ti_hour * 360000. +
  135.                 t1.ti_min * 6000. + t1.ti_sec * 100. + t1.ti_hund)) / 100.;
  136.         t_sort -= t_copy;
  137.         std::cout << "THIS IS SORT BY SHAKER:" << std::endl;
  138.         for (int i = 0; i < number; i++)
  139.         {
  140.             std::cout << arr1[i] << " ";
  141.         }
  142.         std::cout << "Time sort: " << t_sort << std::endl;
  143.  
  144.  
  145.         gettime(&t1);
  146.         //int* arr2 = new int[number];
  147.         std::cout << "Original array: " << std::endl;
  148.         for (int i = 0; i < number; i++)
  149.         {
  150.             arr2[i] = mas_vozr[i];
  151.             std::cout << arr2[i] << " ";
  152.         }
  153.         std::cout << std::endl;
  154.         // Копирование из массива arr1 в массив arr.
  155.         gettime(&t2);
  156.  
  157.         t_copy = (t2.ti_hour * 360000. + t2.ti_min * 6000. +
  158.             t2.ti_sec * 100. + t2.ti_hund - (t1.ti_hour * 360000. +
  159.                 t1.ti_min * 6000. + t1.ti_sec * 100. + t1.ti_hund)) / 100.;
  160.         gettime(&t1);
  161.         // Цикл сортировки из большого числа проходов.
  162.         simple_decision(arr2, number);
  163.         gettime(&t2);
  164.         t_sort = (t2.ti_hour * 360000. + t2.ti_min * 6000. +
  165.             t2.ti_sec * 100. + t2.ti_hund - (t1.ti_hour * 360000. +
  166.                 t1.ti_min * 6000. + t1.ti_sec * 100. + t1.ti_hund)) / 100.;
  167.         t_sort -= t_copy;
  168.         std::cout << "THIS IS SORT BY SIMPLE_SORT:" << std::endl;
  169.         for (int i = 0; i < number; i++)
  170.         {
  171.             std::cout << arr2[i] << " ";
  172.         }
  173.         std::cout << "Time sort: " << t_sort << std::endl;
  174.         /*delete[] arr;
  175.         delete[] arr1;
  176.         delete[] arr2;*/
  177.             break;
  178.  
  179.     case 'y':                                  /////////////////////////////////////////////////////////////////////////////////////////////////////
  180.         gettime(&t1);
  181.         //int* arr = new int[number];
  182.         std::cout << "Original array: " << std::endl;
  183.         for (int i = 0; i < number; i++)
  184.         {
  185.             arr[i] = mas_yb[i];
  186.             std::cout << arr[i] << " ";
  187.         }
  188.         std::cout << std::endl;
  189.         // Копирование из массива arr1 в массив arr.
  190.         gettime(&t2);
  191.  
  192.         t_copy = (t2.ti_hour * 360000. + t2.ti_min * 6000. +
  193.             t2.ti_sec * 100. + t2.ti_hund - (t1.ti_hour * 360000. +
  194.                 t1.ti_min * 6000. + t1.ti_sec * 100. + t1.ti_hund)) / 100.;
  195.         gettime(&t1);
  196.         // Цикл сортировки из большого числа проходов.
  197.         vstavka(arr, number);
  198.         gettime(&t2);
  199.         t_sort = (t2.ti_hour * 360000. + t2.ti_min * 6000. +
  200.             t2.ti_sec * 100. + t2.ti_hund - (t1.ti_hour * 360000. +
  201.                 t1.ti_min * 6000. + t1.ti_sec * 100. + t1.ti_hund)) / 100.;
  202.         t_sort -= t_copy;
  203.         std::cout << "THIS IS SORT BY INSERTS:" << std::endl;
  204.         for (int i = 0; i < number; i++)
  205.         {
  206.             std::cout << arr[i] << " ";
  207.         }
  208.         std::cout << "Time sort: " << t_sort << std::endl;
  209.  
  210.  
  211.         gettime(&t1);
  212.         //int* arr1 = new int[number];
  213.         std::cout << "Original array: " << std::endl;
  214.         for (int i = 0; i < number; i++)
  215.         {
  216.             arr1[i] = mas_yb[i];
  217.             std::cout << arr1[i] << " ";
  218.         }
  219.         std::cout << std::endl;
  220.         // Копирование из массива arr1 в массив arr.
  221.         gettime(&t2);
  222.  
  223.         t_copy = (t2.ti_hour * 360000. + t2.ti_min * 6000. +
  224.             t2.ti_sec * 100. + t2.ti_hund - (t1.ti_hour * 360000. +
  225.                 t1.ti_min * 6000. + t1.ti_sec * 100. + t1.ti_hund)) / 100.;
  226.         gettime(&t1);
  227.         // Цикл сортировки из большого числа проходов.
  228.         shaker(arr1, 1, number);
  229.         gettime(&t2);
  230.         t_sort = (t2.ti_hour * 360000. + t2.ti_min * 6000. +
  231.             t2.ti_sec * 100. + t2.ti_hund - (t1.ti_hour * 360000. +
  232.                 t1.ti_min * 6000. + t1.ti_sec * 100. + t1.ti_hund)) / 100.;
  233.         t_sort -= t_copy;
  234.         std::cout << "THIS IS SORT BY SHAKER:" << std::endl;
  235.         for (int i = 0; i < number; i++)
  236.         {
  237.             std::cout << arr1[i] << " ";
  238.         }
  239.         std::cout << "Time sort: " << t_sort << std::endl;
  240.  
  241.  
  242.         gettime(&t1);
  243.         //int* arr2 = new int[number];
  244.         std::cout << "Original array: " << std::endl;
  245.         for (int i = 0; i < number; i++)
  246.         {
  247.             arr2[i] = mas_yb[i];
  248.             std::cout << arr2[i] << " ";
  249.         }
  250.         std::cout << std::endl;
  251.         // Копирование из массива arr1 в массив arr.
  252.         gettime(&t2);
  253.  
  254.         t_copy = (t2.ti_hour * 360000. + t2.ti_min * 6000. +
  255.             t2.ti_sec * 100. + t2.ti_hund - (t1.ti_hour * 360000. +
  256.                 t1.ti_min * 6000. + t1.ti_sec * 100. + t1.ti_hund)) / 100.;
  257.         gettime(&t1);
  258.         // Цикл сортировки из большого числа проходов.
  259.         simple_decision(arr2, number);
  260.         gettime(&t2);
  261.         t_sort = (t2.ti_hour * 360000. + t2.ti_min * 6000. +
  262.             t2.ti_sec * 100. + t2.ti_hund - (t1.ti_hour * 360000. +
  263.                 t1.ti_min * 6000. + t1.ti_sec * 100. + t1.ti_hund)) / 100.;
  264.         t_sort -= t_copy;
  265.         std::cout << "THIS IS SORT BY SIMPLE_SORT:" << std::endl;
  266.         for (int i = 0; i < number; i++)
  267.         {
  268.             std::cout << arr2[i] << " ";
  269.         }
  270.         std::cout << "Time sort: " << t_sort << std::endl;
  271.         /*delete[] arr;
  272.         delete[] arr1;
  273.         delete[] arr2;*/
  274.             break;
  275.     case 'r'://////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  276.         gettime(&t1);
  277.         //int* arr = new int[number];
  278.         std::cout << "Original array: " << std::endl;
  279.         for (int i = 0; i < number; i++)
  280.         {
  281.             arr[i] = mas_rand[i];
  282.             std::cout << arr[i] << " ";
  283.         }
  284.         std::cout << std::endl;
  285.         // Копирование из массива arr1 в массив arr.
  286.         gettime(&t2);
  287.  
  288.         t_copy = (t2.ti_hour * 360000. + t2.ti_min * 6000. +
  289.             t2.ti_sec * 100. + t2.ti_hund - (t1.ti_hour * 360000. +
  290.                 t1.ti_min * 6000. + t1.ti_sec * 100. + t1.ti_hund)) / 100.;
  291.         gettime(&t1);
  292.         // Цикл сортировки из большого числа проходов.
  293.         vstavka(arr, number);
  294.         gettime(&t2);
  295.         t_sort = (t2.ti_hour * 360000. + t2.ti_min * 6000. +
  296.             t2.ti_sec * 100. + t2.ti_hund - (t1.ti_hour * 360000. +
  297.                 t1.ti_min * 6000. + t1.ti_sec * 100. + t1.ti_hund)) / 100.;
  298.         t_sort -= t_copy;
  299.         std::cout << "THIS IS SORT BY INSERTS:" << std::endl;
  300.         for (int i = 0; i < number; i++)
  301.         {
  302.             std::cout << arr[i] << " ";
  303.         }
  304.         std::cout << "Time sort: " << t_sort << std::endl;
  305.  
  306.  
  307.         gettime(&t1);
  308.         //int* arr1 = new int[number];
  309.         std::cout << "Original array: " << std::endl;
  310.         for (int i = 0; i < number; i++)
  311.         {
  312.             arr1[i] = mas_rand[i];
  313.             std::cout << arr1[i] << " ";
  314.         }
  315.         std::cout << std::endl;
  316.         // Копирование из массива arr1 в массив arr.
  317.         gettime(&t2);
  318.  
  319.         t_copy = (t2.ti_hour * 360000. + t2.ti_min * 6000. +
  320.             t2.ti_sec * 100. + t2.ti_hund - (t1.ti_hour * 360000. +
  321.                 t1.ti_min * 6000. + t1.ti_sec * 100. + t1.ti_hund)) / 100.;
  322.         gettime(&t1);
  323.         // Цикл сортировки из большого числа проходов.
  324.         shaker(arr1, 1, number);
  325.         gettime(&t2);
  326.         t_sort = (t2.ti_hour * 360000. + t2.ti_min * 6000. +
  327.             t2.ti_sec * 100. + t2.ti_hund - (t1.ti_hour * 360000. +
  328.                 t1.ti_min * 6000. + t1.ti_sec * 100. + t1.ti_hund)) / 100.;
  329.         t_sort -= t_copy;
  330.         std::cout << "THIS IS SORT BY SHAKER:" << std::endl;
  331.         for (int i = 0; i < number; i++)
  332.         {
  333.             std::cout << arr1[i] << " ";
  334.         }
  335.         std::cout << "Time sort: " << t_sort << std::endl;
  336.  
  337.  
  338.         gettime(&t1);
  339.         //int* arr2 = new int[number];
  340.         std::cout << "Original array: " << std::endl;
  341.         for (int i = 0; i < number; i++)
  342.         {
  343.             arr2[i] = mas_rand[i];
  344.             std::cout << arr2[i] << " ";
  345.         }
  346.         std::cout << std::endl;
  347.         // Копирование из массива arr1 в массив arr.
  348.         gettime(&t2);
  349.  
  350.         t_copy = (t2.ti_hour * 360000. + t2.ti_min * 6000. +
  351.             t2.ti_sec * 100. + t2.ti_hund - (t1.ti_hour * 360000. +
  352.                 t1.ti_min * 6000. + t1.ti_sec * 100. + t1.ti_hund)) / 100.;
  353.         gettime(&t1);
  354.         // Цикл сортировки из большого числа проходов.
  355.         simple_decision(arr2, number);
  356.         gettime(&t2);
  357.         t_sort = (t2.ti_hour * 360000. + t2.ti_min * 6000. +
  358.             t2.ti_sec * 100. + t2.ti_hund - (t1.ti_hour * 360000. +
  359.                 t1.ti_min * 6000. + t1.ti_sec * 100. + t1.ti_hund)) / 100.;
  360.         t_sort -= t_copy;
  361.         std::cout << "THIS IS SORT BY SIMPLE_SORT:" << std::endl;
  362.         for (int i = 0; i < number; i++)
  363.         {
  364.             std::cout << arr2[i] << " ";
  365.         }
  366.         std::cout << "Time sort: " << t_sort << std::endl;
  367.         /*delete[] arr;
  368.         delete[] arr1;
  369.         delete[] arr2;*/
  370.         break;
  371.     default:
  372.         std::cout << "Error..." << std::endl;
  373.             break;
  374.     }
  375.     std::cout << "Если вы хотите выйти, нажмите \'u\', в противном случае-любую другую клавишу" << std::endl;
  376.     std::cin.ignore(100, '\n');
  377.     std::cin >> ex;
  378.     } while (ex != 'u');
  379.     return 0;
  380. }
  381.  
  382.  
  383.  
  384. sort.h
  385. #ifndef SORT_H_
  386. #define SORT_H_
  387. void vstavka(int* mas, int n);
  388. void shaker(int* mas, int start, int N);
  389. void simple_decision(int* mas, int length);
  390. #endif
  391.  
  392.  
  393. sort.cpp
  394. #include "Sort.h"
  395. #include "swap.h"
  396. #include <iostream>
  397. void vstavka(int* mas, int n)
  398. {
  399.     for (int i = 1; i < n; i++)
  400.     {
  401.         for (int j = i; (j > 0) && (mas[j - 1] > mas[j]); j--)
  402.         {
  403.             swap(&mas[j - 1], &mas[j]);
  404.         }
  405.     }
  406. }
  407. void shaker(int* mas, int start, int N)
  408. {
  409.     int l, r, i;
  410.     l = start;
  411.     r = N - 1;
  412.     while (l <= r)
  413.     {
  414.         for (i = r; i >= l; i--)
  415.         {
  416.             if (mas[i - 1] > mas[i])
  417.             {
  418.                 swap(&mas[i], &mas[i - 1]);
  419.             }
  420.         }
  421.         l++;
  422.         for (i = l; i <= r; i++)
  423.         {
  424.             if (mas[i - 1] > mas[i])
  425.             {
  426.                 swap(&mas[i], &mas[i - 1]);
  427.             }
  428.         }
  429.         r--;
  430.     }
  431. }
  432.  
  433. void simple_decision(int* mas, int length)
  434. {
  435.     // Перебираем каждый элемент массива (кроме последнего, он уже будет отсортирован к тому времени, когда мы до него доберемся)
  436.     for (int startIndex = 0; startIndex < length - 1; ++startIndex)
  437.     {
  438.         // В переменной smallestIndex хранится индекс наименьшего значения, которое мы нашли в этой итерации.
  439.         // Начинаем с того, что наименьший элемент в этой итерации - это первый элемент (индекс 0)
  440.         int smallestIndex = startIndex;
  441.  
  442.         // Затем ищем элемент поменьше в остальной части массива
  443.         for (int currentIndex = startIndex + 1; currentIndex < length; ++currentIndex)
  444.         {
  445.             // Если мы нашли элемент, который меньше нашего наименьшего элемента,
  446.             if (mas[currentIndex] < mas[smallestIndex])
  447.                 // то запоминаем его
  448.                 smallestIndex = currentIndex;
  449.         }
  450.  
  451.         // smallestIndex теперь наименьший элемент.
  452.                 // Меняем местами наше начальное наименьшее число с тем, которое мы обнаружили
  453.         swap(&mas[startIndex], &mas[smallestIndex]);
  454.     }
  455. }
  456.  
  457. swap.h
  458. #ifndef SWAP_H_
  459. #define SWAP_H_
  460. void swap(int* a, int* b);
  461. #endif
  462.  
  463. swap.cpp
  464. #include "swap.h"
  465. void swap(int* a, int* b)
  466. {
  467.     int temp = *a;
  468.     *a = *b;
  469.     *b = temp;
  470. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!