193030

DR 6.2 Binary tree to linked list Whole code

Nov 28th, 2021 (edited)
60
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 2.99 KB | None
  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.  
  17. void prnint(void* p)
  18. {
  19.     printf("%d ", *(int*)p);
  20. }
  21.  
  22. struct node2* newNode(int data)
  23. {
  24.     void* p = malloc(sizeof(data));
  25.     *(int*)p = data;
  26.     struct node2* t = (struct node2*)malloc(sizeof(struct node2));
  27.     t->data = p;
  28.     t->one = NULL;
  29.     t->two = NULL;
  30.     return t;
  31. }
  32.  
  33. void printList(struct node2* p)
  34. {
  35.     //printf("\n");
  36.     static struct node2* root;
  37.     if (root == NULL)
  38.         root = p;
  39.     while (p != NULL)
  40.     {
  41.         prnint(p->data);
  42.         p = p->two;
  43.         if (p == root) // Възлите на цикъла започват да се повтарят
  44.             break;
  45.     }
  46. }
  47.  
  48.  
  49.  
  50. void display(struct node1** head)
  51. {
  52.     struct node1* t = *head;
  53.     do {
  54.         prnint(t->data);
  55.         t = t->next;
  56.     } while (t != *head);
  57. }
  58.  
  59. void add1(void* data, struct node1** head)
  60. {
  61.     struct node1* p = *head;
  62.     if (p == NULL)
  63.     {
  64.         p = (struct node1*)malloc(sizeof(struct node1));
  65.         p->data = data;
  66.         p->next = NULL;
  67.         *head = p;
  68.         return;
  69.     }
  70.     else
  71.     {
  72.         while (p->next)
  73.             p = p->next;
  74.         struct node1* t = (struct node1*)malloc(sizeof(struct node1));
  75.         t->data = data;
  76.         t->next = NULL;
  77.         p->next = t;
  78.     }
  79. }
  80.  
  81. //void add2(void* data, struct node1** head)
  82. //{
  83. //  struct node1* p = (struct node1*)malloc(sizeof(struct node1));
  84. //  p->data = data;
  85. //  if (head != NULL)
  86. //      p->next = *head;
  87. //  else
  88. //      p->next = NULL;
  89. //  *head = p;
  90. //}
  91.  
  92. void preorder(struct node2* p, struct node1** listHead)
  93. {
  94.     if (!p)
  95.         return;
  96.     add1(p->data, listHead);
  97.     preorder(p->one, listHead);
  98.     preorder(p->two, listHead);
  99. }
  100.  
  101. void postorder(struct node2* p, struct node1** listHead)
  102. {
  103.     if (!p)
  104.         return;
  105.     postorder(p->one, listHead);
  106.     postorder(p->two, listHead);
  107.     add1(p->data, listHead);
  108. }
  109.  
  110.  
  111. void postorderPrint(struct node2* p)
  112. {
  113.     if (!p)
  114.         return;
  115.     postorderPrint(p->one);
  116.     postorderPrint(p->two);
  117.     prnint(p->data);
  118.  
  119. }
  120. void preorderPrint(struct node2* p)
  121. {
  122.     if (!p)
  123.         return;
  124.     prnint(p->data);
  125.     preorderPrint(p->one);
  126.     preorderPrint(p->two);
  127. }
  128.  
  129.  
  130. void postorderFUN(struct node2* p, struct node1** listHead)
  131. {
  132.     postorder(p, listHead);
  133.     struct node1* t = *listHead;
  134.     while (t->next != NULL)
  135.         t = t->next;
  136.     t->next = *listHead;
  137.     putchar('\n');
  138. }
  139.  
  140.  
  141. void preorderFUN(struct node2* p, struct node1** listHead)
  142. {
  143.     preorder(p, listHead);
  144.     struct node1* t = *listHead;
  145.     while (t->next != NULL)
  146.         t = t->next;
  147.     t->next = *listHead;
  148.     putchar('\n');
  149. }
  150.  
  151.  
  152.  
  153.  
  154. int main()
  155. {
  156.     struct node1* listHead = NULL;
  157.  
  158.     struct node2* root = newNode(2);
  159.     root->one = newNode(4);
  160.     root->two = newNode(19);
  161.     root->one->one = newNode(7);
  162.     root->one->two = newNode(10);
  163.     root->two->one = newNode(22);
  164.     /*
  165.      *          2
  166.      *        /   \
  167.      *       4     19
  168.      *      / \   /
  169.      *     7  10 22
  170.      */
  171.     postorderPrint(root);
  172.     postorderFUN(root, &listHead);
  173.     display(&listHead);
  174.     listHead = NULL;
  175.     preorderPrint(root);
  176.     preorderFUN(root, &listHead);
  177.     display(&listHead);
  178. }
RAW Paste Data Copied