Question

我有以下实现来镜像二叉树。

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

/* A binary tree node has data, pointer to left child
   and a pointer to right child */
struct node
{
    int data;
    struct node* left;
    struct node* right;
};

/* Helper function that allocates a new node with the
   given data and NULL left and right pointers. */
struct node* newNode(int data)

{
  struct node* node = (struct node*)
                       malloc(sizeof(struct node));
  node->data = data;
  node->left = NULL;
  node->right = NULL;

  return(node);
}


/* Change a tree so that the roles of the  left and
    right pointers are swapped at every node.

 So the tree...
       4
      / \
     2   5
    / \
   1   3

 is changed to...
       4
      / \
     5   2
        / \
       3   1
*/
void mirror(struct node* node)
{
  if (node==NULL)
    return; 
  else
  {
    struct node* temp;

    /* do the subtrees */
    mirror(node->left);
    mirror(node->right);

    /* swap the pointers in this node */
    temp        = node->left;
    node->left  = node->right;
    node->right = temp;
  }
}


/* Helper function to test mirror(). Given a binary
   search tree, print out its data elements in
   increasing sorted order.*/
void inOrder(struct node* node)
{
  if (node == NULL)
    return;

  inOrder(node->left);
  printf("%d ", node->data);

  inOrder(node->right);
} 


/* Driver program to test mirror() */
int main()
{
  struct node *root = newNode(1);
  root->left        = newNode(2);
  root->right       = newNode(3);
  root->left->left  = newNode(4);
  root->left->right = newNode(5);

  /* Print inorder traversal of the input tree */
  printf("\n Inorder traversal of the constructed tree is \n");
  inOrder(root);

  /* Convert tree to its mirror */
  mirror(root);

  /* Print inorder traversal of the mirror tree */
  printf("\n Inorder traversal of the mirror tree is \n"); 
  inOrder(root);

  getchar();
  return 0; 
}

我说的是以下几行：

  struct node* node = (struct node*)
                       malloc(sizeof(struct node));

我对c / c ++有中级知识，但我非常害怕指针。即使经过几次尝试，我也无法获得指针。我尽可能地避免它们，但是当实现像树这样的数据结构时，没有其他选择。为什么我们在这里使用malloc和sizeof？另外我们为什么要转换（struct node *）？

Answer 1

首先在C中使用malloc时不需要进行转换。（见here）

您正在进行mallocing，因为您正在分配节点结构大小的堆内存。你在C中看到，你必须记住所有变量的存储位置。即stack和heap（请参阅here）

在函数内部，您的变量被称为局部变量，它存储在stack中。离开函数后，清除堆栈中的变量。

为了能够在函数之外引用或使用局部变量，你必须在heap中分配内存，这就是你在这里所做的。您正在堆中分配内存，以便您也可以在其他函数中重用相同的变量。

总结：

函数中的变量是函数的本地变量，因此术语局部变量
对于访问本地变量的其他功能，您必须在堆中分配内存以与其他函数共享该变量。

为了举例说明原因，请考虑以下代码：

#include <stdio.h>
#include <string.h>

char *some_string_func()
{
    char some_str[13]; /* 12 chars (for "Hello World!") + 1 null '\0' char */

    strcpy(some_str, "Hello World!");

    return some_str;
}

int main()
{
    printf("%s\n", some_string_func());
    return 0;
}

非常简单，main只是调用一个返回局部变量some_str_func的函数some_str，编译上面的代码会起作用，但不是没有警告：

test.c: In function ‘some_string_func’:
test.c:11:9: warning: function returns address of local variable [enabled by default]

虽然它编译说明some_str中的some_str_func() 将返回到函数的本地变量（即在函数的堆栈中）。由于一旦你离开函数some_str_func()就清除了堆栈，在main()中，不可能来获取some_str的内容，即“Hello World”

如果你试图运行它，你会得到：

$ gcc test.c
$ ./a.out

$

它不打印任何内容，因为它无法访问some_str。为了解决这个问题，你可以为字符串“Hello World”分配一些内存空间。像这样：

