链表的插入删除操作中，p != NULL 和 p->next !=NULL的区别

最新推荐文章于 2024-10-26 21:32:28 发布
原创 最新推荐文章于 2024-10-26 21:32:28 发布 · 4.1k 阅读 · 19 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文探讨了在链表操作中，条件p != NULL与p->next != NULL的区别。前者在遍历到末尾时会将p设为NULL，后者则允许在最后一个节点进行操作。在查找和插入过程中通常使用p != NULL，而在删除操作时，应使用p->next != NULL来确保正确判断节点数据。

1、首先两个表达式的输出情况

while(p!=NULL)
{
    printf("%d",p->data);
    p=p->next;
}

第一步：p指向第一个节点，第一个节点数据不为空；打印数据：1；p=p->next,指向第二个节点； 
第二步：p指向第二个节点，第二个节点数据不为空；打印数据：2；p=p->next,指向第三个节点； 
第三步：p指向第三个节点，第三个节点数据不为空；打印数据：3；p=p->next,指向第四个节点； 
第四步：p指向第四个节点，第四个节点数据不为空；打印数据：4；p=p->next,指向第五个节点； 
第五步：p指向第五个节点，第五个节点数据不为空；打印数据：5；p=p->next,指向第六个节点（不存在）； 
第六步：p指向第六个节点（不存在），p为空；退出循环。

while(p->next!=NULL)
{
    printf("%d",p->data);
    p=p->next;
}
第一步：p->next指向第二个节点，第二个节点数据不为空；打印数据：1；p=p->next,指向第二个节点； 
第二步：p->next指向第三个节点，第三个节点数据不为空；打印数据：2；p=p->next,指向第三个节点； 
第二步：p->next指向第四个节点，第四个节点数据不为空；打印数据：3；p=p->next,指向第四个节点； 
第三步：p->next指向第五个节点，第五个节点数据不为空；打印数据：4；p=p->next,指向第五个节点； 
第四步：p->next指向第六个节点（不存在），第六个节点为空；退出循环

2、说明

前一个：p != NULL -- 一直到最后未查找到时，p为NULL，对p进行操作了，如p->data等

后一个： p->next !=NULL--一直到最后未查找到时，p为最后一个节点，可以对p进行操作判断其数据等

 

3、什么时候使用

查找、插入时，使用p != NULL

删除时，使用p->next !=NULL，这样可以对p->data的数据进行判断

 

