193030

DR 6.1 Za predavane

Nov 28th, 2021
611
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. struct node2
  5. {
  6.     void* data;
  7.     struct node2* one;
  8.     struct node2* two;
  9. };
  10.  
  11. struct node1 {
  12.     void* data;
  13.     struct node1* next;
  14. };
  15.  
  16. void prnint(void* p)
  17. {
  18.     printf("%d ", *(int*)p);
  19. }
  20.  
  21. struct node2* newNode(int data)
  22. {
  23.     void* p = malloc(sizeof(data));
  24.     *(int*)p = data;
  25.     struct node2* t = (struct node2*)malloc(sizeof(struct node2));
  26.     t->data = p;
  27.     t->one = NULL;
  28.     t->two = NULL;
  29.     return t;
  30. }
  31.  
  32. void printList(struct node2* p)
  33. {
  34.     static struct node2* root;
  35.     if (root == NULL)
  36.         root = p;
  37.     while (p != NULL)
  38.     {
  39.         prnint(p->data);
  40.         p = p->two;
  41.         if (p == root) // Възлите на списъка започват да се повтарят
  42.             break;
  43.     }
  44. }
  45.  
  46.  
  47. void display(struct node1** head)
  48. {
  49.     struct node1* t = *head;
  50.     do {
  51.         prnint(t->data);
  52.         t = t->next;
  53.     } while (t != *head);
  54. }
  55.  
  56. void add1(void* data, struct node1** head)
  57. {
  58.     struct node1* p = *head;
  59.     if (p == NULL)
  60.     {
  61.         p = (struct node1*)malloc(sizeof(struct node1));
  62.         p->data = data;
  63.         p->next = NULL;
  64.         *head = p;
  65.         return;
  66.     }
  67.     else
  68.     {
  69.         while (p->next)
  70.             p = p->next;
  71.         struct node1* t = (struct node1*)malloc(sizeof(struct node1));
  72.         t->data = data;
  73.         t->next = NULL;
  74.         p->next = t;
  75.     }
  76. }
  77.  
  78. void preorder(struct node2* p, struct node1** listHead)
  79. {
  80.     if (!p)
  81.         return;
  82.     add1(p->data, listHead);
  83.     preorder(p->one, listHead);
  84.     preorder(p->two, listHead);
  85. }
  86.  
  87. void postorder(struct node2* p, struct node1** listHead)
  88. {
  89.     if (!p)
  90.         return;
  91.     postorder(p->one, listHead);
  92.     postorder(p->two, listHead);
  93.     add1(p->data, listHead);
  94. }
  95.  
  96. void postorderToLL(struct node2* p, struct node1** listHead)
  97. {
  98.     postorder(p, listHead);
  99.     struct node1* t = *listHead;
  100.     while (t->next != NULL)
  101.         t = t->next;
  102.     t->next = *listHead;
  103. }
  104.  
  105. void preorderToLL(struct node2* p, struct node1** listHead)
  106. {
  107.     preorder(p, listHead);
  108.     struct node1* t = *listHead;
  109.     while (t->next != NULL)
  110.         t = t->next;
  111.     t->next = *listHead;
  112. }
  113.  
  114.  
  115. int main()
  116. {
  117.     struct node1* listHead = NULL;
  118.     struct node2* root = newNode(2);
  119.     root->one = newNode(4);
  120.     root->two = newNode(19);
  121.     root->one->one = newNode(7);
  122.     root->one->two = newNode(10);
  123.     root->two->one = newNode(22);
  124.     /*
  125.      *          2
  126.      *        /   \
  127.      *       4     19
  128.      *      / \   /
  129.      *     7  10 22
  130.      *     prefix - 2 4 7 10 19 22
  131.      *     postfix - 7 10 4 22 19 2
  132.      *     infix - 7 4 10 2 22 19
  133.      */
  134.     postorderToLL(root, &listHead);
  135.     display(&listHead);
  136.     putchar('\n');
  137.  
  138.     listHead = NULL;
  139.     preorderToLL(root, &listHead);
  140.     display(&listHead);
  141. }
RAW Paste Data