数据结构视频 二叉树代码不理解

独一无②

二叉树的建立和遍历那一课程

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef char ElemType;
   
5. 
   
6. typedef struct BiTNode
   
7. {
   
8.         char data;
   
9.         struct BiTNode *lchild, *rchild;
   
10. } BiTNode, *BiTree;
    
11. 
    
12. // 创建一棵二叉树，约定用户遵照前序遍历的方式输入数据
    
13. CreateBiTree(BiTree *T)//这里是二级指针了吗？
    
14. {
    
15.         char c;
    
16. 
    
17.         scanf("%c", &c);
    
18.         if( ' ' == c )
    
19.         {
    
20.                 *T = NULL;
    
21.         }
    
22.         else
    
23.         {
    
24.                 *T = (BiTNode *)malloc(sizeof(BiTNode));
    
25.                 (*T)->data = c;
    
26.                 CreateBiTree(&(*T)->lchild);
    
27.                 CreateBiTree(&(*T)->rchild);
    
28.         }
    
29. }
    
30. 
    
31. // 访问二叉树结点的具体操作，你想干嘛？！
    
32. visit(char c, int level)
    
33. {
    
34.         printf("%c 位于第 %d 层\n", c, level);
    
35. }
    
36. 
    
37. // 前序遍历二叉树
    
38. PreOrderTraverse(BiTree T, int level)
    
39. {
    
40.         if( T )
    
41.         {
    
42.                 visit(T->data, level);
    
43.                 PreOrderTraverse(T->lchild, level+1);
    
44.                 PreOrderTraverse(T->rchild, level+1);
    
45.         }
    
46. }
    
47. 
    
48. int main()
    
49. {
    
50.         int level = 1;
    
51.         BiTree T = NULL;
    
52. 
    
53.         CreateBiTree(&T);//为什么这里要用&，不能直接用T传进去吗？
    
54.         PreOrderTraverse(T, level);//这里又没有&了
    
55.    
    
56.         return 0;
    
57. }

复制代码

CreateBiTree(&T); 这里为什么要用&T传进去，这样是算二级指针了吗
我把&这去掉，然后做了相应的修改，结果就没输出了，想了好久都不明白
还是因为我对指针不对了解吧，哪位大神可以详细的解释一下，O(∩_∩)O谢谢！！！

ryxcaixia

少年 函数的参数都是临时变量 指针类型的参数也是临时变量 二级指针的类型也是临时变量
函数调用的时候 会把这些参数由右向左 依次推进栈中
当函数调用完成后 这些参数会出栈 也就是临时变量消失了 生命周期结束

只不过当形参是二级指针的时候, 可以拿到一级指针的地址,
获得里某个变量的地址 自然就可以对其赋值并保证不被清空(在其生命周期内)

ryxcaixia

1. void getmem_1(int* p)
   
2. {
   
3.         p = (int*)malloc(sizeof(int) * 0xFF);
   
4. }
   
5. 
   
6. void getmem_2(int** p)
   
7. {
   
8.         *p = (int*)malloc(sizeof(int) * 0xFF);
   
9. }
   
10. 
    
11. #include "vld.h"
    
12. int main(int argc, char* argv[])
    
13. {
    
14.         int* p1 = NULL;
    
15.         int* p2 = NULL;
    
16. 
    
17.         getmem_1(p1);
    
18.         getmem_2(&p2);
    
19. 
    
20.         return 0;
    
21. }

复制代码

请自行忽略那个vld头文件
楼主体会下 p1 和 p2 哪个成功获得了内存
想想这句话 "如果想通过函数的参数在函数内部获得堆上内存, 就需要传递二级(或更高级)指针"
如果理解了 就知道为什么了

独一无②

ryxcaixia 发表于 2016-1-26 17:08
请自行忽略那个vld头文件
楼主体会下 p1 和 p2 哪个成功获得了内存
想想这句话 "如果想通过函数的参 ...

感觉getmem_2可以，然后我修改了一下程序，果然getmem_1运行会出错

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. /*
   
4. void getmem_1(int* p)
   
5. {
   
6.         p = (int*)malloc(sizeof(int) * 0xFF);
   
7.                 *p=3;
   
8. }
   
9. */
   
10. void getmem_2(int** p)
    
11. {
    
12.         *p = (int*)malloc(sizeof(int) * 0xFF);
    
13.                 **p=4;
    
14. }
    
15. 
    
16. 
    
17. int main(int argc, char* argv[])
    
18. {
    
19.         int* p1 = NULL;
    
20.         int* p2 = NULL;
    
21. 
    
22. //        getmem_1(p1);
    
23. //                printf("%d\n",*p1);
    
24.         getmem_2(&p2);
    
25.                 printf("%d",*p2);
    
26. 
    
27.         return 0;
    
28. }

复制代码

我可能还是没有理解吧，在我看来getmem_1中的  p  和getmem_2中的  *p   不是同一个东西吗？只是表达不一样，为什么一个分配就会失败，

ryxcaixia

1. __declspec(naked) void asm_getmem_1(int* p)
   
2. {
   
3.         __asm
   
4.         {
   
5.                 push ebp
   
6.                 mov ebp, esp
   
7. 
   
8.                 push 4
   
9.                 call dword ptr malloc
   
10.                 add esp, 4
    
11. 
    
12.                 mov [ebp+8], eax ; [ebp+8]就是临时变量p, eax存着由malloc申请的内存
    
13. 
    
14.                 mov esp, ebp
    
15.                 pop ebp
    
16.                 ret
    
17.         }
    
18. }
    
19. 
    
20. int main(int argc, char* argv[])
    
21. {
    
22.         int* p1 = NULL;
    
23.         __asm
    
24.         {
    
25.                 push p1 ; 这个过程就是相当于复制了个临时变量
    
26.                 call asm_getmem_1
    
27.                 add esp, 4 ; 临时变量被销毁
    
28. 
    
29.                 mov eax, dword ptr [esp-4] ; 由于临时变量被销毁, 直接从栈上取消失的临时变量
    
30.                 mov p1, eax
    
31.         }
    
32. 
    
33.         *p1 = 0xFF;
    
34.         printf("%d\n", *p1); // 正确赋值
    
35. 
    
36.         return 0;
    
37. }

复制代码

ryxcaixia

这种东西 利用汇编解释 最清楚
直接跟踪着内存 寄存器
啥都一目了然

独一无②

ryxcaixia 发表于 2016-1-27 09:15
这种东西 利用汇编解释 最清楚
直接跟踪着内存 寄存器
啥都一目了然

哦哦，貌似懂了，O(∩_∩)O谢谢了~

作我自己

看数据结构，讲的很清楚