p!= NULL 还是 P-＞next!=NULL
looeyWei的博客
08-25 8127
在学习C语言指针的时候, 我常常会因为 "到底什么情况用p!=NULL, 什么情况用p->next!=NULL" 而头痛 我举个栗子 PNODE deleteNode(PNODE head, int data) { PNODE p = head, temp; if (head == NULL) { printf("链表为空!\n"); return head; }...
讨论p!=NULL和p->next!=NULL的区别（重点想了解最后p指针的位置）
充满好奇的threecat
02-18 7703
前言： 由于在某个题目中卡住了，发现对于链表的知识是有所欠缺的。（呜呜呜，不小心把有头结点的和没有头结点的指针中p指针在循环后指向的位置弄错了）。所以这里就利用编译器重新设置了实验组，请看代码（C++）： #include<iostream> using namespace std; typedef struct LNode{//首先我们定义结构体 int dat...
链表p != NULL 和 p->next !=NULL区别
LearningNote
04-25 1万+
while(p!=NULL) { printf("%d",p-&gt;data); p=p-&gt;next; } 第一步：p指向第一个节点，第一个节点数据不为空；打印数据：1；p=p-&gt;next,指向第二个节点； 第二步：p指向第二个节点，第二个节点数据不为空；打印数据：2；p=p-&gt;next,指向第三个节点； 第三步：p指向第三个节点，第三个...
非循坏单链表中while(p!=NULL)和while(p-＞next!=NULL)的区别
Liutianshuo6的博客
10-26 347
非循坏单链表中while(p!=NULL)和while(p->next!=NULL)的区别
单链表里，如果p->next为NULL，那么引用 p->next->next 会报错
MonkeyMonkeyGo
05-16 6878
typedef struct Node{int Data;NODE* next;}NODE;NODE a;NODE p;p-&gt;next = a;p-&gt;next-&gt;next 相当于 a-&gt;next 这是ok的;但当p-&gt;next = null,p-&gt;next-&gt;next 这是不存在的，null为空，又不是NODE类型，怎么会有next呢。所以这是会报错的...
void insert_sort(Linklist &L){ Lnode *p,*pre,*r; p=L->next; r=p->next;//r保持*p后继结点指针，以保证不断链 p->next=NULL;//构造只含一个数据结点的有序表 p=r; while(p!=NULL){ r=p->next； pre=L; while(pre->next!=NULL&&pre->next->data <p->data){ pre=pre->next; }//在有序表中查找插入*p的前驱结点*pre p->next=pre->next;//将*p插入到*pre之后 pre->next=p; p=r;//扫描原单链表中剩下的结点 } }
10-16
= NULL && pre->next->data < p->data){ pre = pre->next; } // 将 p 节点插入到 pre 之后 p->next = pre->next; pre->next = p; // p 指向下一个未排序节点 p = r; } } ``` ### 可能存在的问题 1. **代码...
#include<stdio.h> #define MAXSIZE 100 using namespace std; typedef int ElemType; struct Node{ ElemType data; Node *prev,*next; }; Node* InitNode(){ Node* H=new Node; H->data=0; H->next=NULL; H->prev=NULL; return H; } //头插法 int InsertHead(Node* H,ElemType e){ Node* p = new Node; p->data=e; p->next=H->next; if(H->next!=NULL){ H->next->prev=p; } H->next=p; return 1; } //遍历 void ListNode(Node* H){ Node *p=H->next; while(p!=NULL){ printf("%d ",p->data); p=p->next; } printf("\n"); } //获取尾节点地址 Node* get_tail(Node* H){ Node* p = H ;//遍历指针 while(p->next!=NULL) { p=p->next; } return p; } //尾插法 Node* InsertTail(Node* tail,ElemType e) { Node* p= new Node; p->data=e; p->prev=tail; tail->next=p; return p; } //在指定位置插入数据 int insertNode(Node* H,int pos,ElemType e){ Node* p = H; int i = 0; while(i<pos-1){ p=p->next; i++; if(p == NULL){ printf("位置输入错误"); return 0; } }//找到指定位置的前一个结点 Node* q =new Node; q->data=e; q->prev=p; q->next=p->next; if(p->next!=NULL){ p->next->prev=q; } p->next=q; return 0; } int main(){ Node* list=InitNode(); //头插法 InsertHead(list,1); InsertHead(list,2); InsertHead(list,3); ListNode(list); //尾插法 Node* tail=get_tail(list); tail=InsertTail(tail,11); tail=InsertTail(tail,12); tail=InsertTail(tail,13); ListNode(list); //在指定位置插入 insertNode(list,3,22); ListNode(list); return 0; }代码哪里有问题
最新发布
11-24
3. **链表为空的情况**：在 `TraverseList` 函数中，没有对链表为空（即 `L->next == NULL`）的情况进行特殊处理，虽然代码逻辑上不会出错，但可以添加一些提示信息，增强代码的健壮性。 4. **资源释放**：代码中...
for(p=head->next;p!=NULL;p=p->next) for(q=p->next;q!=NULL;q=q->next)
04-29
这是一个嵌套的 for 循环，用于遍历链表中的每一个节点。其中，外层的循环变量是 p，内层的循环变量是 q...内层循环中的操作通常是在外层循环中的节点之后寻找符合条件的节点，从而进行链表的操作，例如插入、删除等。
Node * merge(Node*h1,Node*h2) { Node * p; p=(Node*)malloc(sizeof(Node)); while(h1!=NULL&&h2!=NULL) { if(h1->data>=h2->data) { p->next>=h2; h2=h2->next; } else{ p->next=h1; h1=h1->next; } p=p->next; } if(h1=NULL) { p->next=h2; } else p->next=h1; return p; }为什么无法将有序链表合并
06-12
1. 在第7行，应该是 `p->next = h1` 或者 `p->next = h2`，而不是 `p->next >= h2`。 2. 在第14行，应该是 `if(h1==NULL)`，而不是 `if(h1=NULL)`。 除此之外，这个函数并没有将两个有序链表合并成一个有序链表，...
算法步骤如下： 1. 定义两个指针p和q，分别指向链表的头结点和尾结点。 2. 循环遍历链表，判断p和q指向的节点的值是否相等，如果不相等，则链表不对称，返回false。 3. 如果p和q指向的节点的值相等，则将p指向下一个节点，q指向上一个节点，继续判断。 4. 如果p和q相遇了，说明链表对称，返回true。 5. 如果链表为空或只有一个节点，则也是对称的，返回true。 完整代码如下： bool isSymmetric(ListNode* head) { if (head == NULL || head->next == NULL) { return true; } ListNode* p = head; ListNode* q = head->prev; while (p != q && q->next != p) { if (p->val != q->val) { return false; } p = p->next; q = q->prev; } return true; }
06-03
if (head == NULL || head->next == NULL) { return true; } ListNode* p = head; ListNode* q = reverse(copy(head)); while (p != NULL && q != NULL) { if (p->val != q->val) { return false; } p = p...
单链表尾指针要置为空?为什么单链表建立完以后,比如p指向尾节点,要加上一句p->next=NULL;?
i_m_jack的博客
07-20 4166
p->next 这个数据域一般属于动态分配的，其存储单元中初始内容不可知，虽然没有初始值，但是并不是正好为空啊 不过话说回来，倒是有些语言是这样的，不过C++肯定不是 ...
链表的插入
Eric_keke的专栏
10-30 1020
链表的插入功能实现如下： 查找符合的插入位置： 1. 链表为空，把插入链表当成头节点 2. 查到位置为链表的中间元素 3. 没查到位置，加到链表的末尾 4. 查到位置为链表的头节点这里插入规则是按学号从小到大插入。#include <iostream> #include<stdio.h> #include<malloc.h> using namespace std; struct stu{
链表——删除元素或插入元素（头插法及尾插法）
明里灰的博客
03-29 4453
是一种在存储单元上非连续，非顺序的存储结构，由一系列结点组成，结点可以在运行的过程中，每个结点包括两部分：存储数据的；存储下一节点地址的。对的理解：将某个变量（例如 int a）赋值给指针，实际上就是将这个变量的地址赋值给指针，或者反过来说，指针中存储了这个变量的内存地址，指向了这个变量，通过指针就能找到这个变量。
单链表的插入问题
u014361711的博客
04-05 612
从图中我们可以看出，如果要把b这个节点删除，有两种方法： 1、让C（包括C）后面的数据整体上向前移动一个位置，把b位置的数据进行覆盖处理 2、利用a这个节点进行操作。利用a->next = a->next->next来把a的下一个指针指向c，并把b的next指针置空即可讨论： 1）第一种方法，的确可以使得b的数据被覆盖删除，但是问题是，如果c后面的数据有很多，而你又必须记下当前位置和链表尾部位
C语言中->含义，比如说 p=p->next
热门推荐
skyang在路上
06-24 9万+
注：本答案来自百度知道 jiajuehorse ->是一个整体，它是用于指向结构体、C++中的class等含有子数据的指针用来取子数据。换种说法，如果我们在C语言中定义了一个结构体，然后申明一个指针指向这个结构体，那么我们要用指针取出结构体中的数据，就要用到“->”. 举个例子： struct Data { int a,b,c; }; /*定义结构体*/ struct Data * p...
c++单链表以及循环单链表的实现以及操作
HZPHYT的博客
02-15 1445
 单链表: #include&lt;stdlib.h&gt; #include&lt;stdio.h&gt; typedef struct node{ int data; node* next; }Node,*PNode; int getlen(PNode pn){ int i=0; PNode p=pn-&gt;next; while(p!=NULL){ i++; p=p-&g...
(理解)单链表算法循环条件while(p)和while(p-＞next)有什么区别？
sunshine_r_007的博客
11-18 5709
【问题】 //在带头节点的单链表L中，删除指定位置i p = L; j = 1; while(p->next && j<i) { p = p->next; j++; } //在带头结点的单链表L中，指定位置i插入值e p = L; j = 1; while(p && j<i) { p = p->next; j++; } 单链表的删除算法中循环条件(p->next&&j<i)和插入
数据结构（C语言）——线性表一些较难理解的操作讲解
qq_43743402的博客
01-30 1145
首先介绍一下什么是线性表： 线性表分为：顺序表：顺序存储的线性表，用一组地址连续的存储单元依次存储表中数据元素。 链式表：又分为 单链表 双向链表（每个节点都有两个指针，分别指向前驱和后继系结点） 循环链表（又分为 循环单链表：尾节点的后继指向头节点、循环双向链表：在循环单链表的基础上，头结点的前驱指向尾节点） 静态链表（用数组来实现的线性表，结点的指针域使用的是相对地址） em…线性表大概就是这样的 接下来我想分享一下我个人觉得一些比较难理解的线性表的操作，我加了一些个人的理解，希望大家多多支持?????
void deval(node* header) { if (header == NULL||header->next==NULL) return; node* p = NULL; p= header->next; while (p!=NULL&&p->next != NULL) { if (p->next->data==p->data) { node* q = p->next; p->next = q->next; free(q); q = NULL; } else { p = p->next; } } }
11-09
上述代码实现的是**删除单链表中相邻的重复节点**，保留第一个出现的节点。具体来说，该函数 `deval` 接收一个链表头结点指针 `header`，遍历链表，并删除所有与前一个节点数据相同的后续节点（即去除连续重复元素）。 ### 问题分析 假设链表是这样的： ``` 1 -> 2 -> 2 -> 3 -> 3 -> 3 -> 4 ``` 经过 `deval(header)` 处理后，结果应为： ``` 1 -> 2 -> 3 -> 4 ``` 但注意：这个函数只删除“连续”重复项。例如如果是 `2->3->2`，不会删除后面的 `2`，因为它不和前面连续相等。 --- ### 完整可运行示例（C语言） ```c #include <stdio.h> #include <stdlib.h> // 定义链表节点结构 typedef struct Node { int data; struct Node* next; } node; // 删除连续重复节点 void deval(node* header) { if (header == NULL || header->next == NULL) return; node* p = header->next; // 从第一个实际节点开始比较 while (p != NULL && p->next != NULL) { if (p->next->data == p->data) { node* q = p->next; p->next = q->next; free(q); q = NULL; } else { p = p->next; } } } // 辅助函数：创建新节点 node* create_node(int data) { node* new_node = (node*)malloc(sizeof(node)); new_node->data = data; new_node->next = NULL; return new_node; } // 辅助函数：打印链表 void print_list(node* header) { node* p = header->next; // 假设 header 是带头节点的哑节点 while (p != NULL) { printf("%d ", p->data); p = p->next; } printf("\n"); } // 测试程序 int main() { // 创建带头节点的链表 node* header = create_node(0); // 哑节点，方便操作 node* cur = header; int arr[] = {1, 2, 2, 3, 3, 3, 4}; int n = sizeof(arr)/sizeof(arr[0]); for (int i = 0; i < n; i++) { node* new_node = create_node(arr[i]); cur->next = new_node; cur = new_node; } printf("原始链表: "); print_list(header); deval(header); printf("去重后链表: "); print_list(header); // 释放内存... return 0; } ``` --- ### 对原函数的逐行解释： ```c void deval(node* header) { if (header == NULL || header->next == NULL) return; ``` - 如果头指针为空或链表没有实际节点（只有头），直接返回。 ```c node* p = NULL; p = header->next; ``` - 让 `p` 指向第一个有效节点（跳过头节点）。这里多此一举可以简化为 `node* p = header->next;` ```c while (p != NULL && p->next != NULL) { if (p->next->data == p->data) { node* q = p->next; p->next = q->next; free(q); q = NULL; } else { p = p->next; } } ``` - 遍历过程中检查当前节点 `p` 和它的下一个节点 `p->next` 是否值相同。 - 若相同，则删除 `p->next` 节点（用临时指针 `q` 保存，然后释放）。 - 否则移动 `p` 到下一个节点。 ⚠️ 注意：**在删除节点后，`p` 不前进**，因为可能还有更多连续重复（如三个 3 连续）。下一次继续用 `p` 和新的 `p->next` 比较。 --- ### 潜在问题与改进建议 1. **是否需要头节点？** - 当前代码使用了 `header` 并判断 `header->next`，说明可能是带“哑节点”（dummy head）的设计。 - 如果传入的是真正的头节点（无 dummy），且链表只有一个节点，也能正确处理。 2. **不能处理非连续重复** - 如 `1->2->1`，中间的 `2` 断开了，两个 `1` 不会被去重。 - 若要全局去重，需要用哈希表记录已见元素（适用于无序链表）。 3. **内存安全** - 使用 `free()` 后置 `q = NULL` 是良好习惯，但在函数作用域内意义不大。 4. **空指针访问风险** - 条件 `p != NULL && p->next != NULL` 确保不会解引用空指针，逻辑安全。 --- ### 扩展：如何实现**完全去重**（非仅连续）？ ```c void remove_duplicates(node* header) { if (!header || !header->next) return; node* p = header->next; while (p) { node* q = p; while (q->next) { if (q->next->data == p->data) { node* temp = q->next; q->next = temp->next; free(temp); } else { q = q->next; } } p = p->next; } } ``` 这会删除链表中所有与 `p` 相同的数据（除了 `p` 自身），实现全局唯一。 --- ### 时间复杂度分析 - 当前 `deval`: O(n)，每个节点最多访问一次。 - 全局去重版本：O(n²)，嵌套循环。 --- ### 相关问题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值