SHARE
TWEET

Untitled

a guest May 22nd, 2019 65 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include "pch.h"
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <malloc.h>
  5. #include <math.h>
  6. #include <time.h>
  7. #include <stdlib.h>
  8.  
  9. const double MAX = 1000;
  10.  
  11. typedef struct Link {
  12.     int i; //индекс
  13.     double ves; //вес ребра
  14.     struct Link *next;
  15. }Link;
  16.  
  17. typedef struct Item {
  18.     int name;
  19.     int x;
  20.     int y;
  21.     double d;
  22.     Item *pred;
  23.     Link *first;
  24. }Item;
  25.  
  26. typedef struct Graf {
  27.     int size; //размер вектора
  28.     int n; //количество вершин
  29.     struct Item *head;
  30. }Graf;
  31.  
  32.  
  33. const char *msgs[] = { "0. Quit", "1. Add_top", "2. Add_rib", "3. Find", "4. Delete", "5. Show", "6. File_in", "7. File_out", "8. Random_Generation" }; // список альтернатив
  34. const int NMsgs = sizeof(msgs) / sizeof(msgs[0]);
  35.  
  36.  
  37. int dialog(const char *msgs[], int); // выбор номера альтернативы
  38. int D_Add_top(Graf *);
  39. int D_Add_rib(Graf *);
  40. int D_Find(Graf *);
  41. int D_Delete(Graf *);
  42. int D_Show(Graf *);
  43. int D_File_in(Graf*);
  44. int D_File_out(Graf *);
  45. int D_Random_Generation(Graf *);
  46.  
  47. int insert(Graf *, int, int, int);
  48. void  deletee(Graf *, int, int);
  49. int FileOpenFlag = 0;
  50. void rand_gen(Graf *, int, int);
  51. void deleteall(Graf* graf);
  52.  
  53. int(*fptr[])(struct Graf *) = { NULL, D_Add_top, D_Add_rib, D_Find, D_Delete, D_Show, D_File_in, D_File_out, D_Random_Generation };
  54.  
  55.  
  56. int getInt(int *pn)
  57. {
  58.     const char *errmsg = "";
  59.     int n;
  60.     do {
  61.         puts(errmsg);
  62.         errmsg = "Illegal integer; enter once more";
  63.         n = scanf_s("%d", pn, 4);
  64.         if (n < 0) // обнаружен конец файла
  65.             return 0;
  66.         scanf_s("%*[^\n]"); // игнорирование всех символов до конца строки
  67.         scanf_s("%*c"); // игнорирование символа кнца строки
  68.     } while (n == 0);
  69.     return 1;
  70. }
  71.  
  72. char *getStr()
  73. {
  74.     char *ptr = (char *)malloc(1);
  75.     char buf[81];
  76.     int n, len = 0;
  77.     *ptr = '\0';
  78.     do {
  79.         n = scanf_s("%80[^\n]", buf, 81);
  80.         if (n < 0) {
  81.             free(ptr);
  82.             ptr = NULL;
  83.             continue;
  84.         }
  85.         else
  86.             if (n)
  87.             {
  88.                 len += strlen(buf);
  89.                 ptr = (char *)realloc(ptr, len + 1);
  90.                 strncat_s(ptr, len + 1, buf, len);
  91.             }
  92.     } while (n > 0);
  93.     scanf_s("%*c"); //удалить последний символ строки
  94.     return ptr;
  95. }
  96.  
  97. int dialog(const char *msgs[], int N)
  98. {
  99.     const char *errmsg = "";
  100.     int rc;
  101.     int i, n;
  102.     do {
  103.         puts(errmsg);
  104.         errmsg = "You are wrong. Repeate, please!";
  105.         // вывод списка альтернатив
  106.         for (i = 0; i < N; ++i)
  107.             puts(msgs[i]);
  108.         puts("Make your choice: --> ");
  109.         n = getInt(&rc); // ввод номера альтернативы
  110.         if (n == 0) // конец файла - конец работы
  111.             rc = 0;
  112.     } while (rc < 0 || rc >= N);
  113.     return rc;
  114. }
  115.  
  116.  
  117. void add_info(Item* curr, int name, int x, int y)
  118. {
  119.     curr->name = name;
  120.     curr->x = x;
  121.     curr->y = y;
  122.     curr->d = MAX;
  123.     curr->pred = NULL;
  124. }
  125.  
  126. int find_notexist_empty(Graf* graf, int name, int x, int y)
  127. {
  128.     int i, buf = -1;
  129.  
  130.     for (i = 0; i < graf->size; ++i)
  131.     {
  132.         if (graf->head[i].name == name)
  133.         {
  134.             puts("Top with this name is already exist with");
  135.             return buf;
  136.         }
  137.  
  138.         if (graf->head[i].name != -1 && graf->head[i].x == x)
  139.             if (graf->head[i].y == y)
  140.             {
  141.                 puts("Top with this cords is already exist with");
  142.                 return buf;
  143.             }
  144.         if (graf->head[i].name == -1)
  145.         {
  146.             buf = i;
  147.             graf->n++;
  148.             return buf;
  149.         }
  150.     }
  151.     graf->size += 1;
  152.     graf->n += 1;
  153.     graf->head = (Item*)realloc(graf->head, (i + 1) * sizeof(Item));
  154.     graf->head[graf->size - 1].first = NULL;
  155.     buf = graf->size - 1;
  156.  
  157.     return buf;
  158. }
  159.  
  160. int insert(Graf *graf, int name, int x, int y)
  161. {
  162.     int p = find_notexist_empty(graf, name, x, y);
  163.     if (p != -1)
  164.     {
  165.         add_info(&(graf->head[p]), name, x, y);
  166.         return 1;
  167.     }
  168.     else
  169.         return 0;
  170. }
  171.  
  172. int D_Add_top(Graf *graf)
  173. {
  174.     int x, y, rc, n;
  175.     int name;
  176.  
  177.     puts("Enter name: -->");
  178.     n = getInt(&name);
  179.     if (n == 0)
  180.         return 0;
  181.  
  182.     puts("Enter x cord: -->");
  183.     n = getInt(&x);
  184.     if (n == 0)
  185.         return 0; // конец файла
  186.  
  187.     puts("Enter y cord: -->");
  188.     n = getInt(&y);
  189.     if (n == 0)
  190.         return 0; // конец файла
  191.  
  192.     rc = insert(graf, name, x, y); // вставка элемента в таблицу
  193.     if (rc)
  194.     {
  195.         printf("Top was added with name: %d \n", name);
  196.     }
  197.  
  198.     return 1;
  199. }
  200.  
  201. void transfer(Item* p_r, Item* p_l, Link* p_e, int i)
  202. {
  203.     int d;
  204.     double h;
  205.     Link *buf_p_e = p_e->next;
  206.     p_e->next = (Link*)malloc(sizeof(Link));
  207.     d = p_e->i;
  208.     h = p_e->ves;
  209.     p_e->i = i;
  210.     p_e->ves = sqrt(pow((p_r->x - p_l->x), 2) + pow((p_r->y - p_l->y), 2));
  211.     p_e = p_e->next;
  212.     p_e->i = d;
  213.     p_e->ves = h;
  214.     p_e->next = buf_p_e;
  215. }
  216.  
  217. int work_add_pathway(Item* p_r, Item* p_l, int p, int q) {
  218.     if (p_r->first == NULL)
  219.     {
  220.         p_r->first = (Link*)malloc(sizeof(Link));
  221.         p_r->first->i = q;
  222.         p_r->first->next = NULL;
  223.         p_r->first->ves = sqrt(pow((p_r->x - p_l->x), 2) + pow((p_r->y - p_l->y), 2));
  224.         return 1;
  225.     }
  226.     Link *p_e = p_r->first;
  227.     for (; p_e->next != NULL; p_e = p_e->next) {
  228.         if (p_e->i == q) {
  229.             return 2;
  230.         }
  231.         if (p_e->i > q) {
  232.             transfer(p_r, p_l, p_e, q);
  233.             return 1;
  234.         }
  235.     }
  236.  
  237.     if (p_e->next == NULL) {
  238.         if (p_e->i == q) {
  239.             return 2;
  240.         }
  241.  
  242.         if (p_e->i > q)
  243.         {
  244.             transfer(p_r, p_l, p_e, q);
  245.             return 1;
  246.         }
  247.         else
  248.         {
  249.             p_e->next = (Link*)malloc(sizeof(Link));
  250.             p_e = p_e->next;
  251.             p_e->i = q;
  252.             p_e->ves = sqrt(pow((p_r->x - p_l->x), 2) + pow((p_r->y - p_l->y), 2));
  253.             p_e->next = NULL;
  254.             return 1;
  255.         }
  256.     }
  257.  
  258.     return 0;
  259. }
  260.  
  261.  
  262. int add_rib(Graf* graf, int top1, int top2)
  263. {
  264.     int i, j, p, q, f1 = 0, f2 = 0;
  265.     for (i = 0; i < graf->size; ++i)
  266.     {
  267.         if (graf->head[i].name == top1)
  268.         {
  269.             p = i;
  270.             f1 = 1;
  271.         }
  272.     }
  273.     if (f1 != 1)
  274.     {
  275.         puts("Top1 hasn't found.");
  276.         return 0;
  277.     }
  278.  
  279.     for (j = 0; j < graf->size; ++j)
  280.     {
  281.         if (graf->head[j].name == top2)
  282.         {
  283.             q = j;
  284.             f2 = 1;
  285.         }
  286.     }
  287.     if (f2 != 1)
  288.     {
  289.         puts("Top2 hasn't found.");
  290.         return 0;
  291.     }
  292.  
  293.     int n = work_add_pathway(&(graf->head[p]), &(graf->head[q]), top1, top2);
  294.     if (n == 1)
  295.         return 1;
  296.     if (n == 2)
  297.         return 2;
  298.     return 0;
  299. }
  300.  
  301. int D_Add_rib(Graf* graf)
  302. {
  303.     int t1, t2;
  304.     int  n, l;
  305.     puts("Enter name 1st top: -->");
  306.     n = getInt(&t1);
  307.     if (n == 0)
  308.         return 0;
  309.     puts("Enter name 2nd top: -->");
  310.     n = getInt(&t2);
  311.     if (n == 0)
  312.         return 0;
  313.  
  314.     l = add_rib(graf, t1, t2);
  315.     if (l==1)
  316.         puts("Rib was created successfully.");
  317.     if (l==2)
  318.         puts("Rib is already exist.");
  319.     return 1;
  320. }
  321.  
  322. void dell_one(Graf *graf, int k)
  323. {
  324.     Link *p_e = graf->head[k].first;
  325.     while (p_e != NULL)
  326.     {
  327.         Link *p_e_del = p_e;
  328.         p_e = p_e->next;
  329.         free(p_e_del);
  330.     }
  331. }
  332.  
  333.  
  334. void deletee(Graf *graf, int k, int nm)
  335. {
  336.     int j, g;
  337.     // удаляем связи
  338.     for (j = 0; j < k; j++)
  339.     {
  340.         if (graf->head[j].first)
  341.         {
  342.             Link *p_e = graf->head[j].first;
  343.  
  344.             if (p_e->next == NULL)
  345.             {
  346.                 if (p_e->i == nm)
  347.                 {
  348.                     graf->head[j].first = NULL;
  349.                     free(p_e);
  350.                 }
  351.             }
  352.             else
  353.             {
  354.                 if (p_e->i == nm)
  355.                 {
  356.                     graf->head[j].first = p_e->next;
  357.                     p_e->next = NULL;
  358.                     free(p_e);
  359.                 }
  360.                 else
  361.                 {
  362.                     for (; p_e->next != NULL; p_e = p_e->next)
  363.                     {
  364.                         if (p_e->next->i == nm)
  365.                         {
  366.                             Link *p_e_del = p_e->next;
  367.                             p_e->next = p_e_del->next;
  368.                             p_e_del->next = NULL;
  369.                             free(p_e_del);
  370.                         }
  371.                         if (p_e->next == NULL)
  372.                             break;
  373.                     }
  374.                 }
  375.             }
  376.         }
  377.     }
  378.  
  379.     for (g = (k + 1); g < graf->size; g++)
  380.     {
  381.         if (graf->head[g].first)
  382.         {
  383.             Link *p_e = graf->head[g].first;
  384.             if (p_e->next == NULL)
  385.             {
  386.                 if (p_e->i == nm)
  387.                 {
  388.                     graf->head[g].first = NULL;
  389.                     free(p_e);
  390.                 }
  391.             }
  392.             else
  393.             {
  394.                 if (p_e->i == nm)
  395.                 {
  396.                     graf->head[g].first = p_e->next;
  397.                     p_e->next = NULL;
  398.                     free(p_e);
  399.                 }
  400.                 else
  401.                 {
  402.                     for (; p_e->next != NULL; p_e = p_e->next)
  403.                     {
  404.                         if (p_e->next->i == nm)
  405.                         {
  406.                             Link *p_e_del = p_e->next;
  407.                             p_e->next = p_e_del->next;
  408.                             p_e_del->next = NULL;
  409.                             free(p_e_del);
  410.                         }
  411.                         if (p_e->next == NULL)
  412.                             break;
  413.                     }
  414.                 }
  415.             }
  416.         }
  417.     }
  418.     //удаляем вершину
  419.     dell_one(graf, k);
  420.     graf->head[k].first = NULL;
  421.     graf->head[k].name = -1;
  422.     graf->n--;
  423. }
  424.  
  425. int D_Delete(Graf *graf)
  426. {
  427.     int n, nm, i, k = -1;
  428.     int name;
  429.     puts("Enter top name: -->");
  430.     n = getInt(&name);
  431.     if (n == 0)
  432.         return 0;
  433.     nm = name;
  434.     for (i = 0; i < graf->size; i++)
  435.     {
  436.         if (graf->head[i].name == name)
  437.             k = i;
  438.     }
  439.     if (k != -1)
  440.     {
  441.         deletee(graf, k, nm);
  442.         puts("Ok");
  443.     }
  444.     else
  445.         puts("Top hasn't found");
  446.     return 1;
  447. }
  448.  
  449. void show(Graf *graf)
  450. {
  451.     if (graf->n == 0)
  452.         puts("Graf wasn't found");
  453.  
  454.     int i;
  455.     for (i = 0; i < graf->size; ++i)
  456.     {
  457.         if (graf->head[i].name != -1)
  458.         {
  459.             printf("%d (%d;%d) --> ", graf->head[i].name, graf->head[i].x, graf->head[i].y);
  460.             Link *p_e = graf->head[i].first;
  461.             if (p_e)
  462.             {
  463.                 for (p_e; p_e->next != NULL; p_e = p_e->next)
  464.                     printf("%d (weight = %f), ", p_e->i, p_e->ves);
  465.                 printf("%d (weight = %f)\n", p_e->i, p_e->ves);
  466.             }
  467.             else
  468.             {
  469.                 printf("Null\n");
  470.             }
  471.         }
  472.     }
  473. }
  474.  
  475. int D_Show(Graf *graf)
  476. {
  477.     show(graf);
  478.     return 1;
  479. }
  480.  
  481. Graf init()
  482. {
  483.     Graf *graf = (Graf*)malloc(sizeof(Graf));
  484.     graf->size = 0;
  485.     graf->n = 0;
  486.     graf->head = NULL;
  487.     return *graf;
  488. }
  489.  
  490. int sort(Graf *line)
  491. {
  492.     int i, n;
  493.     Item *buf = (Item*)malloc(sizeof(Item));
  494.     n = line->size;
  495.     for (i = 0; i < n - 1; i++) //сортировка массива
  496.     {
  497.         for (int j = n - 1; j > i; j--)
  498.         {
  499.             if (line->head[j - 1].d > line->head[j].d)
  500.             {
  501.                 buf->name = line->head[j - 1].name;
  502.                 buf->x = line->head[j - 1].x;
  503.                 buf->y = line->head[j - 1].y;
  504.                 buf->d = line->head[j - 1].d;
  505.                 buf->pred = line->head[j - 1].pred;
  506.                 buf->first = line->head[j - 1].first;
  507.  
  508.                 line->head[j - 1].name = line->head[j].name;
  509.                 line->head[j - 1].x = line->head[j].x;
  510.                 line->head[j - 1].y = line->head[j].y;
  511.                 line->head[j - 1].d = line->head[j].d;
  512.                 line->head[j - 1].pred = line->head[j].pred;
  513.                 line->head[j - 1].first = line->head[j].first;
  514.  
  515.                 line->head[j].name = buf->name;
  516.                 line->head[j].x = buf->x;
  517.                 line->head[j].y = buf->y;
  518.                 line->head[j].d = buf->d;
  519.                 line->head[j].pred = buf->pred;
  520.                 line->head[j].first = buf->first;
  521.             }
  522.         }
  523.     }
  524.    
  525.     return 0;
  526. }
  527.  
  528. Item Extract_min(Graf *line, int size)
  529. {
  530.     Item *res = (Item*)malloc(sizeof(Item));
  531.  
  532.     res->name = line->head[0].name;
  533.     res->x = line->head[0].x;
  534.     res->y = line->head[0].y;
  535.     res->d = line->head[0].d;
  536.     res->pred = line->head[0].pred;
  537.     res->first = line->head[0].first;
  538.  
  539.     line->head[0] = line->head[size - 1];
  540.     line->head[0].name = line->head[size - 1].name;
  541.     line->head[0].x = line->head[size - 1].x;
  542.     line->head[0].y = line->head[size - 1].y;
  543.     line->head[0].d = line->head[size - 1].d;
  544.     line->head[0].pred = line->head[size - 1].pred;
  545.     line->head[0].first = line->head[size - 1].first;
  546.  
  547.     line->head[size - 1].d = (MAX+1);
  548.     line->head[size - 1].name = -1;
  549.     line->n--;
  550.     sort(line);
  551.     return *res;
  552. }
  553.  
  554. double Dijkstra(Graf *graf, int t1, int t2)
  555. {
  556.     int n, name, m = 0, i, l = 0, j, x, y,  g, p, h, v = -1, q, b, k, f1=0, f2=0;
  557.     double w;
  558.     Item *u = (Item*)malloc(sizeof(Item));
  559.  
  560.     n = graf->size;
  561.     for (g = 0; g < graf->size; ++g)
  562.     {
  563.         if (graf->head[g].name == t1)
  564.         {
  565.             p = g;
  566.             f1 = 1;
  567.         }
  568.     }
  569.     if (f1 != 1)
  570.     {
  571.         puts("Top1 hasn't found.");
  572.         return -2;
  573.     }
  574.  
  575.     for (j = 0; j < graf->size; ++j)
  576.     {
  577.         if (graf->head[j].name == t2)
  578.         {
  579.             q = j;
  580.             f2 = 1;
  581.         }
  582.     }
  583.     if (f2 != 1)
  584.     {
  585.         puts("Top2 hasn't found.");
  586.         return -2;
  587.     }
  588.  
  589.     Graf line = init();
  590.     Graf S = init();
  591.     for (i = 0; i < n; i++)
  592.     {
  593.         name = graf->head[i].name;
  594.         x = graf->head[i].x;
  595.         y = graf->head[i].y;
  596.         if (name != -1)
  597.         insert(&line, name, x, y);
  598.     }
  599.  
  600.     for (h = 0; h < n; h++)
  601.     {
  602.       name = graf->head[h].name;
  603.       Link *p_e = graf->head[h].first;
  604.       for (; p_e != NULL; p_e = p_e->next)
  605.       {
  606.          k = p_e->i;
  607.          add_rib(&line, name, k);
  608.       }
  609.     }
  610.  
  611.      line.head[p].d = 0;
  612.      sort(&line);
  613.  
  614.      while (line.n != 0)
  615.      {
  616.         *u = Extract_min(&line, line.size);
  617.  
  618.         insert(&S, u->name, u->x, u->y);
  619.         S.head[l].d = u->d;
  620.         S.head[l].pred = u->pred;
  621.         S.head[l].first = u->first;
  622.         S.n++;
  623.  
  624.         Link *p_l = S.head[l].first;
  625.         for (; p_l != NULL; p_l = p_l->next)
  626.         {
  627.             b = p_l->i;
  628.             for (int z = 0; z < line.size; ++z)
  629.             {
  630.                 if (line.head[z].name == b)
  631.                     v = z;
  632.             }
  633.             if (v != -1 && (line.head[v].d > (S.head[l].d + p_l->ves)))
  634.             {
  635.                 line.head[v].d = S.head[l].d + p_l->ves;
  636.                 line.head[v].pred = &S.head[l];
  637.                 sort(&line);
  638.             }
  639.             v = -1;
  640.         }
  641.         l++;
  642.      }
  643.  
  644.     for (int y = 0; y < graf->size; ++y)
  645.     {
  646.         if (S.head[y].name == t2)
  647.             k = y;
  648.     }
  649.     w = S.head[k].d;
  650.     if (w != MAX)
  651.     {
  652.         while (S.head[k].pred)
  653.         {
  654.             printf("%d <--", S.head[k].name);
  655.             S.head[k] = *S.head[k].pred;
  656.         }
  657.         printf("%d\n", S.head[k].name);
  658.     }
  659.  
  660.     return w;
  661. }
  662.  
  663.  
  664. int D_Find(Graf* graf) {
  665.     int t1, t2, n;
  666.     double x;
  667.     puts("Enter top1: -->");
  668.     n = getInt(&t1);
  669.     if (n == 0)
  670.         return 0;
  671.     puts("Enter top2: -->");
  672.     n = getInt(&t2);
  673.     if (n == 0)
  674.         return 0;
  675.     x = Dijkstra(graf, t1, t2);
  676.     if (x == -2)
  677.         return 1;
  678.     if (x == MAX)
  679.     {
  680.         printf("There is no path");
  681.             return 1;
  682.     }
  683.     printf("The shortest path from %d to %d: %f", t1, t2, x);
  684.     return 1;
  685. }
  686.  
  687.  
  688. Graf read_graf(FILE* file) {
  689.     Graf graf = init();
  690.     fseek(file, 0, SEEK_SET);
  691.     int size;
  692.  
  693.     if (fread(&size, sizeof(int), 1, file) == 1) {
  694.         int i;
  695.         for (i = 0; i < size; ++i) {
  696.  
  697.             int x, y, name = 0;
  698.  
  699.             if (fread(&name, sizeof(int), 1, file) == 1 &&
  700.                 fread(&x, sizeof(int), 1, file) == 1 &&
  701.                 fread(&y, sizeof(int), 1, file) == 1) {
  702.                 insert(&graf, name, x, y);
  703.             }
  704.  
  705.             int k;
  706.             while (fread(&k, sizeof(int), 1, file) == 1) {
  707.                 if (k == -1)
  708.                     break;
  709.                 else
  710.                     add_rib(&graf, name, k);
  711.             }
  712.         }
  713.     }
  714.     return graf;
  715. }
  716.  
  717. int D_File_in(Graf *graf) {
  718.     //Путь к файлу
  719.     puts("Put file name!");
  720.     char *graf_path = getStr();
  721.     if (&graf_path == NULL)
  722.     {
  723.         printf("Wrong filename or EOF. ");
  724.         return 0;
  725.     }
  726.     //Открытие файла
  727.     FILE *bfp = NULL;
  728.     fopen_s(&bfp, graf_path, "r+b");
  729.     if (!bfp)
  730.         printf("No file with this path");
  731.  
  732.     //Работа с файлом
  733.     if (bfp) {
  734.         *graf = read_graf(bfp);
  735.         D_Show(graf);
  736.         fclose(bfp);
  737.         printf("File was cloased");
  738.     }
  739.     else
  740.         printf("Something gone wrong, check access permissions.");
  741.  
  742.     FileOpenFlag = 1;
  743.     return 1;
  744. }
  745.  
  746.  
  747. int write_graf(Graf *graf, FILE* file) {
  748.     fseek(file, 0, SEEK_SET);
  749.  
  750.     if (graf->size == 0)
  751.         return 0;
  752.  
  753.     fwrite(&graf->size, sizeof(int), 1, file);
  754.     int i;
  755.     const int end_key = -1;
  756.     for (i = 0; i < graf->size; ++i) {
  757.         fwrite(&graf->head[i].name, sizeof(int), 1, file);
  758.         fwrite(&graf->head[i].x, sizeof(int), 1, file);
  759.         fwrite(&graf->head[i].y, sizeof(int), 1, file);
  760.  
  761.         Link *p_e = graf->head[i].first;
  762.         for (; p_e != NULL; p_e = p_e->next)
  763.             fwrite(&p_e->i, sizeof(int), 1, file);
  764.  
  765.         fwrite(&end_key, sizeof(int), 1, file);
  766.     }
  767.  
  768.     return 1;
  769. }
  770.  
  771. int D_File_out(Graf *graf) {
  772.     //Путь к файлу
  773.     puts("Put file name!");
  774.     char* graf_path = getStr();
  775.     if (&graf_path == NULL) {
  776.         printf("Wrong filename or EOF. ");
  777.         return 0;
  778.     }
  779.  
  780.     //Открытие файла
  781.     FILE* bfp = NULL;
  782.     fopen_s(&bfp, graf_path, "r+b");
  783.     if (!bfp)
  784.         fopen_s(&bfp, graf_path, "w+b");
  785.  
  786.     //Работа с файлом
  787.     if (bfp) {
  788.         if (!write_graf(graf, bfp))
  789.             printf("Something gone wrong. Start again pls.");
  790.         fclose(bfp);
  791.         printf("File was cloased");
  792.     }
  793.     else
  794.         printf("Something gone wrong, check access permissions.");
  795.  
  796.     FileOpenFlag = 0;
  797.     return 1;
  798. }
  799.  
  800. int D_Random_Generation(Graf *graf) {
  801.     int k1, k2, n;
  802.     puts("Enter how many tops you want to add: -->");
  803.     n = getInt(&k1);
  804.     if (n == 0)
  805.         return 0;
  806.     puts("Enter how many rib you want to add: -->");
  807.     n = getInt(&k2);
  808.     if (n == 0)
  809.         return 0;
  810.     rand_gen(graf, k1, k2);
  811.     return 1;
  812. }
  813.  
  814. int TF_gen() {
  815.     int p = rand();
  816.     while (p > 10) {
  817.         p /= 10;
  818.     }
  819.     if (p < 6)
  820.         p = 1;
  821.     else
  822.         p = -1;
  823.     return p;
  824. }
  825.  
  826. void rand_gen(Graf *graf, int num1, int num2) {
  827.     int i, n, x, y, name;
  828.     for (i = 0; i < num1; )
  829.     {
  830.         n = 0;
  831.         while (n == 0) {
  832.             x = (rand() * rand() * time(NULL) % (num1 + graf->size))* TF_gen();
  833.             y = (rand() * rand() * time(NULL) % (num1 + graf->size))* TF_gen();
  834.             name = (rand() * rand() * time(NULL) % (num1 + graf->size))* TF_gen();
  835.             n = insert(graf, name, x, y);
  836.         }
  837.         ++i;
  838.     }
  839.     int k1, k2;
  840.     for (i = 0; i < num2; ) {
  841.         n = 0;
  842.         while (n == 0) {
  843.             k1 = 0;
  844.             k2 = 0;
  845.             while (k1 == 0 || k2 == 0)
  846.             {
  847.                 k1 = rand() * rand() * time(NULL) % graf->size;
  848.                 k2 = rand() * rand() * time(NULL) % graf->size;
  849.             }
  850.             n = add_rib(graf, k1, k2);
  851.         }
  852.         ++i;
  853.     }
  854. }
  855.  
  856. void deleteall(Graf* graf)
  857. {
  858.     int i;
  859.     for (i = 0; i < graf->size; ++i)
  860.     {
  861.         dell_one(graf, i);
  862.         graf->head[i].pred = NULL;
  863.     }
  864.     free(graf->head);
  865.     graf->head = NULL;
  866. }
  867.  
  868. int main() {
  869.     Graf graf = init();
  870.  
  871.     int rc;
  872.     while (rc = dialog(msgs, NMsgs))
  873.         if (!fptr[rc](&graf))
  874.             break;
  875.  
  876.     //if (FileOpenFlag)
  877.         //D_File_out(&graf);
  878.  
  879.     deleteall(&graf);
  880.     return 0;
  881. }
RAW Paste Data
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
 
Top