首页 > 试题广场 > 访问单个节点的删除
[编程题]访问单个节点的删除
  • 热度指数:15066 时间限制:C/C++ 3秒,其他语言6秒 空间限制:C/C++ 32M,其他语言64M
  • 算法知识视频讲解

实现一个算法,删除单向链表中间的某个结点,假定你只能访问该结点。

给定待删除的节点,请执行删除操作,若该节点为尾节点,返回false,否则返回true

//不删这个节点了,把下个节点值copy过来,然后删除下个节点
public boolean removeNode(ListNode pNode) {
        if(pNode==null||pNode.next==null) return false;
        pNode.val=pNode.next.val; //pNode.val=pNode.val笔误这样写也能AC,测试用例无力吐槽
        pNode.next=pNode.next.next;
        return true;
    }

编辑于 2017-05-11 19:55:31 回复(7)
//先判断,再删除
class Remove {
public:
    bool removeNode(ListNode* pNode) {
        if(pNode == NULL || (pNode != NULL &&  pNode->next == NULL )) return false;
        
        pNode->val = pNode->next->val;
        pNode->next = pNode->next->next;
        delete pNode->next;
        return true;
    }
};

发表于 2016-05-05 17:15:04 回复(3)
    public boolean removeNode(ListNode pNode) {
        if (pNode == null || pNode.next == null) {
            return false;
        } else {
            pNode = pNode.next;    // 评论区某同学的提示,利用‘引用’的特点
        }
        return true;
    }

编辑于 2017-04-10 09:47:13 回复(19)
首先,不能访问之前的节点,但是可以访问后续节点。
然后,对于尾节点,直接delete掉,返回false即可。
最后,对于中间节点简记为A = pNode,利用其后续节点B = pNode->next和C = pNode->next->next变相删除。
即 A--->B--->C,要删除A。这样变相删除:把B的值给A的值域,把C的地址赋给A的地址域。
class Remove {
public:
    bool removeNode(ListNode* pNode) {
        // write code here
        // 尾节点
        if (pNode->next == NULL)
            {
            delete pNode;
            return false;
        }
        else
            {
            ListNode* nextNode;
            nextNode = pNode->next;
            pNode->val = nextNode->val;
            pNode->next = nextNode->next;
            delete nextNode;
            return true;
        }
    }
};

发表于 2016-08-14 12:02:20 回复(3)
public classRemove {
    public boolean removeNode(ListNode pNode) {
        if(pNode ==null|| pNode.next ==null)return false;
        return true;
    }
}
这样居然也可以
发表于 2018-08-27 15:36:14 回复(2)
删除中间节点,将后面结点值赋给他,然后直接删除后面结点。
注意只能这样删除中间节点,尾结点无法删除。

import java.util.*;

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Remove {
    public boolean removeNode(ListNode pNode) {
        // write code here
        if(pNode.next==null){
            return false;
        }
        pNode.val=pNode.next.val;
        pNode.next=pNode.next.next;
        return true;
    }
}

发表于 2018-03-09 09:49:10 回复(0)
    bool removeNode(ListNode* pNode) {
        // write code here
        if(pNode==NULL || pNode->next == NULL) return false;
        ListNode* tmp = pNode->next;
        pNode->val = tmp->val;
        pNode->next = tmp->next;
        delete tmp;   //回收
        return true;
    }

发表于 2017-08-17 16:08:28 回复(0)
class Remove {
public:
    bool removeNode(ListNode* pNode) {
        if (pNode->next == NULL || pNode == NULL)
        {
            return false;
        }
        ListNode *front;
        front = pNode;
        front->next=pNode;
        front->next=pNode->next;
        pNode->next=NULL;
        delete pNode;
        return true;
    }
};

发表于 2020-02-06 19:59:14 回复(0)
class Remove {
public:
    bool removeNode(ListNode* pNode) {
        ListNode* qNode = pNode->next;
        if (!qNode) { return false; }
        // swap
        pNode->val ^= qNode->val;
        qNode->val ^= pNode->val;
        pNode->val ^= qNode->val;
        // delete
        pNode->next = qNode->next;
        qNode->next = nullptr;
        delete qNode;
        return true;
    }
};

发表于 2018-12-22 22:07:55 回复(0)
刚开始题目有点没看懂,真是对不起小学老师hh,结果思考一会后,发现就是判断这个节点是否为空
/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class Remove {
public:
    bool removeNode(ListNode* pNode) {
        if(!pNode->next)
            return false;
            return true;
    }
};

