具有静态数组C的动态堆栈

Question

I have been doing excercises from a book. And I am stuck on the meaning of this qustion. Assuming that you store integer values on the stac and that using a static array to store data provide a createStack() deleteStack(stack) methods.

My interpretation is

typedef struct {
  int values;
  char data[50];

} StackData;

typedef struct n {
  StackData d; // store some data in node
  struct n *successor; // store successor of node
  // as typedef is not yet completed
  // name StackNode cannot be used
} SatckNode;


typedef struct {
  StackNode *head;
  StackNode *current;
} Stacklist;

I know these arent the methods. But i want to know if I am going about it the right way

Answer 1

I think you're on the right way - just a couple of comments.

In Stacklist , I don't get why you have pointers to two of the nodes in the stack. Usually, stacks only keep a reference to the item on the top of the stack. In addition, they either keep a counter of how big is the stack, or a pointer to the node on the bottom of the stack (which is what you probably mean by head , and reference the head node by current ?).

And don't forget to initialize everything whenever you create any of those structures :P usually ends up in endless hours of headache.

Keep up the good work.

Answer 2

If you're using a static array for the values, then you don't technically need createStack() and deleteStack() functions, because you can just create a struct stack or whatever on the stack (pun intended) and you're done.

If you do want to, though, (and you might legitimately want to, eg to avoid having to explicitly initialize top , or to hide the implementation behind an opaque type, or to be able to return one from a function without copying a potentially large array) this'll do it:

#include <stdio.h>
#include <stdlib.h>

#define STACKSIZE 50

typedef struct stack * Stack;

struct stack {
    size_t top;
    int values[STACKSIZE];
};

Stack createStack(void)
{
    Stack new_stack = malloc(sizeof *new_stack);
    if ( !new_stack ) {
        perror("couldn't allocate memory");
        exit(EXIT_FAILURE);
    }
    new_stack->top = 0;
    return new_stack;
}

void deleteStack(Stack stack)
{
    free(stack);
}

void push(Stack stack, const int n)
{
    if ( stack->top < STACKSIZE ) {
        stack->values[stack->top++] = n;
    }
    else {
        fprintf(stderr, "Stack full - exiting.\n");
        exit(EXIT_FAILURE);
    }
}

int pop(Stack stack)
{
    if ( stack->top > 0 ) {
        return stack->values[--stack->top];
    }
    else {
        fprintf(stderr, "Stack empty - exiting.\n");
        exit(EXIT_FAILURE);
    }
}

int main(void)
{
    Stack mystack = createStack();

    push(mystack, 3);
    push(mystack, 1);
    push(mystack, 4);
    push(mystack, 1);
    push(mystack, 5);

    for ( size_t i = 0; i < 5; ++i ) {
        printf("Popped %d from stack.\n", pop(mystack));
    }

    deleteStack(mystack);

    return 0;
}

Right now you seem to want a stack with values in a static array, but then you start defining structs for nodes and lists, as if you want a linked list implementation. The two implementations are obviously pretty different.