[已解决]关于给结构体内数组分配内存空间的问题求解！

a905448839

代码如下：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. int MinData = -1;
   
5. typedef struct TreeNode *HuffmanTree;
   
6. typedef struct Heap *MinHeap;
   
7. typedef int ElenmentType ;
   
8. struct TreeNode
   
9. {
   
10.     ElenmentType Weight;//权值
    
11.     HuffmanTree Left;
    
12.     HuffmanTree Right;
    
13. };
    
14. struct Heap
    
15. {
    
16.     HuffmanTree *Data;
    
17.     ElenmentType Size;
    
18.     ElenmentType Capacity;
    
19. };
    
20. 
    
21. MinHeap CreateHeap(int MaxSize);   // 建堆
    
22. void InsertHeap(MinHeap H,HuffmanTree T);
    
23. HuffmanTree DeleteHeap(MinHeap H);
    
24. HuffmanTree CreateHuffman(MinHeap H);
    
25. void Print(HuffmanTree HF);
    
26. void P(MinHeap H);
    
27. 
    
28. MinHeap CreateHeap(int MaxSize)
    
29. {
    
30.     MinHeap H = malloc(sizeof(struct Heap));
    
31.     H->Data = malloc((MaxSize + 1)* sizeof(struct TreeNode));
    
32.     H->Size = 0;
    
33.     H->Capacity = MaxSize;
    
34.     //H->Data[0] = malloc(sizeof(struct TreeNode));
    
35.     H->Data[0]->Weight = MinData;
    
36.     int i;
    
37.     for(i = 1;i <= MaxSize;i++)
    
38.             H->Data[i] = NULL;
    
39. 
    
40.     return H;
    
41. }
    
42. 
    
43. void InsertHeap(MinHeap H,HuffmanTree T)
    
44. {
    
45.         if(H->Size == H->Capacity)
    
46.         {
    
47.                 printf("最小堆满");
    
48.                 return;
    
49.         }
    
50.         int i = ++H->Size;
    
51.         for(;H->Data[i/2]->Weight > T->Weight;i/=2)
    
52.                 H->Data[i] = H->Data[i/2];
    
53.         H->Data[i] = T;
    
54. }
    
55. 
    
56. HuffmanTree DeleteHeap(MinHeap H)
    
57. {
    
58.         if(H->Size == 0)
    
59.         {
    
60.                 printf("最小堆空");
    
61.                 return;
    
62.         }
    
63.         HuffmanTree MinData = H->Data[1];
    
64.         HuffmanTree temp = H->Data[H->Size--];
    
65.         int i,j;
    
66.         for(i = 1;i*2 <= H->Size;i = j)
    
67.         {
    
68.                 j = i*2;
    
69.                 if((j != H->Size) && (H->Data[j]->Weight > H->Data[j+1]->Weight))
    
70.                 j++;
    
71.                 if(temp->Weight <= H->Data[j]->Weight)break;
    
72.                 else
    
73.                         H->Data[i] = H->Data[j];
    
74.         }
    
75.         H->Data[i] = temp;
    
76.        
    
77.         P(H);
    
78.         return MinData;
    
79. }
    
80. HuffmanTree CreateHuffman(MinHeap H)
    
81. {
    
82.         while(H->Size > 1)
    
83.         {
    
84.                 HuffmanTree A = DeleteHeap(H);
    
85.                 HuffmanTree B = DeleteHeap(H);
    
86.                 HuffmanTree Troot = (HuffmanTree)malloc(sizeof(struct TreeNode));
    
87.                 Troot->Weight = A->Weight+B->Weight;
    
88.                 Troot->Left = A;
    
89.                 Troot->Right = B;
    
90.                 InsertHeap(H,Troot);
    
91.         }
    
92.         return H->Data[1];
    
93. }
    
94. 
    
95. void Print(HuffmanTree HF)
    
96. {
    
97.         if(HF)
    
98.         {
    
99.                 printf("%d ",HF->Weight);
    
100.                 Print(HF->Left);
     
101.                 Print(HF->Right);
     
102.         }
     
103.                         printf("\n");
     
104. }
     
105. 
     
106. void P(MinHeap H)
     
107. {
     
108.         int i = 1;
     
109.         if(H->Size > 0)
     
110.                 for(;i <= H->Size;i++)
     
111.                         printf("%d ",H->Data[i]->Weight);
     
112.                 printf("\n");
     
113. }
     
114. int main()
     
