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

[cpp] view plaincopy/*
code:Linklist
author:tashaxing
time:2014.9.30
*/
#include "stdio.h"
#include "stdlib.h"
#include "time.h"
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */
typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType;/* ElemType类型根据实际情况而定，这里假设为int */
Status visit(ElemType c)
{  printf("%d ",c);  return OK;
}
typedef struct Node
{  ElemType data;  struct Node *next;
}Node;
typedef struct Node *LinkList; /* 定义LinkList */ //初始化表头，用一级指针（此方式无效）
Status InitList1(LinkList L)    //等价于Node *L
{   L=(LinkList)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点 */ if(!L) /* 存储分配失败 */ return ERROR;  L->next=NULL; /* 指针域为空 */ return OK;
}  //初始化表头，用二级指针
Status InitList2(LinkList *L)   //等价于Node **L
{   *L=(LinkList)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点 */ if(!(*L)) /* 存储分配失败 */ return ERROR;  (*L)->next=NULL; /* 指针域为空 */ return OK;
}  //初始化表头，用一级指针引用
Status InitList3(LinkList &L)   //等价于Node *&L
{   L=(LinkList)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点 */ if(!L) /* 存储分配失败 */ return ERROR;  L->next=NULL; /* 指针域为空 */ return OK;
}  //清空链表，使用二级指针
Status ClearList1(LinkList *L)
{   LinkList p,q;  p=(*L)->next;           /*  p指向第一个结点 */ while(p)                /*  没到表尾 */ {  q=p->next;  free(p);  p=q;  }  (*L)->next=NULL;        /* 头结点指针域为空 */ return OK;
}  //清空链表，使用一级指针
Status ClearList2(LinkList L)
{   LinkList p,q;  p=L->next;           /*  p指向第一个结点 */ while(p)                /*  没到表尾 */ {  q=p->next;  free(p);  p=q;  }  L->next=NULL;        /* 头结点指针域为空 */ return OK;
}  //销毁链表，使用一级指针(此方式无效)
Status DestroyList1(LinkList L)
{  LinkList p,q;  p=L->next;           /*  p指向第一个结点 */ while(p)                /*  没到表尾 */ {  q=p->next;  free(p);  p=q;  }  free(L);  L=NULL;  return OK;
}  //销毁链表，使用二级指针
Status DestroyList2(LinkList *L)
{  LinkList p,q;  p=(*L)->next;           /*  p指向第一个结点 */ while(p)                /*  没到表尾 */ {  q=p->next;  free(p);  p=q;  }  free(*L);  *L=NULL;  return OK;
}  //销毁链表，使用一级指针引用
Status DestroyList3(LinkList &L)
{  LinkList p,q;  p=L->next;           /*  p指向第一个结点 */ while(p)                /*  没到表尾 */ {  q=p->next;  free(p);  p=q;  }  free(L);  L=NULL;  return OK;
}
/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值 */
Status GetElem(LinkList L,int i,ElemType *e)
{  int j;  LinkList p;     /* 声明一结点p */ p = L->next;     /* 让p指向链表L的第一个结点 */ j = 1;      /*  j为计数器 */ while (p && j<i)  /* p不为空或者计数器j还没有等于i时，循环继续 */ {     p = p->next;  /* 让p指向下一个结点 */ ++j;  }  if ( !p || j>i )   return ERROR;  /*  第i个元素不存在 */ *e = p->data;   /*  取第i个元素的数据 */ return OK;
}  //在中间插入元素，用二级指针
Status ListInsert1(LinkList *L,int i,ElemType e)
{   int j;  LinkList p,s;  p = *L;     j = 1;  while (p && j < i)     /* 寻找第i个结点 */ {  p = p->next;  ++j;  }   if (!p || j > i)   return ERROR;   /* 第i个元素不存在 */ s = (LinkList)malloc(sizeof(Node));  /*  生成新结点(C语言标准函数) */ s->data = e;    s->next = p->next;      /* 将p的后继结点赋值给s的后继  */ p->next = s;          /* 将s赋值给p的后继 */ return OK;
}
//在中间插入元素，用一级指针
Status ListInsert2(LinkList L,int i,ElemType e)
{   int j;  LinkList p,s;  p = L;     j = 1;  while (p && j < i)     /* 寻找第i个结点 */ {  p = p->next;  ++j;  }   if (!p || j > i)   return ERROR;   /* 第i个元素不存在 */ s = (LinkList)malloc(sizeof(Node));  /*  生成新结点(C语言标准函数) */ s->data = e;    s->next = p->next;      /* 将p的后继结点赋值给s的后继  */ p->next = s;          /* 将s赋值给p的后继 */ return OK;
}
//删除一个元素，用二级指针
Status ListDelete1(LinkList *L,int i,ElemType *e)
{   int j;  LinkList p,q;  p = *L;  j = 1;  while (p->next && j < i)  /* 遍历寻找第i个元素 */ {  p = p->next;  ++j;  }  if (!(p->next) || j > i)   return ERROR;           /* 第i个元素不存在 */ q = p->next;  p->next = q->next;            /* 将q的后继赋值给p的后继 */ *e = q->data;               /* 将q结点中的数据给e */ free(q);                    /* 让系统回收此结点，释放内存 */ return OK;
}
//删除一个元素，用一级指针
Status ListDelete2(LinkList L,int i,ElemType *e)
{   int j;  LinkList p,q;  p = L;  j = 1;  while (p->next && j < i)  /* 遍历寻找第i个元素 */ {  p = p->next;  ++j;  }  if (!(p->next) || j > i)   return ERROR;           /* 第i个元素不存在 */ q = p->next;  p->next = q->next;            /* 将q的后继赋值给p的后继 */ *e = q->data;               /* 将q结点中的数据给e */ free(q);                    /* 让系统回收此结点，释放内存 */ return OK;
}
/* 初始条件：顺序线性表L已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
Status ListTraverse(LinkList L)
{  LinkList p=L->next;  while(p)  {  visit(p->data);  p=p->next;  }  printf("n");  return OK;
}  int main()
{          LinkList L;  ElemType e;  Status i;  int j,k;  //InitList1(L);   //一级指针方式创建表头，失败 //InitList2(&L);  //二级指针方式创建表头，成功 InitList3(L);     //一级指针引用方式创建表头，成功 for(j=1;j<=7;j++)  ListInsert2(L,1,j);  printf("一级指针方式在L的表头依次插入1～7后：");  ListTraverse(L);   ListInsert1(&L,3,12);  printf("二级指针方式在L的中间插入12后：");  ListTraverse(L);   ListInsert2(L,5,27);  printf("一级指针在L的中间插入27后：");  ListTraverse(L);   GetElem(L,5,&e);  printf("第5个元素的值为：%dn",e);  ListDelete1(&L,5,&e); /* 删除第5个数据 */ printf("二级指针方式删除第%d个的元素值为：%dn",5,e);  printf("依次输出L的元素：");  ListTraverse(L);   ListDelete2(L,3,&e); /* 删除第3个数据 */ printf("一级指针方式删除第%d个的元素值为：%dn",3,e);  printf("依次输出L的元素：");  ListTraverse(L);   printf("二级指针方式清空链表n");  ClearList1(&L);  printf("依次输出L的元素：");  ListTraverse(L);   for(j=1;j<=7;j++)  ListInsert2(L,j,j);  printf("在L的表尾依次插入1～7后：");  ListTraverse(L);   printf("一级指针方式清空链表n");  ClearList2(L);  printf("依次输出L的元素：");  ListTraverse(L);   printf("销毁链表n");  //DestroyList1(L);   //一级指针方式销毁链表，失败,且出现满屏乱码 //DestroyList2(&L);  //二级指针方式销毁链表，成功 DestroyList3(L);     //一级指针引用方式销毁链表，成功 return 0;
}

