API tools faq
paste
Advertisement
P1punGorbach

KURSACH готовый

P1punGorbach
Mar 15th, 2023
670
0
Never
1
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 12.37 KB | None | 0 0
raw download clone embed print report
  1. //кольцевой односвязный список векторов целого типа на односвязном списке
  2.  
  3.  
  4. #include <iostream>
  5. #include <stdio.h>
  6. #include <string.h>
  7. #include <stdlib.h>
  8.  
  9. using namespace std;
  10.  
  11. struct Node {
  12.     int value;
  13.     struct Node* next;
  14. };
  15.  
  16. struct Vec {
  17.     struct Node* first = NULL; 
  18.     int counter = 0;
  19. };
  20. struct ListNode {
  21.     Vec value;
  22.     struct ListNode* next;
  23. };
  24. struct List {
  25.     struct ListNode* first = NULL;
  26.     struct ListNode* Last = NULL;
  27.     struct ListNode* current = NULL;
  28.     int counter = 0;
  29. };
  30.  
  31. void alloc_check(void* p) {
  32.     if (p == NULL) {
  33.         printf("\n= Ошибка выделения памяти. =\n");
  34.         exit(-1);
  35.     }
  36. }
  37. bool current_check(List* L) {
  38.     if (L->current == NULL) {
  39.         printf("= Ошибка! Нет выбранного вектора! = \n");
  40.         return true;
  41.     }
  42.     else return false;
  43. }
  44. void ListEmptyCheck(List* L) {
  45.     if (L->counter == 0) {
  46.         printf("Список пуст!\n");
  47.        
  48.     }
  49.     else printf("Список не пуст!\n");
  50. }
  51. void clear_buff() {
  52.     int c;
  53.     while ((c = getchar()) != '\n' && c != EOF) {}
  54. }
  55. void MakeEmpty(Vec* V) {
  56.     struct Node* p, * p1;
  57.     p = V->first;
  58.     for (int i = 0; i < V->counter;i++) {
  59.         p1 = p->next;
  60.         free (p);
  61.         p = p1;
  62.     }
  63.     V->first = NULL;   
  64.     V->counter = 0;
  65.     printf("Список очищен!\n");
  66. }
  67. void EmptyCheck(Vec* V) {
  68.     if (V->counter == 0) {
  69.         printf("Список пуст!\n");
  70.     }
  71.     else {
  72.         printf("Список не пуст\n");
  73.     }
  74. }
  75. void ShowInd(Vec* V) {
  76.     int num = 0;
  77.     Node *tmp = V->first;
  78.     if (V->counter == 0) {
  79.         printf("Список пуст!\n");
  80.  
  81.     }
  82.     else {
  83.         printf("Введите индекс элемента: ");
  84.         if (scanf_s("%d", &num)==1 && num > 0 && num<=(V->counter)) {
  85.             for (int i = 0; i < num-1; i++) {
  86.                 tmp = tmp->next;
  87.             }
  88.             printf("Значение элемента: %d\n", tmp->value);
  89.         }
  90.         else {
  91.             printf("Введите правильное число!\n");
  92.         }
  93.     }
  94. }
  95. void EndAdd(Vec* V) {
  96.     int val = 0;
  97.     Node* tmp = V->first;
  98.     printf("Введите элемент: ");
  99.     if (scanf_s("%d", &val) == 1) {
  100.  
  101.         if (V->first)
  102.         {
  103.             while (tmp->next)
  104.             {
  105.                 tmp = tmp->next;
  106.             }
  107.             tmp->next = (Node*)malloc(sizeof(Node));
  108.             alloc_check(tmp->next);
  109.             tmp->next->value = val;
  110.             tmp->next->next = NULL;
  111.         }
  112.         else
  113.         {
  114.             V->first = (Node*)malloc(sizeof(Node));
  115.             alloc_check(V->first);
  116.             V->first->value = val;
  117.             V->first->next = NULL;
  118.         }
  119.  
  120.         V->counter++;
  121.         printf("Элемент добавлен\n");
  122.     }
  123.     else
  124.         clear_buff();
  125.         printf("Введите число!\n");
  126. }
  127. void ShowVec(Vec* V) {
  128.     if (V->counter != 0) {
  129.         Node* curr = V->first;
  130.         printf("[ ");
  131.         while (curr) {
  132.             printf("%d ", curr->value);        
  133.             curr = curr->next;
  134.         }
  135.         printf("]\n");
  136.     }
  137.     else {
  138.         printf("Вектор пуст!\n");
  139.         return;
  140.     }
  141. }
  142. void EndDel(Vec* V) {
  143.     Node* tmp = V->first;
  144.     if (V->first)
  145.     {
  146.         if (V->counter == 1) {
  147.             free(tmp);
  148.             V->first = NULL;
  149.             V->counter--;
  150.         }
  151.         else {
  152.             while (tmp->next->next != NULL)
  153.             {
  154.                 tmp = tmp->next;
  155.             }
  156.             free(tmp->next);
  157.             tmp->next = NULL;
  158.             V->counter--;
  159.         }
  160.         printf("Элемент удален!\n");
  161.     }
  162.     else
  163.     printf("Вектор пуст!\n");
  164. }
  165. void ChangebyInd(Vec* V)
  166. {
  167.     int num = 0;
  168.     int val;
  169.     Node* tmp = V->first;
  170.     if (V->counter == 0) {
  171.         printf("Список пуст!\n");
  172.     }
  173.     else {
  174.         printf("Введите индекс элемента: ");
  175.         scanf_s("%d", &num);
  176.         printf("Введите новое значение элемента: ");
  177.         if (scanf_s("%d", &val) != 1) {
  178.             clear_buff();
  179.             printf("Введите число!\n");
  180.             return;
  181.         }      
  182.         if (num > 0 && num <= V->counter && scanf_s("%d", &val) == 1) {
  183.             for (int i = 1; i < num; i++) {
  184.                 tmp = tmp->next;
  185.             }
  186.             tmp->value = val;
  187.             printf("Элемент изменен!\n");
  188.         }
  189.         else {
  190.             clear_buff();
  191.             printf("Элемента под данным индексом не существует!\n");
  192.             return;
  193.         }
  194.     }
  195. }
  196. void ElCount(Vec* V) {
  197.     printf("Количество элементов: %d\n", V->counter);
  198.  
  199. }
  200. void TakebyInd(Vec* V) {
  201.     int num = 0;
  202.     Node* tmp = V->first;
  203.     Node* prevTmp = NULL;
  204.     if (V->counter <= 0) {
  205.         printf("Список пуст!\n");
  206.     }
  207.     else {
  208.         printf("Введите индекс элемента: ");
  209.        
  210.         if (scanf_s("%d", &num) == 1 && num > 0 && num <= V->counter) {
  211.             for (int i = 1; i < num; i++) {
  212.                 prevTmp = tmp;
  213.                 tmp = tmp->next;
  214.             }
  215.             printf("Элемент: %d\n", tmp->value);
  216.             if (num != 1) {
  217.                 prevTmp->next = tmp->next;
  218.             }
  219.             free(tmp);
  220.             V->counter--;
  221.             if (V->counter == 0) {
  222.                 V->first = NULL;
  223.             }
  224.            
  225.         }
  226.         else{
  227.             clear_buff();
  228.             printf("Неправильный символ!\n");
  229.         }
  230.     }
  231. }
  232.  
  233. void VecStart(Vec* V) {
  234.     while (1) {
  235.         int num;
  236.  
  237.         printf("= Обработка вектора =\n\
  238. 1.  Сделать пустым\n\
  239. 2.  Пуст ли ?\n\
  240. 3.  Сколько элементов ?\n\
  241. 4.  Показать значение элемента по индексу, при некорректном индексе выводится сообщение\n\
  242. 5.  Удалить элемент из конца\n\
  243. 6.  Взять элемент по индексу\n\
  244. 7.  Изменить значение по индексу\n\
  245. 8.  Добавить элемент в конец\n\
  246. 9.  Распечатать вектор\n\
  247. 10. Закончить работу\n");
  248.         if (scanf_s("%d", &num) == 1) {
  249.             switch (num)
  250.             {
  251.             case 1:
  252.                 system("cls");
  253.                 MakeEmpty(V);
  254.  
  255.                 break;
  256.             case 2:
  257.                 system("cls");
  258.                 EmptyCheck(V);
  259.  
  260.                 break;
  261.             case 3:
  262.                 system("cls");
  263.                 ElCount(V);
  264.                 break;
  265.             case 4:
  266.                 system("cls");
  267.                 ShowInd(V);
  268.  
  269.                 break;
  270.             case 5:
  271.                 system("cls");
  272.                 EndDel(V);
  273.  
  274.                 break;
  275.             case 6:
  276.                 system("cls");
  277.                 TakebyInd(V);
  278.  
  279.                 break;
  280.             case 7:
  281.                 system("cls");
  282.                 ChangebyInd(V);
  283.  
  284.                 break;
  285.             case 8:
  286.                 system("cls");
  287.                 EndAdd(V);
  288.  
  289.                 break;
  290.             case 9:
  291.                 system("cls");
  292.                 ShowVec(V);
  293.  
  294.                 break;
  295.             case 10:
  296.                 system("cls");
  297.                 return;
  298.                 break;
  299.             default:
  300.                 printf("Неправильное число!\n");
  301.  
  302.             }
  303.         }
  304.         else {
  305.             clear_buff();
  306.             printf("Неправильный символ!\n");
  307.         }
  308.     }
  309.  
  310. }
  311. //=========================================================
  312. void ListFree(List* L){
  313.     struct ListNode* p, * p1;
  314.     p = L->first;
  315.     for(int i=0; i<L->counter;i++) {
  316.         p1 = p->next;
  317.         MakeEmpty(&p->value);
  318.         free(p);
  319.         p = p1;
  320.     }
  321.     L->first = NULL;
  322.     L->Last = NULL;
  323.     L->current = NULL;
  324.     L->counter = 0;
  325. }
  326. void MoveIndFw(List* L){
  327.     if (L->first == L->Last) {
  328.         printf("Некуда двигать!\n");
  329.     }
  330.     else {
  331.         L->current = L->current->next;
  332.         printf("Указатель переехал!\n");
  333.     }
  334. }
  335. void LookAfterInd(List* L){
  336.     if (L->counter == 1) {
  337.         printf("Вектор: ");
  338.         ShowVec(&L->current->value);
  339.     }
  340.     else {
  341.         printf("Вектор: ");
  342.         ShowVec(&L->current->next->value);
  343.     }
  344. }
  345.  
  346. void DelAftInd(List* L) {
  347.     ListNode* del;
  348.    
  349.         if (L->current == L->Last) {
  350.             del = L->first;
  351.             L->first = L->first->next;
  352.             free(del);
  353.             L->counter--;
  354.             printf("Элемент удален!\n");
  355.         }
  356.         else {
  357.             del = (ListNode*)L->current->next;
  358.             L->current->next = del->next;
  359.             free(del);
  360.             L->counter--;
  361.             printf("Элемент удален!\n");
  362.         }
  363.        
  364. }
  365. void TakeAftInd(List* L) {
  366.     if (L->counter == 0) {
  367.         printf("Список пуст!\n");
  368.     }
  369.     else {
  370.         ListNode* del;
  371.         del = (ListNode*)L->current->next;
  372.         printf("Вектор: ");
  373.         ShowVec(&del->value);
  374.         L->current->next = del->next;
  375.         free(del);
  376.         L->counter--;
  377.         printf("Элемент удален!\n");
  378.     }
  379. }
  380. void ChangeAftInd(List* L) {
  381.     int val;
  382.     if (L->counter == 1) {
  383.     VecStart(&L->current->value);
  384.     }
  385.     else {
  386.         VecStart(&L->current->next->value);
  387.     }
  388.    
  389. }
  390. void AddAftInd(List* L) {  
  391.    
  392.     ListNode* str;
  393.         if (L->counter == 0) {
  394.             str = (ListNode*)malloc(sizeof(ListNode));
  395.             alloc_check(str);  
  396.             str->value = { NULL,0 };
  397.             L->first = str;
  398.             L->current = str;
  399.             L->Last = str;
  400.             L->counter++;
  401.         }
  402.         else {
  403.             str = (ListNode*)malloc(sizeof(ListNode));
  404.             alloc_check(str);
  405.             str->value = { NULL,0 };
  406.             if (L->current == L->Last) {
  407.                 str->next = L->first;
  408.                 L->current->next = str;
  409.                 L->Last = str;
  410.                 L->counter++;
  411.             }
  412.             else {
  413.                 str->next = L->current->next;
  414.                 L->current->next = str;
  415.                 L->counter++;
  416.             }
  417.  
  418.         }
  419.         ChangeAftInd(L);
  420.    
  421.  
  422. }
  423. void LastIndCheck(List* L){
  424.     if (L->current == L->Last) {
  425.         printf("Указатель на последнем элементе!\n");
  426.     }
  427.     else
  428.         printf("Указатель не на последнем элементе!\n");
  429.  
  430.  
  431. }
  432. void PrintList(List* L) {
  433.     ListNode* pr = L->first;
  434.     if (L->counter == 0) {
  435.         printf("Списочек то пустой...\n");
  436.     }
  437.     for (int i = 0;i<L->counter; i++) {
  438.         if (pr == L->current) {
  439.             printf("!");
  440.         }
  441.         ShowVec(&pr->value);       
  442.         pr = pr->next;
  443.     }  
  444. }
  445. void IndSetStart(List* L) {
  446.     L->current = L->first;
  447.     printf("Курсор установлен\n");
  448. }
  449. void ListMenu(List *L)
  450. {
  451.     while (1) {
  452.  
  453.         int num;       
  454.         printf("= Обработка кольцевого списка =\n\
  455. 1.  Сделать список пустым\n\
  456. 2.  Пусто ли? \n\
  457. 3.  Установить рабочий указатель в начало списка\n\
  458. 4.  В конце ли списка рабочий указатель? \n\
  459. 5.  Передвинуть рабочий указатель вперёд\n\
  460. 6.  Посмотреть за указатель\n\
  461. 7.  Удалить за указателем\n\
  462. 8.  Взять элемент за указателем\n\
  463. 9.  Изменить значение элемента списка за указателем\n\
  464. 10. Добавить за указатель.\n\
  465. 11. Распечатать\n\
  466. 12. Закончить работу\n");
  467.        
  468.         if (scanf_s("%d", &num) == 1) {
  469.             switch (num)
  470.             {
  471.            
  472.             case 1:
  473.                 system("cls");
  474.                 ListFree(L);
  475.                 printf("Список очищен!\n");
  476.  
  477.                 break;
  478.             case 2:
  479.                 system("cls");             
  480.                 ListEmptyCheck(L);
  481.                 break;
  482.             case 3:
  483.                 system("cls");
  484.                 if (L->counter == 0) {
  485.                     printf("Список пуст!\n");
  486.                     break;
  487.                 }
  488.                 IndSetStart(L);        
  489.                 break;
  490.             case 4:
  491.                 system("cls");
  492.                 if (L->counter == 0) {
  493.                     printf("Список пуст!\n");
  494.                     break;
  495.                 }
  496.                 LastIndCheck(L);
  497.                
  498.                 break;
  499.             case 5:
  500.                 system("cls");
  501.                 if (L->counter == 0) {
  502.                     printf("Список пуст!\n");
  503.                     break;
  504.                 }
  505.                 MoveIndFw(L);
  506.  
  507.                 break;
  508.             case 6:
  509.                 system("cls");
  510.                 if (L->counter == 0) {
  511.                     printf("Список пуст!\n");
  512.                     break;
  513.                 }
  514.                 if (current_check(L)) break;
  515.                 LookAfterInd(L);
  516.  
  517.                 break;
  518.             case 7:
  519.                 system("cls");
  520.                 if (L->counter == 0) {
  521.                     printf("Список пуст!\n");
  522.                     break;
  523.                 }
  524.                 if (current_check(L)) break;
  525.                 DelAftInd(L);
  526.  
  527.                 break;
  528.             case 8:
  529.                 system("cls");
  530.                 if (L->counter == 0) {
  531.                     printf("Список пуст!\n");
  532.                     break;
  533.                 }
  534.                 if (current_check(L)) break;
  535.                 TakeAftInd(L);
  536.  
  537.                 break;
  538.             case 9:
  539.                 system("cls");
  540.                 if (L->counter == 0) {
  541.                     printf("Список пуст!\n");
  542.                     break;
  543.                 }
  544.                 if (current_check(L)) break;
  545.                 ChangeAftInd(L);
  546.                 break;
  547.             case 10:
  548.                 system("cls");
  549.  
  550.                 AddAftInd(L);              
  551.                 printf("Элемент добавлен!\n");
  552.                 break;
  553.             case 11:
  554.                 system("cls");
  555.                 PrintList(L);
  556.                 break;
  557.             case 12:               
  558.                 system("cls");
  559.                 ListFree(L);
  560.                 printf("Работа закончена\n");
  561.                 return;
  562.  
  563.             default:
  564.                 printf("Неправильное число!\n");
  565.  
  566.             }
  567.  
  568.         }
  569.         else {
  570.             clear_buff();
  571.             printf("Неправильный символ!\n");
  572.         }
  573.     }
  574.    
  575. }
  576.  
  577. void ProgramStart(List* L) {
  578.     int num = 0;
  579.     while (1) {
  580.         printf("1. Начать программу\n\
  581. 2. Выйти из программы\n");
  582.         if (scanf_s("%d", &num) == 1) {
  583.             switch (num) {
  584.             case 1:
  585.                 system("cls");
  586.                
  587.                 ListMenu(L);
  588.                
  589.                 break;
  590.             case 2:
  591.                 exit(1);
  592.                 break;
  593.  
  594.             default:
  595.                 printf("Неправильное число!\n");
  596.             }
  597.         }
  598.         else {
  599.             clear_buff();
  600.             printf("Неправильный символ!\n");
  601.         }
  602.     }
  603. }
  604.  
  605. int main() {
  606.     setlocale(LC_ALL, "Russian");  
  607.     List L;
  608.     ProgramStart(&L);  
  609. }
Advertisement
Comments
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!