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

最新推荐文章于 2023-01-12 17:11:47 发布
最新推荐文章于 2023-01-12 17:11:47 发布
阅读量427 收藏 9
点赞数 2
分类专栏： 数据结构与算法

转载：http://blog.csdn.net/u012434102/article/details/44886339

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

 #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个元素的值为：%d\n",e);  

    ListDelete1(&L,5,&e); /* 删除第5个数据 */  
    printf("二级指针方式删除第%d个的元素值为：%d\n",5,e);  
    printf("依次输出L的元素：");  
    ListTraverse(L);   

    ListDelete2(L,3,&e); /* 删除第3个数据 */  
    printf("一级指针方式删除第%d个的元素值为：%d\n",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
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267
  • 268
  • 269
  • 270
  • 271
  • 272
  • 273
  • 274
  • 275
  • 276
  • 277
  • 278
  • 279
  • 280
  • 281
  • 282
  • 283
  • 284
  • 285
  • 286
  • 287
  • 288
  • 289
  • 290
  • 291
  • 292
  • 293
  • 294
  • 295
  • 296
  • 297
  • 298
  • 299
  • 300
  • 301
  • 302
  • 303

结果: 
这里写图片描述

得出结论：

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

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

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

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

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

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

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

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

   
   
  • 1
  • 2

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

 #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;    
}  
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 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，二级指针与一级指针方式删除结点 
这里写图片描述
删除的原理与插入一样。

注意：

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

例如：

    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  
    }  
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

因为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);   //error  
        insert2(&p); //OK  
    }  
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
z

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

 #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个元素的值为：%d\n",e);  

    ListDelete1(&L,5,&e); /* 删除第5个数据 */  
    printf("二级指针方式删除第%d个的元素值为：%d\n",5,e);  
    printf("依次输出L的元素：");  
    ListTraverse(L);   

    ListDelete2(L,3,&e); /* 删除第3个数据 */  
    printf("一级指针方式删除第%d个的元素值为：%d\n",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
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267
  • 268
  • 269
  • 270
  • 271
  • 272
  • 273
  • 274
  • 275
  • 276
  • 277
  • 278
  • 279
  • 280
  • 281
  • 282
  • 283
  • 284
  • 285
  • 286
  • 287
  • 288
  • 289
  • 290
  • 291
  • 292
  • 293
  • 294
  • 295
  • 296
  • 297
  • 298
  • 299
  • 300
  • 301
  • 302
  • 303

结果: 
这里写图片描述

得出结论：

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

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

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

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

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

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

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

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

 
 
  • 1
  • 2

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

 #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;    
}  
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 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，二级指针与一级指针方式删除结点 
这里写图片描述
删除的原理与插入一样。

注意：

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

例如：

    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  
    }  
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

因为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);   //error  
        insert2(&p); //OK  
    }