输出结果：

得出结论：

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

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

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

需要C/C++ Linux服务器架构师学习资料加qun获取（资料包括C/C++，Linux，golang技术，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK，ffmpeg等），免费分享

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

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

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

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

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

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

[cpp] view plaincopy#include <iostream>
#include <string.h>
using namespace std;    void fun1(char* str)
{    str = new char[5];    strcpy (str, "test string");
}    void fun2(char** str)
{    *str = new char[5];    strcpy (*str, "test string");
}    int main()
{    char* s = NULL;        cout << "call function fun1" << endl;    fun1 (s);    if (!s)    cout << "s is null!" << endl;    else cout << s << endl;    cout << "call function fun2" << endl;    fun2 (&s);    if (!s)    cout << "s is null!" << endl;    else cout << s << endl;    return 0;   }

输出结果：

分析：

在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，二级指针与一级指针方式删除结点

删除的原理与插入一样。

注意：

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

例如：

void insert(Node *p)
{//do something to change the structure
}
void fun(Node *T)
{Node *p;insert(p)    //OK,the head T is in
}
int main()
{Node *T;fun(T);  //OK,the head T is in
}

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

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

void insert1(Node *p)
{//do something to change the structure
}
void insert2(Node **P)
{//do something to change the structure
}
int main()
{Node *p;insert1(p);   //errorinsert2(&p); //OK
}