发表于 2017-08-29 16:11:27 回复(1)
把下一个节点删了,在删之前把它的值拿了,可能这就是命吧
    if (pNode.next == null) return false;
    pNode.val = pNode.next.val;
    pNode.next = pNode.next.next;
    return true;

编辑于 2017-07-28 22:17:17 回复(0)
import java.util.*;

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Remove {
    public boolean removeNode(ListNode pNode) {
		ListNode cur=pNode;
        if(cur.next==null)	return false;
        else
        	return true;
    }
}

发表于 2017-07-17 20:36:55 回复(1)
/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class Remove {
public:
    bool removeNode(ListNode* pNode) {
        // write code here
        if(!pNode || !pNode->next){
            return false;
        }
        
        ListNode* p = pNode->next;
        
        pNode->val = p->val;
        
        pNode->next = p->next;
        
        return true;
    }
};
发表于 2017-05-22 21:29:07 回复(0)
import java.util.*;
//仅检测了是不是尾节点,因为我真的没看懂前面描述的和后面有什么关系,而且还通过了
public class Remove {
    public boolean removeNode(ListNode pNode) {
        if(pNode !=null&&pNode.next ==null){
            return false;
        }else{
            return true;
        }
    }
}
运行时间:33ms
占用内存:709k

发表于 2017-05-16 16:16:38 回复(2)
我觉得题目就是让检测这个节点是不是尾节点。。。两行代码通过。。。
public class Remove {
    public boolean removeNode(ListNode pNode) {
        if(pNode == null || pNode.next == null) return false;
        return true;
    }
}

发表于 2017-04-26 18:51:48 回复(1)
import java.util.*;

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Remove {
    public boolean removeNode(ListNode pNode) {
      
        
        if(pNode.next==null)
            return false;
        
        ListNode next_node= pNode.next;
        // 将待删除节点的下一个节点的值 赋值给待删除的节点,然后删除 待删除节点的下一个节点
        pNode.val=next_node.val;
        pNode.next=next_node.next;
       // 将下一个节点赋值为null  让GC回收 
      next_node=null;  

        return true;
    }
}
发表于 2017-03-26 14:59:55 回复(0)
本题高票答案一定是看了C语言的实现,才那样写的。
在Java中的引用和C语言的指针是不一样的。
public class Remove {
    public boolean removeNode(ListNode pNode) {
        // write code here
        if (pNode == null) {
            return false;
        }
        if (pNode.next == null) {
            pNode = null;
            return false;
        } else {
            pNode = pNode.next;
        }
        return true;
    }
}

编辑于 2017-03-23 13:46:07 回复(0)
思路:正常的删除一个结点思路是,给定一个链表头和一个结点。当访问到指定结点pNode时,即pHead->next 等于指定结点, pHead->next = pNode->next->next
但是现在不能访问到指定结点的前一个结点,那么可以这样做
  • 将当前结点的下一个结点覆盖当前结点,然后删除下一个结点。变相的达到删除指定结点的目的
# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Remove:
    def removeNode(self, pNode):
        if not pNode or not pNode.next:
            return False
        
        pNode.val = pNode.next.val
        pNode.next = pNode.next.next
        
        return True

发表于 2016-08-01 21:07:05 回复(0)
import java.util.*;

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Remove {
    public boolean removeNode(ListNode pNode) {
        if(pNode.next == null){
            return false;
        }else{
            pNode.val = pNode.next.val;
            pNode.next = pNode.next.next;
            return true;
        }
    }
}
编辑于 2017-04-05 20:26:23 回复(0)
class Remove {
public:
    bool removeNode(ListNode* pNode) {
        // write code here
        if(pNode->next==NULL){
            return false;
        }else{
            //由于是单向链表,所以访问不到前一个节点,只能获取pNode节点之后的所有节点
            //为了实现删除效果,可以把后续节点的值都依次往前复制,最终删除最后一个节点
            ListNode *cur=pNode,*post=cur->next;
            /*
            while(post){
                if(post->next==NULL)break;
                cur->val=post->val;
                cur=post;
                post = post->next;
            }
            cur->next=NULL;
            */
            if(post){
                cur->val=post->val;
                cur->next=post->next;
            }
            delete post;
            return true;
        }
    }
};

编辑于 2016-07-25 13:40:40 回复(2)