Question

In C, Implement each of the functions to create a working stack

6 II-Implement each of the functions to create a working stack. 7 II -Do not change any of the function declarations I-(i.e. stack t* create stack) should not have additional arguments) II-You should not have any 'printf' statements in your stack functions 10 II(You may consider using these printf statements to debug, but they should be removed from your final version) 12 #ifndefMYSTACK_A 13 #define MYSTACKH 14 15 I/ Stores the maximum "depth' of our stack. 16 I/Our implementation enforces a maximum depth of our stack. 17 II (i.e. capacity cannot exceed MAX_DEPTH for any stack) 18 # define MAXDEPTH 32 19 20 II Create a node data structure to store data within 21 1I our stack. In our case, we will stores integers 22 typedef struct nodet 23 24 25 node t; 26 27 // Create a stack data structure 28 II Our stack holds a single pointer to a node, which 9 I1 is a linked list of nodes. 30 typedef struct stackf 31 32 - int data struct node* next; int count; // count keeps track of how many items // are in the stack. unsigned int capacity; // Stores the maximum size of our stack node t* head; 34 35 stack_t; 36 37 II Creates a stack 38 //Returns a pointer to a newly created stack. 39 II The stack should be initialized with data on the heap. 0 11 (Think about what the means in terms of memory allocation) 41 / The stacks fields should also be initialized to default values. 42 stack t* create_stack (unsigned int capacity) 43 // head points to a node on the top of our stack. // Modify the body of this function as needed stack-t* myStack = NULL; 45 46 47 return myStack;

Answer 1

stack_t* create_stack(unsigned int capacity) {
    stack_t* myStack = (stack_t*) malloc(sizeof(stack_t));
    myStack->capacity = capacity;
    myStack->count = 0;
    myStack->head = NULL;
    return myStack;
}

int stack_empty(stack_t* s) {
    return (s->head == NULL) || (s->count == 0):
}

int stack_full(stack_t* s) {
    return (s->head != NULL) && (s->count == s->capacity):
}


int stack_enqueue(stack_t* s, int item) {
    if(stack_full(s)) {
        return -1;
    }
    node_t *newNode = (node_t *) malloc(sizeof(node_t));
    newNode->data = item;
    newNode->next = s->head;
    s->head = newNode;
    s->count += 1;
    return 0:
}

int stack_dequeue(stack_t* s) {
    if(stack_empty(s)) {
        exit(1);
    }

    int x = s->head->data;

    node_t *node = s->head;

    s->head = s->head->next;
    s->count -= 1;

    free(node);

    return x:
}

unsigned int stack_size(stack_t* s) {   
    return s->count;
}

void free_stack(stack_t* s) {   
    while(!stack_empty(s)) {
        stack_dequeue(s);
    }
}

Please upvote, as i have given the exact answer as asked in question. Still in case of any concerns in code, let me know in comments. Thanks!