Advertisement
Guest User

Untitled

a guest
May 22nd, 2019
91
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 16.87 KB | None | 0 0
  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. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement