SHARE
TWEET

Untitled

a guest Mar 18th, 2019 62 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdio.h>
  2.     #include <stdlib.h>
  3.     #include <stdbool.h>
  4.     #include <string.h>
  5.  
  6.     #define NAME_SIZE   256
  7.  
  8.     int ml_bits = 0, fr_bits = 0;
  9.     int ml_amount = 0, fr_amount = 0;
  10.  
  11.     // structure for one node in the linked list
  12.     typedef struct node_struct {
  13.         int age;
  14.         char name[NAME_SIZE];
  15.         struct node_struct *next;
  16.         struct node_struct *prev;
  17.     } Node;
  18.  
  19.     // enumerated type for valid operations
  20.     typedef enum operation_enum {
  21.         NEW = 1, FIND, DISPLAY_ASC, DISPLAY_DESC, DELETE_LAST, SHOW_MEMORY, QUIT
  22.     } Operation;
  23.  
  24.     //
  25.     // function prototypes for the functions the students need to create
  26.     //
  27.  
  28.     void insert_node(Node **head_ptr, Node *node){
  29.         system("cls");
  30.  
  31.         Node *current = *head_ptr;
  32.         node->next = NULL;
  33.         if (current == NULL){
  34.             printf("(Node Inserted)n");
  35.             node->prev = NULL;
  36.             *head_ptr = node;
  37.         }
  38.         else{
  39.             while (current->next != NULL){
  40.                 current = current->next;
  41.             }
  42.             printf("(Not First)(Node Inserted)n");
  43.             current->next = node;
  44.             node->prev = current;
  45.         }
  46.     }
  47.  
  48.     Node *find_node(Node *head, const int age){
  49.         while (head != NULL){
  50.             if (head->age == age){
  51.                 return head;
  52.             }
  53.             head = head->next;
  54.         }
  55.         system("cls");
  56.         printf("Your node not foundn");
  57.         return 0;
  58.     }
  59.     void display_node(Node *node){
  60.         system("cls");
  61.         printf("(Found node)n");
  62.         printf("Name: %sAge: %dn", node->name, node->age);
  63.         printf("(Found node)n");
  64.     }
  65.     void display_reverse(Node* head){
  66.         Node *temp = head;
  67.         if (temp == NULL){
  68.             return;
  69.         }
  70.         while (temp->next != NULL){
  71.             temp = temp->next;
  72.         }
  73.         while (temp != NULL){
  74.             printf("nName: %sAge: %dn", temp->name, temp->age);
  75.             temp = temp->prev;
  76.         }
  77.     }
  78.  
  79.     void display_list(Node *head, Operation op){
  80.         system("cls");
  81.         switch(op){
  82.             case DISPLAY_DESC:
  83.                 printf("(Display reverse)");
  84.                 display_reverse(head);
  85.                 printf("(Display reverse)n");
  86.                 break;
  87.             case DISPLAY_ASC:
  88.                 printf("(Display ascending)");
  89.                 while (head != NULL){
  90.                     printf("nName: %sAge: %dn", head->name, head->age);
  91.                     head = head->next;
  92.                 }
  93.                 printf("(Display ascending)n");
  94.                 break;
  95.         }
  96.     }
  97.  
  98.     void show_memory(){
  99.         system("cls");
  100.         printf("(Malloc)n");
  101.         printf("Currently used memory in bits: %dnCurrently used amount of memory: %dn", ml_bits, ml_amount);
  102.  
  103.         printf("n(Free)n");
  104.         printf("Deleted memory in bits: %dnDeleted memory in amount: %dnn", fr_bits, fr_amount);
  105.     }
  106.  
  107.     void Memory_up(Node* temp){
  108.         ml_bits = ml_bits + (sizeof(temp));
  109.         ml_amount++;
  110.     }
  111.  
  112.     void Memory_down(Node *temp){
  113.         fr_amount++;
  114.         fr_bits = fr_bits + sizeof(temp);
  115.         ml_amount--;
  116.         ml_bits = ml_bits - sizeof(temp);
  117.     }
  118.  
  119.     void delete_last(Node *head){
  120.         system("cls");
  121.         Node *temp = head;
  122.         if (head == NULL){
  123.             printf("Empty listn");
  124.         }
  125.         else if (head->next == NULL){
  126.             head = head->next;
  127.             free(temp);
  128.             printf("deleted_name: %sdeleted_age: %dn", temp->name, temp->age);
  129.         }
  130.         else{
  131.             printf("(Delete last)n");
  132.             while (temp->next->next != NULL){
  133.                 temp = temp->next;
  134.             }
  135.             Memory_down(temp->next);
  136.             printf("deleted_name: %sdeleted_age: %dn", temp->next->name, temp->next->age);
  137.             free(temp->next);
  138.             temp->next = NULL;
  139.         }
  140.     }
  141.     /*
  142.      * Create a new node.  The "next" member is initialized to NULL, other members are
  143.      * set according to the parameters.
  144.      *
  145.      * Parameters:
  146.      *      in: age - the value to store in the age field of the node
  147.      *      in: name - the name to store in the name field of the node
  148.      *
  149.      * Returns a pointer to a Node.  Node.next is intialized to NULL
  150.      */
  151.     Node *new_node(const int age, const char *name)
  152.     {
  153.         Node *new = (Node *)malloc(sizeof(Node));
  154.         if (!new) {
  155.             fprintf(stderr, "Unable to allocate memory for new noden");
  156.             return NULL;
  157.         }
  158.  
  159.         new->age = age;
  160.         strncpy(new->name, name, NAME_SIZE);
  161.         new->next = NULL;
  162.         Memory_up(new);
  163.         return new;
  164.     }
  165.  
  166.     /*
  167.      * Get user input including an operation and data associated with that operation, if any.
  168.      *
  169.      * Parameters:
  170.      *      out: operation - the operation the user wants
  171.      *      out: age if the operation was insert or find, else undefined
  172.      *      out: name if the operation was insert or find, else undefined
  173.      *
  174.      * The name parameter must be a pointer to memory sufficiently large to hold NAME_SIZE
  175.      * characters (including null character at the end).
  176.      *
  177.      * Returns: false if success, else true
  178.      */
  179.     bool get_operation(Operation *operation, int *age, char *name)
  180.     {
  181.         const char prompt[] = "Enter an option:nt1) Add nodent2) Find nodent3) display ascendingnt4) display descendingnt5) delete lastnt6) show memorynt7) Quitn-> ";
  182.         char input[NAME_SIZE];
  183.  
  184.         bool invalid_operation = true;
  185.         while (invalid_operation) {
  186.  
  187.             fprintf(stdout, prompt);
  188.  
  189.             // get the option number from the user's input
  190.             int op;
  191.             if (fgets(input, NAME_SIZE, stdin) && sscanf(input, "%d", &op) == 1) {
  192.                 *operation = op;
  193.                 switch(op) {
  194.                     case NEW:
  195.                         // Need both age and name
  196.                         fprintf(stdout, "Age: ");
  197.                         if (!fgets(input, NAME_SIZE, stdin) || sscanf(input, "%d", age) != 1) {
  198.                             system("cls");
  199.                             fprintf(stdout, "Age must be an integern");
  200.                             break;
  201.                         }
  202.                         fprintf(stdout, "Name: ");
  203.                         if (!fgets(name, NAME_SIZE, stdin)) {
  204.                             system("cls");
  205.                             fprintf(stderr, "Error reading name from stdinn");
  206.                             break;
  207.                         }
  208.                         invalid_operation = false;
  209.                         break;
  210.  
  211.                     case FIND:
  212.                         // Only need age
  213.                         fprintf(stdout, "Age: ");
  214.                         if (!fgets(input, NAME_SIZE, stdin) || sscanf(input, "%d", age) != 1) {
  215.                             system("cls");
  216.                             fprintf(stdout, "Age must be an integern");
  217.                             break;
  218.                         }
  219.                         invalid_operation = false;
  220.                         break;
  221.  
  222.                     case DISPLAY_ASC:
  223.                     case DISPLAY_DESC:
  224.                         // no additional information needed
  225.                         invalid_operation = false;
  226.                         break;
  227.                     case DELETE_LAST:
  228.                         invalid_operation = false;
  229.                         break;
  230.                     case SHOW_MEMORY:
  231.                         invalid_operation = false;
  232.                         break;
  233.                     case QUIT:
  234.                         return true;
  235.  
  236.                     default:
  237.                         system("cls");
  238.                         fprintf(stdout, "Invalid optionnn");
  239.                         break;
  240.                 } // end switch
  241.             } else {
  242.                 system("cls");
  243.                 fprintf(stdout, "Invalid optionn");
  244.             }
  245.         } // end while
  246.  
  247.         return false;
  248.     }
  249.  
  250.     /*
  251.      * Repeatedly prompt the user for an operation and perform the operation.
  252.      *
  253.      * Parameters: n/a
  254.      *
  255.      * Returns:
  256.      *      0 on success, else 1
  257.      */
  258.     void main(){
  259.         Node *head = NULL;      // pointer to the first node in the linked list
  260.         Node *node;
  261.         Operation op;
  262.         int age;
  263.         char name[NAME_SIZE];
  264.  
  265.         while (!get_operation(&op, &age, name)) {
  266.  
  267.             switch(op) {
  268.                 case NEW:
  269.                     // Create a new node and insert it into the list
  270.                     node = new_node(age, name);
  271.                     insert_node(&head, node);
  272.                     break;
  273.  
  274.                 case FIND:
  275.                     // Display all nodes containing the specified age
  276.                     node = find_node(head, age);
  277.                     while(node && node->age == age) {
  278.                         display_node(node);
  279.                         node = node->next;
  280.                     }
  281.                     break;
  282.  
  283.                 case DISPLAY_ASC:
  284.                     display_list(head, op);
  285.                     break;
  286.                 case DISPLAY_DESC:
  287.                     // Display the entire linked list in the specified order
  288.                     display_list(head, op);
  289.                     break;
  290.                 case DELETE_LAST:
  291.                     delete_last(head);
  292.                     break;
  293.                 case SHOW_MEMORY:
  294.                     show_memory();
  295.                     break;
  296.                 case QUIT:
  297.                     return 0;
  298.  
  299.                 default: break;// don't need, but here to avoid compiler warning
  300.             } // end switch
  301.         } // end while
  302.  
  303.         // if we get here, it's because there was an error reading input
  304.         return 1;
  305.     }
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