yingge2016
关注
专栏目录
C语言关于链表的代码看不懂?一篇文章让你拿捏二级指针并深入理解函数参数列表中传参的多种形式
微凉秋意的博客
07-06 2001
这篇博客即将解决你看不懂或者不会写链表的基本操作的问题，对于初学者而言，有很多地方肯定是费解的。比如函数的参数列表的多样化，动态分配内存空间函数malloc等，其实这些知识和指针联系紧密，尤其是二级指针。那么开始好好的学习这篇博客吧！......
二级指针在单链表中的运用
08-30
运用二级指针在单链表中的删除操作的示例代码
链表中为何使用二级指针
qq_28816873的博客
06-06 3988
本篇目录前言参数的调用方式传值调用传址调用传引用调用示例说明使用二级指针/一级指针创建链表时的对比主函数中作此调用使用二级指针创建链表使用一级指针创建链表会成功吗销毁链表时二级指针和一级指针的对比使用二级指针销毁链表使用一级指针销毁链表会成功吗总结完整代码参考来源 前言 在学习数据结构时，在链表初始化或者销毁链表的时候，经常使用二级指针或者一级指针的引用，这是为什么呢？同样是指向内存单元的地址，为什么就不能使用一级指针呢？使用一级指针去初始化或者是销毁链表的时候，究竟会发生什么呢？到底什么时候该用二级指针，
为什么要使用二级指针？
weixin_42616791的博客
06-15 8211
概念 提到指针，我们都知道指针是用来存储一个变量的地址。所以，当我们定义了一个指向指针的指针的时候(pointer to pointer)，我们也称之为二级指针，那针对于这个二级指针来说，第一级指针存放的是指向的变量的地址，第二级指针存放的是第一级指针的地址。可以用下面这张图表示他们之间的关系。 上图所表达的意思也就是，一级指针变量 ptr1 存放的是 var 变量的地址，二级指针变量 ptr2 存放的是一级指针变量的地址。这也就是关于二级指针的相关概念。 一级指针与二级指针关系示例 #include &
链表：二级指针的使用
andypeng2015的博客
09-07 179
博文的记录源自阅读著名的酷壳主页：http://coolshell.cn/articles/8990.html 　　Coolshell图文并茂说明了这个问题——我们在删除链表的时候，常常需要记录该结点在链表中是否有前趋prev。如果有，那么需要把prev->next指向该结点的next域，然后再删除该结点，这样才能保证链表不会因为删除结点而“断开”。像这样： void re...
c语言二级指针的作用,为什么要使用二级指针？
weixin_34900419的博客
05-16 2963
概念提到指针，我们都知道指针是用来存储一个变量的地址。所以，当我们定义了一个指向指针的指针的时候(pointer to pointer)，我们也称之为二级指针，那针对于这个二级指针来说，第一级指针存放的是指向的变量的地址，第二级指针存放的是第一级指针的地址。可以用下面这张图表示他们之间的关系。 上图所表达的意思也就是，一级指针变量 ptr1 存放的是 var 变量的地址，二级指针变量 ptr2 存...
c语言指针之二级指针示例
01-20
在C语言中，指针是一种强大的工具，它允许我们直接操作内存。二级指针是这种工具的一个高级形式，它能够让我们处理指针的指针，即指针的地址。...正确理解和使用二级指针对于编写高效且内存管理良好的C程序至关重要。
商品管理系统&链表实现&二级指针
11-15
在本系统中，二级指针可能用于操作链表的指针本身，例如更改链表的头节点或者在链表中进行更复杂的操作。二级指针可以被视为指向指针的指针，它可以用来间接修改指针的值。例如，如果我们有一个指向链表头的指针`...
C语言中的指针以及二级指针代码详解
08-28
二级指针的声明类似于`int **p`，表示`p`是一个指针，它指向一个指向整型变量的指针。解引用二级指针需要两次操作，如`**p`，这可以用来访问三级指针所指向的指针变量的值。 4. **指针操作注意事项**： - 必须确保...
对链表的操作为什么要使用二级指针
JayChan
09-29 5882
拿上面的链表的插入函数举例，它使用了二级指针是因为：如果使用一级指针，当我们向空链表中插入节点时，新节点就是头节点，我们会改动头指针，但函数调用完后，head还是一个空指针。 用一级指针和二级指针的区别： 一级指针：传入一个地址，我们可以对地址上的值进行修改。但如果是一个空指针，你在函数内为之开辟空间是无法带回函数外部的。 二级指针：传入一个指针的地址，此时指针是作为地址上的值让我们修改的。
为什么链表的插入和删除要用二级指针
weixin_44356316的博客
10-24 905
首先，来看这样两段代码 #include <iostream> using namespace std; void fun(int*b) { *b = 1; } int main() { int a = 5; fun(&a); cout << a << endl; cin.get(); return 0; } 代码一运行返回1 #inc...
带头结点的链表逆序
liuxunfei15的博客
07-27 1262
#include &lt;iostream&gt; using namespace std; typedef struct listnode  //结构体定义结点数据类型 {     int date;     struct listnode *next; }listnode; void Init(listnode **head) {     listnode *p=new listnode...
链表中的二级指针
代码有点萌的博客
09-28 998
链表中的二级指针
链表释放时使用二级指针的原因
qq_41937509的博客
07-14 388
首先需要先理解，向函数传值与传地址的概念。在函数外部创建的变量传入函数中，如果是值传递，则本质是将变量拷贝一份放入函数中，在函数中的任何操作都不会影响外部的变量。如果是地址传递，本质是通过指针找到对应变量存储的数据，在函数中操作，会影响函数外的变量。 在释放链表的时候我们需要释放节点对应的数据，而不是拷贝一份，把拷贝的数据释放。所以需要拿到节点的地址。由于链表的节点是以指针的形式创建的，所以需要将指针的地址传入，以指针的指针进行寻址并操作数据。...
关于单链表为什么要设置二级指针和为什么尾删不删除头节点时可以使用一级指针的个人理解
m0_64862267的博客
01-12 758
我们要删除头节点，然而这个头节点的地址是一级指针所存储，我们要删除他，就要删除整个结构体的地址，也就是一级指针的地址，所以要传二级指针来删除它。传二级指针主要是为了创建头节点。其次你要为结构体里面的指针创建空间，本题为结构体指针，所以先判断，先给结构体一个空间，然后判断如果结构体有空间，就给结构体里面的结构指针空间，依次递归。然后要改变头节点结构体地址，所以要传二级指针，二级指针存储的是头节点结构体地址，然后我们要尾删时要注意，我们创建的结构体里面包含下一个结构体的地址，
关于链表初始化中为何使用二级指针(指向指针的指针)的对比解释
aiba5484的博客
04-27 909
###引言### 在数据结构的学习过程中,有时候会遇到一些一时无法理解的问题,深究起来却是语言的底层的语法机制所限制. 就例如在链表的构建中,链表的初始化和销毁为何需要使用一个二级指针,而不是只需要传递一个指针就可以了,其问题的关键就在于c语言的参数传递的方式是值传递 那么,这篇文章就来聊一聊在链表的初始化中一级指针的传递和二级指针的区别. 一级指针和二级指针的区别 1.前提知识:c...
二级指针在链表里的使用
verdicty的专栏
08-01 560
在链表里使用二级指针来遍历节点, 会使代码简洁;
单链表中什么时候使用二级指针
weixin_43804406的博客
08-04 3042
在使用单链表时，一直有一个疑惑，初始化单链表时为什么用二级指针？ 代码如下： typedef int ElemType;/* ElemType类型根据实际情况而定，这里假设为int */ typedef struct Node { ElemType data; struct Node * next; }Node, *LinkList;/*LinkList为结构指针类型*/ void InitList(LinkList *L) /* 等价于Node **L，二级指针 */ { *L = (LinkL
链表中什么时候传二级指针
最新发布
09-03
链表中通常会使用二级指针（也称为指向指针或者双指针）的情况包括： 1. 遍历链表时寻找特定元素或满足条件的节点对：通过两个指针，一个快指针每次移动两步，另一个慢指针每次移动一步，可以在遍历时快速找到满足条件的位置，比如查找第一个相等的节点，或者判断链表是否有环。 2. 判断链表是否有交点：当两个链表的头结点分别作为两个指针时，如果它们最终指向的是同一个节点，则说明有交点；如果没有交点，快指针将先到达链表末尾。 3. 分割链表：给定两个指针，一个位于链表开始位置，另一个位于链表某个特定长度的位置之后，可以同时移动这两个指针来分割链表。 4. 调整链表结构：例如合并两个有序链表时，可能需要维护两个指针分别跟踪两个链表的当前节点。 在上述场景中，二级指针能帮助简化算法，提高效率。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值