未插入新值的堆栈推送-C

第一个元素被正确插入，但是当我继续插入元素时，没有一个元素被插入到第一个元素之后。 在某个地方读到，我必须将指针传递给堆栈的指针，但我在一个后缀中缀问题中做了同样的事情，它在那个里工作。 帮我解决这个问题。 非常感谢您提前提供的任何帮助

上一个中缀后缀的示例正在运行

void push(stack *head, int valuee)
{
    if(head->next==NULL && head->value==-1)
    {
        head->value = valuee;
        printf("First element %d inserted\n",valuee);
    }
    else
    {
        stack *temp = new stack;
        temp->value = valuee;
        temp->next = head;
        head = temp;
        printf("Element %d inserted\n",valuee);
    }
}

---

为什么你需要指针到指针

您希望修改指针的内容，因此，如果只向函数传递指针，则该指针是按副本传递的，因此无法实际修改它

---

在中缀前缀的情况下，您必须没有修改字符串，您只能读取它，因此不需要指向指针的指针。

为什么需要指向指针的指针

您希望修改指针的内容，因此，如果只向函数传递指针，则该指针是按副本传递的，因此无法实际修改它

---

在使用中缀前缀的情况下，您必须没有修改字符串，您只能读取它，因此不需要指向指针的指针。

对于

if

语句的

else

部分中的这一行代码：

void push(char c, stack *node)
{
    stack *B = (stack *)malloc(sizeof(stack));
    if (node->next == NULL)
    {
        node->next = B;
        B->value = c;
        B->next =NULL;
    }
    else
    {
        B->next = node->next;
        node->next = B;
        B->value = c;
    }
}

你的意图是变异

头

，换句话说，改变

头

指向的东西。然而，指针是作为值传入的，就像其他变量一样。换句话说，假设我在其他地方调用

push

函数。为简单起见，假设我在

main

函数中调用它，如下所示：

    head = temp;

void push(char c, stack *node)
{
    stack *B = (stack *)malloc(sizeof(stack));
    if (node->next == NULL)
    {
        node->next = B;
        B->value = c;
        B->next =NULL;
    }
    else
    {
        B->next = node->next;
        node->next = B;
        B->value = c;
    }
}

现在，在按下

按钮之后（headOfStack，6）语句已执行，您的目的是希望
headOfStack
指向包含值
6
的新“堆栈节点”。现在，
headOfStack
是指向stack类型变量的指针。它存储一个内存地址。您可以将内存地址视为某个整数。调用
push
时，我们将
headOfStack
的内容（headOfStack

的内容是一个内存地址）复制到

push

函数的局部变量中。因此，当：

int main()
{
    stack *headOfStack = new stack;
    // suppose this next push triggers the else portion of the push code
    push(headOfStack, 6);
}

执行时，我们将

temp

的内容分配给

head

。什么是

temp

？它是指向类型为

stack

的变量的指针。换句话说，

temp

的值是一个内存地址。So<代码>压头=温度只需将

temp

中包含的内存地址分配给本地变量

head

。

push

函数中的局部变量

head

和

main

函数中的

headOfStack

变量是两个完全不同的变量，具有不同的内存地址。如果到目前为止我的解释已经很清楚，这意味着当我们在

push

函数中修改

head

时，

main

中的

headOfStack

变量完全不变

在这种情况下，您要做的是：

head = temp;

以及它的用法，使用我们虚构的

main

函数：

void push(stack **headPtr, int valuee)
{
    // this will get the actual pointer we are interested in
    stack *head = *headPtr;
    if(head->next==NULL && head->value==-1)
    {
        head->value = valuee;
        printf("First element %d inserted\n",valuee);
    }
    else
    {
        stack *temp = new stack;
        temp->value = valuee;
        temp->next = head;
        // mutation is done here
        *headPtr = temp;
        printf("Element %d inserted\n",valuee);
    }
}

只要记住指针存储内存地址，指针只是变量，它们也有内存地址。要改变指针（更改指针指向的对象），只需将其内存地址传递给函数即可

希望有帮助

为有问题的新编辑进行编辑

int main()
{
    stack *headOfStack = new stack;
    // notice the use of &headOfStack instead of headOfStack
    push(&headOfStack, 6);
}

对于此版本的

push

，它所做的基本上是：

如果

node->next==NULL

，则

node

没有后继节点，则将其后继节点设置为新分配的值为

c

否则，

node->next！=NULL

和

节点

有一些后续节点。然后我们将新分配的节点

B

设置为

node

的后续节点，并将

node

的原始后续节点设置为

B

的后续节点。或者换句话说，它在

节点

及其后续节点之间拼接一个新节点

B

（值为

c

）

我发现很难解释这一点，但一个简单的解释是，

push

不会改变

节点所指向的内容。在任何地方，我们都没有表现出变异
节点的意图。我认为涉及
B
的内容应该很容易理解，所以让我们关注
节点->下一个
作业

我假设
堆栈
是一个类似以下内容的结构：

    head = temp;

void push(char c, stack *node)
{
    stack *B = (stack *)malloc(sizeof(stack));
    if (node->next == NULL)
    {
        node->next = B;
        B->value = c;
        B->next =NULL;
    }
    else
    {
        B->next = node->next;
        node->next = B;
        B->value = c;
    }
}

现在，假设在我们的
main
函数中有一个
堆栈
：

struct stack {
    char value;
    struct stack *next;
};

请注意，
x
不是指针。我想我们都同意，做
x.value=something
和
x.next=something
会改变这些字段

现在，让我们看看这个：

stack x;

我们知道
y
将地址存储到实际的
结构堆栈
（实际的
结构堆栈
位于
*y
）。所以
y->value=something
和
y->next=something
将对这些字段进行变异

因此，希望您能够了解
节点->值
赋值工作的原因。本质上，
节点
包含实际
结构堆栈
的地址，其值为
*节点
。根据指针语法，
node->value
和
node->next
赋值将更改
node
的内容

我知道这不是一个很好的解释。但只需编写更多代码。当我第一次开始使用C时，指针把我弄糊涂了。我想现在，我仍然会被2到3层的间接寻址弄糊涂，我遇到了一些非常讨厌的指针错误。只要多练习。。。总有一天你会得到它的。我知道他们都这么说，但这是真的。
对于
if
语句的
else
部分中的这行代码：

void push(char c, stack *node)
{
    stack *B = (stack *)malloc(sizeof(stack));
    if (node->next == NULL)
    {
        node->next = B;
        B->value = c;
        B->next =NULL;
    }
    else
    {
        B->next = node->next;
        node->next = B;
        B->value = c;
    }
}

你的意图是变异