使用静态数组C的动态堆栈

我一直在做书本上的练习。我被困在这个问题的意义上。假设您在stac上存储整数值，并且使用静态数组存储数据提供createStack（）deleteStack（堆栈）方法

我的解释是

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;

---

我知道这些不是方法。但是我想知道我是否走对了这条路，我想你走对了——只是说几句话

在

Stacklist

中，我不明白为什么会有指向堆栈中两个节点的指针。 通常，堆栈只保留对堆栈顶部项目的引用。 此外，它们要么保留堆栈有多大的计数器，要么在堆栈底部保留指向节点的指针（这可能就是您所说的

头节点

，并通过

当前节点

？）引用头节点）

当你创建这些结构时，别忘了初始化所有东西：p通常会在无尽的头痛中结束

---

继续做好工作。

如果您使用静态数组作为值，那么您在技术上不需要

createStack（）

和

deleteStack（）

函数，因为您只需在堆栈上创建

struct stack

或其他任何函数（双关语）就可以了

但是，如果您确实想要（并且您可能合法地想要，例如，为了避免显式初始化

top

，或者为了将实现隐藏在不透明类型后面，或者为了能够在不复制可能较大的数组的情况下从函数返回一个实现），可以这样做：

#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;
}

#包括
#包括
#定义堆栈大小50
类型定义结构堆栈*堆栈；
结构堆栈{
顶部尺寸；
int值[STACKSIZE]；
};
堆栈createStack（空）
{
Stack new_Stack=malloc（sizeof*new_Stack）；
如果（！新建_堆栈）{
perror（“无法分配内存”）；
退出（退出失败）；
}
新建_堆栈->顶部=0；
返回新的_堆栈；
}
void deleteStack（堆栈）
{
自由（堆叠）；
}
无效推送（堆栈，常量int n）
{
如果（堆栈->顶部<堆栈大小）{
堆栈->值[堆栈->顶部+]=n；
}
否则{
fprintf（stderr，“堆栈已满-正在退出。\n”）；
退出（退出失败）；
}
}
int-pop（堆栈）
{
如果（堆栈->顶部>0）{
返回堆栈->值[--stack->top]；
}
否则{
fprintf（stderr，“堆栈为空-正在退出。\n”）；
退出（退出失败）；
}
}
内部主（空）
{
Stack mystack=createStack（）；
推（mystack，3）；
推（mystack，1）；
推（mystack，4）；
推（mystack，1）；
推（mystack，5）；
对于（尺寸i=0；i<5；++i）{
printf（“从堆栈中弹出%d。\n”，弹出（mystack））；
}
deleteStack（mystack）；
返回0；
}

---

现在，您似乎想要在静态数组中包含值的堆栈，但随后开始为节点和列表定义结构，就好像您想要链表实现一样。这两种实现明显不同。

只有一个问题。为什么要返回新的_堆栈，是否可以使用void和没有返回类型来实现此功能？不，如果函数没有返回类型，则不能返回任何内容。您必须创建一个指针，然后将其地址传递到

createStack（）

函数中，这是可能的，但考虑到上面的替代方案，这是不必要的复杂。很好，我现在对堆栈有了更好的理解。