个元素前面 个元素放在第i 链表将第j_彻底理解链表中为何使用二级指针或者一级指针的引用...相关推荐

  1. html的绝对定位脱离文档流吗,子元素position:absolute定位之后脱离文档流，怎么使子元素撑开父元素...

    纯粹的CSS无法实现.因为position:absolute就是脱离文档流,怎么能让父元素不塌陷呢? 目前想到的只能用js和jquery来实现了,用js获取子元素的高度,赋值给父元素. test .o ...

  2. Java学习小程序（8）求数组元素的最大值并放在最后一位

    求数组元素的最大值并放在最后一位,创建一个10个长度的数组,随机生成0-99之间的数值放入数组,找出最大值,将数组的长度扩容为11,把最大值赋给最后一位. //求数组的最大值放在最后一位 import ...

  3. JSP基本语法：文件结构、脚本元素、指令元素、动作元素

    JSP语法分为三种不同的类型: 脚本元素(SCRIPTING) 指令元素(DIRECTIVE) 例如: <%@ page import="java.io.*" %> 动 ...

  4. HTML5之article元素与section元素之间的区别？

    在HTML5中,为了使文档的结构更加清晰明确,追加了几个与页眉.页脚.内容区块等文档结构相关联的结构元素.内容区块是指将HTML页面按逻辑分割后的单位.例如对于书籍来说,章.节可以称为内容区块:对于博 ...

  5. HTML5 新增结构元素分为主体结构元素和非主体结构元素

    做移动端有一段时间,今天有同事问了我 article 和 section 标签的使用,模模糊糊的解释了下,他似懂非懂,有点小尴尬.忽然间觉得自己有必要再翻翻书籍,重温下 html5 的新元素.今天先介 ...

  6. 数组中的元素赋值给元素_漫画：寻找无序数组的第k大元素

    本期封面作者:泰勒太乐 -----  第二天  ----- 题目是什么意思呢?比如给定的无序数组如下: 如果 k=6,也就是要寻找第6大的元素,这个元素是哪一个呢? 显然,数组中第一大的元素是24,第 ...

  7. （一）html5中的新增元素和废除元素

    //刘梦冰发表于2015-6-29 1.新增的结构元素 (1)section元素 section元素表示页面中的一个内容区块,比如章节.页眉.页脚或者页面中的其他部分,它可以与h1.h2.h3等元素结 ...

  8. 行内元素 块级元素之间的嵌套

    默认的span标签是一个行内标签,页面构成时,尽量把它作为最后一个标签. 当然不绝对,你可以在内套用同是行内标签的元素:<i>.<span>.<em>...等等等. ...

  9. figure元素和figcaption元素

    在HTML5中,figure元素用于定义独立的流内容(图像.图表.照片.代码等):figcaption元素用于为figure元素组添加标题. 效果图: 代码如下: <!DOCTYPE html& ...

最新文章

  1. redis-sentinel 主从复制高可用
  2. ASIHTTPRequest的环境配置和使用示例
  3. 二、window下django安装及第一个应用
  4. OpenCV中的模板匹配
  5. git clone 解决Permission Denied (publickey)问题
  6. 《Python编程快速上手——让繁琐工作自动化》——2.8 导入模块
  7. POJ2109-Power of Cryptography
  8. “中国互联网100强”（2013）发布
  9. VS2005 中文版下载
  10. 操作系统与操作系统内核
  11. 基于AC自动机的表白墙解析工具
  12. 【问题解决】java.sql.SQLException: null, message from server: “Host ‘xxx.xx.xx.xxx‘ is blocked because of
  13. 弦截法 解高次方程 C语言/C++
  14. 转录组入门（4）：了解参考基因组及基因注释
  15. 3.10 Ctrl+A快捷键在表格中的使用 [原创Excel教程]
  16. java.lang.NoClassDefFoundError: org/jdom2/JDOMException
  17. 进图形界面黑屏的解决办法
  18. PHP 阿里云OpenAPI签名[RPC 调用机制]·一键登录取号[云通信号码认证服务]
  19. 注释、标识符、关键字、数据类型、类型转换
  20. html测试题英语,北大PKU-GATE考试真题-题库

热门文章

  1. 惊恐的市场洗牌网游市场诞生危机论
  2. vue项目中常见问题及解决方案
  3. 知识图谱在美团推荐场景中的应用实践
  4. 强化学习算法在京东广告序列推荐场景的应用
  5. SIGIR2020 | 基于GCN的鲁棒推荐系统研究
  6. 算法工程师面试备战笔记11_朴素贝叶斯分类某个类别概率为0怎么办
  7. 算法工程师面试备战笔记8_猜测这种划分最可能是什么聚类算法的结果
  8. php常见web安全问题,web安全面试常见问题（来自微博）
  9. 环形单链表的约瑟夫问题
  10. 吴恩达机器学习学习笔记第二章：单变量线性回归