彻底理解链表中为何使用二级指针或者一级指针的引用

转载:https://blog.csdn.net/u012234115/article/details/39717215

在用c/c++写数据结构程序时，链表和二叉树中经常需要用到二级指针或者一级指针的引用，那么什么时候用什么时候不用呢？

先看一个简单的c++链表操作程序：

（虽然风格有点像c，不过这个是cpp文件，不要在意这些细节）

[cpp]  view plain copy

1. /* 
2. code:Linklist 
3. author:tashaxing 
4. time:2014.9.30 
5. */  
6. #include "stdio.h"          
7. #include "stdlib.h"     
8. #include "time.h"  
9. #define OK 1  
10. #define ERROR 0  
11. #define TRUE 1  
12. #define FALSE 0  
13. #define MAXSIZE 20 /* 存储空间初始分配量 */  
14. typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */  
15. typedef int ElemType;/* ElemType类型根据实际情况而定，这里假设为int */  
16. Status visit(ElemType c)  
17. {  
18.     printf("%d ",c);  
19.     return OK;  
20. }  
21. typedef struct Node  
22. {  
23.     ElemType data;  
24.     struct Node *next;  
25. }Node;  
26. typedef struct Node *LinkList; /* 定义LinkList */  
27.   
28. //初始化表头，用一级指针（此方式无效）  
29. Status InitList1(LinkList L)    //等价于Node *L  
30. {   
31.     L=(LinkList)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点 */  
32.     if(!L) /* 存储分配失败 */  
33.             return ERROR;  
34.     L->next=NULL; /* 指针域为空 */  
35.   
36.     return OK;  
37. }  
38.   
39. //初始化表头，用二级指针  
40. Status InitList2(LinkList *L)   //等价于Node **L  
41. {   
42.     *L=(LinkList)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点 */  
43.     if(!(*L)) /* 存储分配失败 */  
44.             return ERROR;  
45.     (*L)->next=NULL; /* 指针域为空 */  
46.   
47.     return OK;  
48. }  
49.   
50. //初始化表头，用一级指针引用  
51. Status InitList3(LinkList &L)   //等价于Node *&L  
52. {   
53.     L=(LinkList)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点 */  
54.     if(!L) /* 存储分配失败 */  
55.             return ERROR;  
56.     L->next=NULL; /* 指针域为空 */  
57.   
58.     return OK;  
59. }  
60.   
61. //清空链表，使用二级指针  
62. Status ClearList1(LinkList *L)  
63. {   
64.     LinkList p,q;  
65.     p=(*L)->next;           /*  p指向第一个结点 */  
66.     while(p)                /*  没到表尾 */  
67.     {  
68.         q=p->next;  
69.         free(p);  
70.         p=q;  
71.     }  
72.     (*L)->next=NULL;        /* 头结点指针域为空 */  
73.     return OK;  
74. }  
75.   
76. //清空链表，使用一级指针  
77. Status ClearList2(LinkList L)  
78. {   
79.     LinkList p,q;  
80.     p=L->next;           /*  p指向第一个结点 */  
81.     while(p)                /*  没到表尾 */  
82.     {  
83.         q=p->next;  
84.         free(p);  
85.         p=q;  
86.     }  
87.     L->next=NULL;        /* 头结点指针域为空 */  
88.     return OK;  
89. }  
90.   
91. //销毁链表，使用一级指针(此方式无效)  
92. Status DestroyList1(LinkList L)  
93. {  
94.     LinkList p,q;  
95.     p=L->next;           /*  p指向第一个结点 */  
96.     while(p)                /*  没到表尾 */  
97.     {  
98.         q=p->next;  
99.         free(p);  
100.         p=q;  
101.     }  
102.     free(L);  
103.     L=NULL;  
104.     return OK;  
105. }  
106.   
107. //销毁链表，使用二级指针  
108. Status DestroyList2(LinkList *L)  
109. {  
110.     LinkList p,q;  
111.     p=(*L)->next;           /*  p指向第一个结点 */  
112.     while(p)                /*  没到表尾 */  
113.     {  
114.         q=p->next;  
115.         free(p);  
116.         p=q;  
117.     }  
118.     free(*L);  
119.     *L=NULL;  
120.     return OK;  
121. }  
122.   
123. //销毁链表，使用一级指针引用  
124. Status DestroyList3(LinkList &L)  
125. {  
126.     LinkList p,q;  
127.     p=L->next;           /*  p指向第一个结点 */  
128.     while(p)                /*  没到表尾 */  
129.     {  
130.         q=p->next;  
131.         free(p);  
132.         p=q;  
133.     }  
134.     free(L);  
135.     L=NULL;  
136.     return OK;  
137. }  
138. /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */  
139. /* 操作结果：用e返回L中第i个数据元素的值 */  
140. Status GetElem(LinkList L,int i,ElemType *e)  
141. {  
142.     int j;  
143.     LinkList p;     /* 声明一结点p */  
144.     p = L->next;     /* 让p指向链表L的第一个结点 */  
145.     j = 1;      /*  j为计数器 */  
146.     while (p && j<i)  /* p不为空或者计数器j还没有等于i时，循环继续 */  
147.     {     
148.         p = p->next;  /* 让p指向下一个结点 */  
149.         ++j;  
150.     }  
151.     if ( !p || j>i )   
152.         return ERROR;  /*  第i个元素不存在 */  
153.     *e = p->data;   /*  取第i个元素的数据 */  
154.     return OK;  
155. }  
156.   
157.   
158. //在中间插入元素，用二级指针  
159. Status ListInsert1(LinkList *L,int i,ElemType e)  
160. {   
161.     int j;  
162.     LinkList p,s;  
163.     p = *L;     
164.     j = 1;  
165.     while (p && j < i)     /* 寻找第i个结点 */  
166.     {  
167.         p = p->next;  
168.         ++j;  
169.     }   
170.     if (!p || j > i)   
171.         return ERROR;   /* 第i个元素不存在 */  
172.     s = (LinkList)malloc(sizeof(Node));  /*  生成新结点(C语言标准函数) */  
173.     s->data = e;    
174.     s->next = p->next;      /* 将p的后继结点赋值给s的后继  */  
175.     p->next = s;          /* 将s赋值给p的后继 */  
176.     return OK;  
177. }  
178. //在中间插入元素，用一级指针  
179. Status ListInsert2(LinkList L,int i,ElemType e)  
180. {   
181.     int j;  
182.     LinkList p,s;  
183.     p = L;     
184.     j = 1;  
185.     while (p && j < i)     /* 寻找第i个结点 */  
186.     {  
187.         p = p->next;  
188.         ++j;  
189.     }   
190.     if (!p || j > i)   
191.         return ERROR;   /* 第i个元素不存在 */  
192.     s = (LinkList)malloc(sizeof(Node));  /*  生成新结点(C语言标准函数) */  
193.     s->data = e;    
194.     s->next = p->next;      /* 将p的后继结点赋值给s的后继  */  
195.     p->next = s;          /* 将s赋值给p的后继 */  
196.     return OK;  
197. }  
198. //删除一个元素，用二级指针  
199. Status ListDelete1(LinkList *L,int i,ElemType *e)   
200. {   
201.     int j;  
202.     LinkList p,q;  
203.     p = *L;  
204.     j = 1;  
205.     while (p->next && j < i)  /* 遍历寻找第i个元素 */  
206.     {  
207.         p = p->next;  
208.         ++j;  
209.     }  
210.     if (!(p->next) || j > i)   
211.         return ERROR;           /* 第i个元素不存在 */  
212.     q = p->next;  
213.     p->next = q->next;            /* 将q的后继赋值给p的后继 */  
214.     *e = q->data;               /* 将q结点中的数据给e */  
215.     free(q);                    /* 让系统回收此结点，释放内存 */  
216.     return OK;  
217. }  
218. //删除一个元素，用一级指针  
219. Status ListDelete2(LinkList L,int i,ElemType *e)   
220. {   
221.     int j;  
222.     LinkList p,q;  
223.     p = L;  
224.     j = 1;  
225.     while (p->next && j < i)  /* 遍历寻找第i个元素 */  
226.     {  
227.         p = p->next;  
228.         ++j;  
229.     }  
230.     if (!(p->next) || j > i)   
231.         return ERROR;           /* 第i个元素不存在 */  
232.     q = p->next;  
233.     p->next = q->next;            /* 将q的后继赋值给p的后继 */  
234.     *e = q->data;               /* 将q结点中的数据给e */  
235.     free(q);                    /* 让系统回收此结点，释放内存 */  
236.     return OK;  
237. }  
238. /* 初始条件：顺序线性表L已存在 */  
239. /* 操作结果：依次对L的每个数据元素输出 */  
240. Status ListTraverse(LinkList L)  
241. {  
242.     LinkList p=L->next;  
243.     while(p)  
244.     {  
245.         visit(p->data);  
246.         p=p->next;  
247.     }  
248.     printf("\n");  
249.     return OK;  
250. }  
251.   
252. int main()  
253. {          
254.     LinkList L;  
255.     ElemType e;  
256.     Status i;  
257.     int j,k;  
258.     //InitList1(L);   //一级指针方式创建表头，失败  
259.     //InitList2(&L);  //二级指针方式创建表头，成功  
260.     InitList3(L);     //一级指针引用方式创建表头，成功  
261.     for(j=1;j<=7;j++)  
262.             ListInsert2(L,1,j);  
263.     printf("一级指针方式在L的表头依次插入1～7后：");  
264.     ListTraverse(L);   
265.   
266.     ListInsert1(&L,3,12);  
267.     printf("二级指针方式在L的中间插入12后：");  
268.     ListTraverse(L);   
269.   
270.     ListInsert2(L,5,27);  
271.     printf("一级指针在L的中间插入27后：");  
272.     ListTraverse(L);   
273.   
274.     GetElem(L,5,&e);  
275.     printf("第5个元素的值为：%d\n",e);  
276.   
277.     ListDelete1(&L,5,&e); /* 删除第5个数据 */  
278.     printf("二级指针方式删除第%d个的元素值为：%d\n",5,e);  
279.     printf("依次输出L的元素：");  
280.     ListTraverse(L);   
281.   
282.     ListDelete2(L,3,&e); /* 删除第3个数据 */  
283.     printf("一级指针方式删除第%d个的元素值为：%d\n",3,e);  
284.     printf("依次输出L的元素：");  
285.     ListTraverse(L);   
286.   
287.     printf("二级指针方式清空链表\n");  
288.     ClearList1(&L);  
289.     printf("依次输出L的元素：");  
290.     ListTraverse(L);   
291.       
292.     for(j=1;j<=7;j++)  
293.             ListInsert2(L,j,j);  
294.     printf("在L的表尾依次插入1～7后：");  
295.     ListTraverse(L);   
296.   
297.     printf("一级指针方式清空链表\n");  
298.     ClearList2(L);  
299.     printf("依次输出L的元素：");  
300.     ListTraverse(L);   
301.   
302.     printf("销毁链表\n");  
303.     //DestroyList1(L);   //一级指针方式销毁链表，失败,且出现满屏乱码  
304.     //DestroyList2(&L);  //二级指针方式销毁链表，成功  
305.     DestroyList3(L);     //一级指针引用方式销毁链表，成功  
306.   
307.     return 0;  
308. }  

输出结果：

得出结论：

1，初始化链表头部指针需要用二级指针或者一级指针的引用。

2，销毁链表需要用到二级指针或者一级指针的引用。

3，插入、删除、遍历、清空结点用一级指针即可。

分析：
1，只要是修改头指针则必须传递头指针的地址，否则传递头指针值即可（即头指针本身）。这与普通变量类似，当需要修改普通变量的值，需传递其地址，否则传递普通变量的值即可（即这个变量的拷贝）。使用二级指针，很方便就修改了传入的结点一级指针的值。 如果用一级指针，则只能通过指针修改指针所指内容，却无法修改指针的值，也就是指针所指的内存块。所以创建链表和销毁链表需要二级指针或者一级指针引用。

2，不需要修改头指针的地方用一级指针就可以了，比如插入，删除，遍历，清空结点。假如头指针是L，则对L->next 及之后的结点指针只需要传递一级指针。

3，比如一个结点p，在函数里要修改p的指向就要用二级指针，如果只是修改p的next指向则用一级指针就可以了

函数中传递指针，在函数中改变指针的值，就是在改变实参中的数据信息。但是这里改变指针的值实际是指改变指针指向地址的值，因为传递指针就是把指针指向变量的地址传递过来，而不是像值传递一样只是传进来一个实参副本。所以当我们改变指针的值时，实参也改变了。

    仔细看函数InitList2(LinkList *L) 可以发现，在该函数中改变了指针的指向，也就是改变了指针自身的值。对比一下按值传递，这里的"值"是一个指针，所以我们要想指针本身的改变可以反映到实参指针上，必须使用二级指针。

下面通过看一个例子来理解：

[cpp]  view plain copy

1. #include <iostream>    
2. #include <string.h>    
3. using namespace std;    
4.     
5. void fun1(char* str)    
6. {    
7.     str = new char[5];    
8.     strcpy (str, "test string");    
9. }    
10.     
11. void fun2(char** str)    
12. {    
13.     *str = new char[5];    
14.     strcpy (*str, "test string");    
15. }    
16.     
17. int main()    
18. {    
19.     char* s = NULL;        
20.     cout << "call function fun1" << endl;    
21.     fun1 (s);    
22.     if (!s)    
23.         cout << "s is null!" << endl;    
24.     else    
25.         cout << s << endl;    
26.     
27.     cout << "call function fun2" << endl;    
28.     fun2 (&s);    
29.     if (!s)    
30.         cout << "s is null!" << endl;    
31.     else    
32.         cout << s << endl;    
33.     return 0;    
34. }    

输出结果：

分析：

在fun1中，当调用str = new char[5]时，str和s已经没什么关系了，相当于在fun1中复制了一个指针，这个指针指向的空间存储了字符串“test string”，但s仍指针NULL。当调用fun2时，因为是二级指针，s指向str，这里*str = new char[5]，*str就是s，所以给*str分配空间就是给s分配空间。这样解释应该就很清楚了。

画图为例：

fun1执行时

fun2执行时

如图所示，在fun1种str是s的拷贝，给str分配空间跟s没有关系，在fun2种str是二级指针，指向s，能够通过控制*str从而给s分配空间。

后记

用框图表示链表中二级指针或者一级指针的使用更加直白了。

1，二级指针创建头指针。

a.只有头指针，没有头结点

b，有头指针，也有头节点

c，而如果不用二级指针，直接传一个一级指针，相当于生成L的拷贝M，但是对M分配空间与L无关了。

2，二级指针销毁头指针

无论有没有头节点都要用二级指针或者一级指针的引用传参来销毁。

3，二级指针与一级指针方式插入结点

传二级指针就是在从链表头指针开始对链表操作，传一级指针只不过是对头结点L生成了一个拷贝M，M的next指向的仍然是L的next，因此，后面的操作仍然是在原链表上操作。

4，二级指针与一级指针方式删除结点

删除的原理与插入一样。

注意：

在没有传入头结点的情况下必须使用二级指针，使用一级指针无效。

例如：

[cpp]  view plain  copy

1. void insert(Node *p)  
2. {  
3.     //do something to change the structure  
4. }  
5. void fun(Node *T)  
6. {  
7.     Node *p;  
8.     insert(p)    //OK,the head T is in  
9. }  
10. int main()  
11. {  
12.     Node *T;  
13.     fun(T);  //OK,the head T is in  
14. }  

因为fun函数里传入了数据结构的头指针（链表，二叉树都可以），在这个函数里面的insert函数形参可以是一级指针。

但是如果在main函数里直接单独对数据结构中某一个结点操作就不能用一级指针了。

[cpp]  view plain  copy

1. void insert1(Node *p)  
2. {  
3.     //do something to change the structure  
4. }  
5. void insert2(Node **P)  
6. {  
7.     //do something to change the structure  
8. }  
9. int main()  
10. {  
11.     Node *p;  
12.     insert1(p);   //error  
13.     insert2(&p); //OK  
14. }