115. {
     
116.        
     
117.         int i;
     
118.         scanf("%d\n",&i);
     
119.         MinHeap H = CreateHeap(i);
     
120.         while(i--)
     
121.         {
     
122.                 char a;
     
123.                 ElenmentType Weight;
     
124.                 scanf("%c %d",&a,&Weight);
     
125.                 HuffmanTree T  = malloc(sizeof(struct TreeNode));
     
126.                 T->Left = T->Right = NULL;
     
127.                 T->Weight = Weight;
     
128.                 getchar();
     
129.                 InsertHeap(H,T);
     
130.         }
     
131.         HuffmanTree HF = CreateHuffman(H);
     
132.         Print(HF);
     
133. 
     
134.   return 0;
     
135. }

复制代码

在CreateHeap函数里，首先生成了一个H的最小堆指针
MinHeap H = malloc(sizeof(struct Heap));
然后为其H堆里的数组成员Data分配内存空间
    H->Data = malloc((MaxSize + 1)* sizeof(struct TreeNode));
分配了之后，访问H->Data[0]居然是无效空间
必须加一句我注释掉的 H->Data[0] = malloc(sizeof(struct TreeNode));

蓝色这行代码就是出错的地方，我分配了内存空间为什么还是无效访问?

最佳答案

月排行榜 / 总排行榜

isdkz

2023-7-18 12:59:34

在你的代码中，你首先为 MinHeap H 结构体变量的 Data 成员，也就是一个指向 HuffmanTree 的指针数组，分配了内存空间。然后你尝试访问 H->Data[0] 并尝试修改其 Weight 属性。然而，你只为 Data 指针数组分配了内存空间，这意味着你已经有了一个可以存储 HuffmanTree 指针的内存空间，但你并没有实际为这些指针所指向的 HuffmanTree 节点分配内存。也就是说，你的数组可以存储指向 HuffmanTree 的指针，但是这些指针本身现在指向的是未分配的内存。

在你尝试执行 H->Data[0]->Weight = MinData; 这行代码时， H->Data[0] 指向的内存区域还没有被分配，所以你遇到了无效访问。

因此，你需要对每个 HuffmanTree 结构体实例分配内存，这就是为什么你需要使用 H->Data[0] = malloc(sizeof(struct TreeNode)); 这行代码的原因。这行代码会为 H->Data[0] 指针分配一个 struct TreeNode 类型的内存空间，所以你可以在这个内存区域上进行操作，例如修改其 Weight 属性。这样，你就不会遇到无效访问的问题了。

以下是你可能需要修改的部分：

1. MinHeap CreateHeap(int MaxSize)
2. {
3.     MinHeap H = malloc(sizeof(struct Heap));
4.     H->Data = malloc((MaxSize + 1) * sizeof(struct TreeNode *));
5.     H->Size = 0;
6.     H->Capacity = MaxSize;
7.     H->Data[0] = malloc(sizeof(struct TreeNode));
8.     H->Data[0]->Weight = MinData;
9.     int i;
10.     for(i = 1; i <= MaxSize; i++)
11.         H->Data[ i] = NULL;
13.     return H;
14. }

复制代码

在这段代码中，我将 H->Data 的内存分配改为 malloc((MaxSize + 1) * sizeof(struct TreeNode *)); ，因为 Data 是一个 HuffmanTree （也就是 struct TreeNode * ）类型的数组。然后，我为 H->Data[0] 分配了一个新的 struct TreeNode 类型的内存空间。

跳转到最佳答案楼层

陶远航

在给结构体内的数组分配内存空间时，你出现了无效访问的问题。这是因为你分配了H->Data的内存空间，但没有为H->Data[0]分配内存空间。

解决这个问题的方法是，你可以在分配H->Data的内存后，再单独为H->Data[0]分配内存空间，例如：

1. H->Data = malloc((MaxSize + 1)* sizeof(struct TreeNode));
2. H->Data[0] = malloc(sizeof(struct TreeNode));

复制代码

这样，你就为H->Data[0]分配了内存空间，之后就可以正常使用了。希望能帮到你！

isdkz

在你的代码中，你首先为 MinHeap H 结构体变量的 Data 成员，也就是一个指向 HuffmanTree 的指针数组，分配了内存空间。然后你尝试访问 H->Data[0] 并尝试修改其 Weight 属性。然而，你只为 Data 指针数组分配了内存空间，这意味着你已经有了一个可以存储 HuffmanTree 指针的内存空间，但你并没有实际为这些指针所指向的 HuffmanTree 节点分配内存。也就是说，你的数组可以存储指向 HuffmanTree 的指针，但是这些指针本身现在指向的是未分配的内存。