#include <stdio.h>
#include <string.h>

char *some_string_func()
{
    char *some_str;

    /* allocate 12 chars (for "Hello World!") + 1 null '\0' char */
    some_str = calloc(13, sizeof(char));

    strcpy(some_str, "Hello World!");

    return some_str;
}

int main()
{
    char *str = some_string_func();
    printf("%s\n", str);

    free(str);  /* remember to free the allocated memory */
    return 0;
}

现在当你编译并运行它时，你得到：

$ gcc test.c
$ ./a.out
Hello World!
$

如果你很难理解C，我知道很多人发现Brian W. Kernighan和Dennis Ritchie的“C编程语言”是一个非常好的参考，但更现代和图形化（甚至有趣阅读！认真）本书是 Head First C David和Dawn Griffiths，他们解释了许多重要的C概念，如Heap和Stack，动态和静态C库之间的区别，为什么使用Makefiles是一个好主意，如何做作品，以及之前没有在普通C书中解释的更多概念，绝对值得一看。

另一个很好的在线资源是Zed Shaws Learn C the Hard way ，他提供了很好的代码示例和说明。

Answer 2

阅读：void *malloc(size_t size);

malloc()函数分配size个字节并返回指针分配的内存。内存未初始化。如果大小为0，然后malloc()返回NULL或可以返回的唯一指针值稍后成功传递给free()。

因此，

struct node* node = (struct node*)malloc(sizeof(struct node));
  //                                     ^----size---------^

您正在分配size = sizeof naode个字节的内存块，并从node指针中存储的malloc返回地址。

注意您的错误变量名称不应该是node，因为它是结构名称。您可以！但不是很好的做法。此外，如果类型发生变化，sizeof(*pointer)优先于sizeof(Type)

附注：避免不通过malloc和calloc函数转换返回地址是安全的。阅读：Do I cast the result of malloc?

所以正确上述陈述的优选形式是：

struct node* nd = malloc(sizeof *nd);
  //                     ^----size-^

两个纠正：（1）删除类型转换和（2）将变量名称更改为nd。

Answer 3

使用sizeof -

sizeof（ T ）将告知存储 T

类型变量所需的字节数

使用malloc -

Malloc动态分配内存，即在运行时（当程序实际由CPU及其内存执行时）。当我们不确定运行时所需的内存量时，我们主要使用它。因此，我们使用malloc在运行时动态分配它。

使用（struct node*） -

Malloc返回指向内存块的指针，其中包含您要求的空间量（在其参数中）。这个空间只是内存中的一些空间。因此，该指针没有与之关联的类型。我们将此指针强制转换为（struct node*），因为它会让机器知道类型（struct node）的变量将保存在此内存中。

Answer 4

void* malloc (size_t size);

分配内存块

分配大小字节的内存块，返回指向的内存   块的开头。新分配的块的内容   内存未初始化，保留不确定的值。如果   size为零，返回值取决于特定的库   实现（它可能是也可能不是空指针），但返回   指针不得解除引用。

不要投射malloc的结果。

你还需要释放这段记忆：

void free (void* ptr);

解除分配内存块

以前通过调用malloc，calloc或者分配的内存块   realloc被取消分配，使其再次可用   分配。

Answer 5

你使用malloc通常会让指针指向某个东西。

指针就像一个街道地址，地址上的建筑物是由malloc建造的 - 或者至少是建造建筑物所需的尺寸 - 你在那里建造的东西取决于你。

在您的示例中，树中的每个节点都是使用malloc分配的字节数，节点的大小是保存节点所有内容所需的字节数。

二叉树将使用malloc分配其每个节点，其中内存中的内容是无关紧要的，并且可能是使用malloc和指针理解有点棘手的事情。只要有指向这些位置的指针一切都很好。

Answer 6

struct node* node = (struct node*)malloc(sizeof(struct node));

用足够的空间来容纳node结构

malloc的以下代码行是什么？

6 个答案: