Paste Search Dynamic
Recent pastes
freeLinkedList
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <assert.h>
  4. //#include "DuLinkList.h"
  5. typedef struct link_list
  6. {
  7.     int data;
  8.     struct link_list *pre;
  9.     struct link_list *next;
  10. } node;
  11.  
  12. // add a node on a previous node
  13. node *add_node(node *prenode, int data)
  14. {
  15.     // allocate the memory for new node and return its position
  16.     if (prenode == null)
  17.     {
  18.         prenode = (node *)malloc(sizeof(node));
  19.         prenode->data = data;
  20.         prenode->next = null;
  21.         prenode->pre = null;
  22.         return prenode;
  23.     }
  24.     prenode->next = (node *)malloc(sizeof(node));
  25.     node *newnode = prenode->next;
  26.     newnode->data = data;
  27.     newnode->pre = prenode;
  28.     newnode->next = null;
  29.     return newnode;
  30. }
  31.  
  32. void freeLinkedList(node *head)
  33. {
  34.     while (head != null)
  35.     {
  36.         node *next = head->next;
  37.         free(head);
  38.         head = next;
  39.     }
  40.     printf("Memory has been freedn");
  41. }
  42.  
  43. void print_ListNode_head(node *head)
  44. {
  45.     node *now = head;
  46.     while (now != null)
  47.     {
  48.         printf("%d ", now->data);
  49.         now = now->next;
  50.     }
  51.     printf("n");
  52. }
  53.  
  54. void print_ListNode_last(node *last)
  55. {
  56.     node *now = last;
  57.     while (now != null)
  58.     {
  59.         printf("%d ", now->data);
  60.         now = now->pre;
  61.     }
  62.     printf("n");
  63. }
  64.  
  65. // return the position of new node
  66. node *insert_ListNode_bySorted(node **head, int new_data, node **last)
  67. {
  68.     node *now = *head;
  69.     if (*head == null)
  70.     {
  71.         *head = (node *)malloc(sizeof(node));
  72.         (*head)->data = new_data;
  73.         (*head)->next = null;
  74.         (*head)->pre = null;
  75.         *last = *head;
  76.         return *head;
  77.     }
  78.     if (now->data > new_data)
  79.     {
  80.         node *newhead = (node *)malloc(sizeof(node));
  81.         newhead->data = new_data;
  82.         newhead->pre = null;
  83.         newhead->next = *head;
  84.         now->pre = newhead;
  85.         *head = newhead;
  86.         node *temp = *head;
  87.         while (temp->next != null)
  88.             temp = temp->next;
  89.         *last = temp;
  90.         return *head;
  91.     }
  92.     while (1)
  93.     {
  94.         if (now->next == null)
  95.         {
  96.             if (now->pre == null)
  97.             {
  98.                 if (new_data > now->data)
  99.                 {
  100.                     now->next = (node *)malloc(sizeof(node));
  101.                     now = now->next;
  102.                     now->data = new_data;
  103.                     now->pre = *last;
  104.                     now->next = null;
  105.                     *last = now;
  106.                     node *temp = *head;
  107.                     while (temp->next != null)
  108.                         temp = temp->next;
  109.                     *last = temp;
  110.                     return *last;
  111.                 }
  112.                 else
  113.                 {
  114.                     now->pre = (node *)malloc(sizeof(node));
  115.                     now = now->pre;
  116.                     now->data = new_data;
  117.                     now->next = *head;
  118.                     now->pre = null;
  119.  
  120.                     *head = now;
  121.                     node *temp = *head;
  122.                     while (temp->next != null)
  123.                         temp = temp->next;
  124.                     *last = temp;
  125.                     return *last;
  126.                 }
  127.             }
  128.             now->next = (node *)malloc(sizeof(node));
  129.             now = now->next;
  130.             now->data = new_data;
  131.             now->pre = *last;
  132.             now->next = null;
  133.             *last = now;
  134.             return *last;
  135.         }
  136.         if (new_data < now->next->data)
  137.         {
  138.             node *temp = (node *)malloc(sizeof(node));
  139.             temp->data = new_data;
  140.             temp->pre = now;
  141.             temp->next = now->next;
  142.             now->next = temp;
  143.             temp->next->pre = temp;
  144.             node *t = *head;
  145.             while (t->next != null)
  146.                 t = t->next;
  147.             *last = t;
  148.             return temp;
  149.         }
  150.         now = now->next;
  151.     }
  152. }
  153. int main()
  154. {
  155.     int part1, new;
  156.  
  157.     scanf("%d", &part1);
  158.     scanf("%d", &new);
  159.     node *head = add_node(null, new);
  160.     node *ptr = head;
  161.     for (int i = 1; i < 10; i++)
  162.     {
  163.         scanf("%d", &new);
  164.         add_node(ptr, new);
  165.         ptr = ptr->next;
  166.     }
  167.     node *last = ptr;
  168.  
  169.     // print from head
  170.     printf("print from headn");
  171.     print_ListNode_head(head);
  172.  
  173.     // print from last
  174.     printf("print from lastn");
  175.     print_ListNode_last(last);
  176.  
  177.     // free linked list
  178.     freeLinkedList(head);
  179.  
  180.     // only run part1
  181.     if (part1 == 1)
  182.     {
  183.         return 0;
  184.     }
  185.     // add numbers into linked list
  186.     int num;
  187.     scanf("%d", &num);
  188.     head = null;
  189.     last = null;
  190.     for (int i = 0; i < num; i++)
  191.     {
  192.         scanf("%d", &new);
  193.         insert_ListNode_bySorted(&head, new, &last);
  194.     }
  195.     print_ListNode_head(head);
  196.     print_ListNode_last(last);
  197.     freeLinkedList(head);
  198.  
  199.     return 0;
  200. }
Parsed in 0.024 seconds