在你尝试执行 H->Data[0]->Weight = MinData; 这行代码时， H->Data[0] 指向的内存区域还没有被分配，所以你遇到了无效访问。

因此，你需要对每个 HuffmanTree 结构体实例分配内存，这就是为什么你需要使用 H->Data[0] = malloc(sizeof(struct TreeNode)); 这行代码的原因。这行代码会为 H->Data[0] 指针分配一个 struct TreeNode 类型的内存空间，所以你可以在这个内存区域上进行操作，例如修改其 Weight 属性。这样，你就不会遇到无效访问的问题了。

以下是你可能需要修改的部分：

1. MinHeap CreateHeap(int MaxSize)
2. {
3.     MinHeap H = malloc(sizeof(struct Heap));
4.     H->Data = malloc((MaxSize + 1) * sizeof(struct TreeNode *));
5.     H->Size = 0;
6.     H->Capacity = MaxSize;
7.     H->Data[0] = malloc(sizeof(struct TreeNode));
8.     H->Data[0]->Weight = MinData;
9.     int i;
10.     for(i = 1; i <= MaxSize; i++)
11.         H->Data[ i] = NULL;
13.     return H;
14. }

复制代码

在这段代码中，我将 H->Data 的内存分配改为 malloc((MaxSize + 1) * sizeof(struct TreeNode *)); ，因为 Data 是一个 HuffmanTree （也就是 struct TreeNode * ）类型的数组。然后，我为 H->Data[0] 分配了一个新的 struct TreeNode 类型的内存空间。

a905448839

isdkz 发表于 2023-7-18 12:59
在你的代码中，你首先为 MinHeap H 结构体变量的 Data 成员，也就是一个指向 HuffmanTree 的指针数组，分配 ...

谢谢你的回答，你能帮我看一下我构造的这个哈夫曼树是正确的吗？正常分配空间后构造的哈夫曼树WPL值好像不对。

sfqxx

a905448839 发表于 2023-7-18 13:50
谢谢你的回答，你能帮我看一下我构造的这个哈夫曼树是正确的吗？正常分配空间后构造的哈夫曼树WPL值好像 ...

你在代码中创建了一个 `MinHeap` 堆，并为 `H->Data` 分配了内存空间，这个内存空间的大小是 `(MaxSize + 1) * sizeof(struct TreeNode)`。然而，你需要注意的是 `H->Data` 是一个指针数组，它存储的是 `HuffmanTree` （也是指针）类型的数据。因此，你分配的内存应该是用来存储 `HuffmanTree` 指针的，而不是 `struct TreeNode` 结构体。

当你尝试访问 `H->Data[0]->Weight` 时，事实上你正在试图访问一个 `HuffmanTree` 结构的 `Weight` 成员。但是在这个时候，`H->Data[0]` 还没有被初始化，它指向的是一个未知的内存位置，这就是为什么你会遇到无效访问的问题。

如果你想要初始化 `H->Data[0]`，你确实需要为其分配内存空间。你注释掉的这行代码 `H->Data[0] = malloc(sizeof(struct TreeNode));` 是正确的，它会为 `H->Data[0]` 分配一个新的 `struct TreeNode` 结构体的内存空间，并将 `H->Data[0]` 指向这个新的内存空间。这样你就可以通过 `H->Data[0]` 访问并修改这个 `struct TreeNode` 结构体的成员了。

所以，你的代码应该修改为：

1. MinHeap CreateHeap(int MaxSize)
   
2. {
   
3.         MinHeap H = malloc(sizeof(struct Heap));
   
4.         H->Data = malloc((MaxSize + 1)* sizeof(struct TreeNode *));
   
5.         H->Size = 0;
   
6.         H->Capacity = MaxSize;
   
7. 
   
8.         H->Data[0] = malloc(sizeof(struct TreeNode));
   
9.         H->Data[0]->Weight = MinData;
   
10. 
    
11.         int i;
    
12.         for(i = 1;i <= MaxSize;i++)
    
13.                 H->Data[i] = NULL;
    
14. 
    
15.         return H;
    
16. }
    

复制代码

上述代码中，我将 `H->Data = malloc((MaxSize + 1)* sizeof(struct TreeNode));` 修改为 `H->Data = malloc((MaxSize + 1)* sizeof(struct TreeNode *));`，以确保为 `H->Data` 分配的内存空间足够存储 `(MaxSize + 1)` 个 `HuffmanTree` 指针。此外，我取消了 `H->Data[0] = malloc(sizeof(struct TreeNode));` 这行代码的注释，以确保 `H->Data[0]` 能指向一个有效的内存空间。