精华内容
下载资源
问答
  • 删除链表指定元素
    2020-11-11 14:11:29

    题目链接

    难度:简单       类型: 链表

    删除链表中等于给定值 val 的所有节点。

    示例

    输入: 1->2->6->3->4->5->6, val = 6

    输出: 1->2->3->4->5

    解题思路

    遍历链表,断掉所有节点值等于val的链

    cur表示当前的节点,pre代表cur的前一个节点

    当cur.val == val时,pre.next = cur.next,这样,就跨过了这个节点,此时,cur也要指向cur.next

    当cur.val != val时,此时不用删除,则pre=pre.next,cur=cur.next

    注意:

    并不是每一步都更新pre的,因为pre指向的节点的值必须时不等于val,当删除一个节点时,并不知道下一个节点是否也等于val,所以不能更新pre

    特殊情况:

    要考虑第一个节点要被删除的情况

    代码实现

    # Definition for singly-linked list.

    # class ListNode:

    # def __init__(self, x):

    # self.val = x

    # self.next = None

    class Solution:

    def removeElements(self, head: ListNode, val: int) -> ListNode:

    pre = ListNode(0)

    dummy = pre

    pre.next = head

    cur = head

    while cur:

    if cur.val == val:

    pre.next = cur.next

    else:

    pre = pre.next

    cur = cur.next

    return dummy.next

    更多相关内容
  • 删除链表指定元素

    千次阅读 2019-11-27 18:43:08
    3 删除链表中的指定元素 #include <stdio.h> #include <stdlib.h> #include<malloc.h> #include "test1.h" /* 创建一个结构体 */ typedef struct Node { int data;//数据 struct Node *nex...

    本段代码实现了

    1 新建链表

    2 输出链表

    3 删除链表中的指定元素

    #include <stdio.h>
    #include <stdlib.h>
    #include<malloc.h>
    #include "test1.h"
    
    /*
    创建一个结构体
    */
    typedef struct Node {
    	int data;//数据
    	struct Node *next;//下一个结点的指针
    }Node;
    int count = 0;//记录链表的长度
    
    Node *InitList() {
    	Node *head;//定义头指针
    	Node *q, *p;//定义两个结构体指针用于后面迭代
    	head = (Node *)malloc(sizeof(Node));
    	q = head;
    	while (1)
    	{
    		count++;
    		p = (Node *)malloc(sizeof(Node));
    		printf("请输入第%d个数: (如需结束输入0):   ", count);
    		scanf_s("%d", &p->data);
    		if (p->data == 0) {
    			return head;
    		}
    		//在迭代插入新的节点的过程中一直使P指向新的节点,q指向当前节点
    		p->next = NULL;
    		q->next = p;
    		q = p;
    	}
    }
    
    void showList(Node *m) {
    	Node *p;
    	p = m->next;//让p指针指向第一个节点
    	while (p!=NULL)
    	{	
    		//注意头指针的数据是不需要输出的
    		printf("%d\n", p->data);
    		p = p->next;
    	}
    }
    void DeleteListItem(Node *n,int x) {
    	Node *p,*q,*pre; //p为循环指针,q指向需要删除的指针, pre始终为当前指针的前一位,类似双链表
    	p = n->next;//让p指向第一个节点,跳过头节点
    	pre = n;
    	while (p!=NULL)
    	{
    		if (p->data==x)
    		{	
    			printf("找到要删除的数据%d---%d\n",p->data,x);
    			q = p;//q指针指向需要删除的指针
    			p = p->next;//循环指针跳到下一个位置
    			pre->next = p;//此时,可以理解为前驱节点跳过要删除的点,next指向P
    			free(q);//释放内存
    			count--;
    		}else
    		{
    			pre = p;
    			p = p->next;
    		}
    	}
    }
    
    int main() {
    	//创建好了一个链表
    	Node *m = InitList();
    	//输出链表中的数据信息
    	showList(m);
    	printf("请输入需要删除的元素: ");
    	int d;
    	scanf_s("%d", &d);
    	//删除链表中指定元素
    	DeleteListItem(m, d);
    	//删除完再输出数据
    	printf("删除了指定元素后的列表:\n", d);
    	printf("链表总长度为:%d\n", count);
    	showList(m);
    	system("pause");
    	return 0;
    }
    
    展开全文
  • 本小程序是对于循环双向链表删除指定元素 考虑几种边界情况!
  • C++删除单链表中指定元素

    千次阅读 2022-04-29 11:41:08
    C++删除单链表指定元素
    // 删除单链表指定元素5
    #include <iostream>
    #include <vector>
    using namespace std;
    
    //节点定义:
    struct ListNode {
    	int val;
    	ListNode* next;
    	ListNode(int x) : val(x), next(nullptr) {}
    };
    class Solution {
    public:
    	ListNode* removeElements(ListNode* head, int val) {
    		ListNode* dummyHead = new ListNode(0);//创造个虚拟头节点,便于操作链表
    		dummyHead->next = head;
    		ListNode* cur = dummyHead;
    		while (cur->next != NULL) {
    			if (cur->next->val == val) {
    				ListNode* tmp = cur->next;
    				cur->next = cur->next->next;
    				delete tmp;
    			}
    			else {
    				cur = cur->next;
    			}
    		}
    		head = dummyHead->next;//如果是删除头节点就需要这行
    		delete dummyHead;
    		return head;
    	}
    };
    //创造节点
    void CreateList(ListNode *head) {
    	vector<int> nums = { 1,2,3,3,1,5,1 };
    	ListNode *p = head;
    	for (int i = 1; i < nums.size(); ++i)
    	{
    		p->next = new ListNode(nums[i]);
    		p = p->next;
    	}
    }
    //输出节点
    void PrintList(ListNode *head) {
    	ListNode *p = head;
    	while (p != NULL)
    	{
    		cout << p->val << endl;
    		p = p->next;
    	}
    }
    int main() {
    	ListNode* head = new ListNode(1);//创造头节点
    	CreateList(head);
    	Solution List;
    	ListNode* ret = List.removeElements(head, 5);
    	PrintList(ret);
    	system("pause");
    	return 0;
    }
    
    
    
    展开全文
  • 链表: 简单列表 双端链表 定义链表 class ListNode_handle: def __init__(self): self.cur_node = None def add(self, data): # add a new node pointed to previous node node = ListNode() # print...

    一、链表种类

    简单列表:包含 val 和next指针

    双端链表: 包含val 和 pre、next指针

    二、定义链表

    class ListNode_handle:
        def __init__(self):
            self.cur_node = None
    
        def add(self, data):
            # add a new node pointed to previous node
            node = ListNode()
            node.val = data
            node.next = self.cur_node
            self.cur_node = node
            return node
    
        def print_ListNode(self, node):
            while node:
                print('\nnode: ', node, ' value: ', node.val, ' next: ', node.next)
                node = node.next
    
        def reverse(self, nodelist):
            list = []
            while nodelist:
                list.append(nodelist.val)
                nodelist = nodelist.next
            result = ListNode()
            result_handle = ListNode_handle()
            for i in list:
                result = result_handle.add(i)
            return result
    
    
    
    # node_list = [5,3,4,1,6]
    list_handle = ListNode_handle()
    l1 = ListNode()
    l1_list = [1, 8, 3]
    for i in l1_list:
        l1 = list_handle.add(i)
    l1 = list_handle.reverse(l1)
    list_handle.print_ListNode(l1)

    输出结果:

    三、删除链表中的一个元素

    删除链表中的元素思想就是找到这个元素的下一个元素赋值给需要删除的元素,然后把当前这个元素指针指向需要删除元素的后两个值

    class ListNode1:
        def __init__(self, x):
            self.val = x
            self.next = None
    
    
    class Solution:
        """
        @param: head: a ListNode
        @param: val: An integer
        @return: a ListNode
        """
    
        def removeElements(self, head, val):
            # write your code here
            tem_head = tem = ListNode1(-1)
            head_tem = head
            # 遍历一遍链表然后发现和val不相等就加入tem后
            while head_tem:
                if head_tem.val != val:
                    tem.next = head_tem
                    tem = tem.next
                # 无论相不相等都需要继续遍历,
                head_tem = head_tem.next
            # 最后结尾的时候一定要加上None,否则tem的下一位很有可能还有其他元素
            tem.next = None
            return tem_head.next
    
    
    head = l1
    val = 3
    res = Solution().removeElements(head, val)
    # list_handle.print_ListNode(l1)
    while l1:
        print(f'node---: {l1},value:{l1.val},next:{l1.next}')
        l1 = l1.next

    输出结果:

    四、如何合并两个有序链表

    # Definition for singly-linked list.
    # class ListNode:
    #     def __init__(self, val=0, next=None):
    #         self.val = val
    #         self.next = next
    
    class Solution:
        def mergeTwoLists(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
            prehead = ListNode(-1)
    
            prev = prehead
            while l1 and l2:
                if l1.val <= l2.val:
                    prev.next = l1
                    l1 = l1.next
                else:
                    prev.next = l2
                    l2 = l2.next            
                prev = prev.next
    
            # 合并后 l1 和 l2 最多只有一个还未被合并完,我们直接将链表末尾指向未合并完的链表即可
            prev.next = l1 if l1 is not None else l2
    
            return prehead.next

    输出结果: 

    展开全文
  • 主要介绍了Java链表中元素删除的实现方法,结合实例形式分析了java只删除链表中一个元素的相关操作原理、实现方法与注意事项,需要的朋友可以参考下
  • 删除单链表指定元素

    千次阅读 2020-07-14 17:53:50
    给定单链表,删除链表中指定等于指定元素的节点。 代码: /** * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ ListNode* removeElements(ListNode* ...
  • 采用C语言实现:完整删除链表指定位置的元素的代码。 原链表:3->4->5。现在要删除位置为2处的元素。 删除后的链表:3->5。 #include <stdio.h> #include <stdlib.h> #include <MacTypes...
  • 19. 删除链表的倒数第 N 个结点  「题目:」  给你一个链表,删除链表的倒数第 n 个结点,并且返回链表的头结点。  「示例:」  输入:head = [1,2,3,4,5], n ...
  • 链表删除指定元素算法

    千次阅读 2019-06-07 14:23:22
    链表删除指定元素算法 我们只需要分情况理清楚就很简单 在算法分析的时候记清楚自己的思路是最重要的 只要链表里有一个元素与给定的元素不相同 第一次与给定元素不相同的节点就为头节点 1:改变头节点 2:不改变头...
  • 1.删除链表元素 例子:1->2->3->4->5 删除也分两种情况,一种是否是删除头结点,二是正常删除链表的结点。 (1)删除头结点(切记,链表无论是插入还是修改还是删除,一旦动了头结点一定要返回一个新...
  • 单链表的删除某个元素的操作

    千次阅读 2021-05-21 11:19:53
    昨天我们谈了关于单链表的插入操作,今天我们就来看看与插入操作对应的删除操作。前面了解了链表的插入,现在删除就简单了,因为是个反...若到链表末尾p为空,则说明第i个元素不存在;否则査找成功,将欲删除的结...
  • LintCode——删除链表中的元素

    千次阅读 2016-04-24 20:25:45
    删除链表中等于给定值val的所有节点。 样例: 给出链表 1->2->3->3->4->5->3, 和 val = 3, 你需要返回删除3之后的链表:1->2->4->5。 分析: 先判断链表的头节点是否为要删除的节点,若是,将head...
  • 使用 clear() 方法来删除链表中的元素 完整代码 import java.util.*; public class Main { public static void main(String[] args) { LinkedList<String> lList = new LinkedList<String>(); ...
  • 参考:链表的12种基本操作(C++实现) 链表的几个基本操作代码只要弄懂指针、链表的数据结构就不难实现,代码如下,不懂得话可以留言询问,有错误的话请指正 #include<iostream> using namespace std; //定义...
  • C++删除单链表指定元素

    千次阅读 2021-06-12 21:03:03
    C++删除单链表指定元素 对于C++单链表的创建与打印操作之前已经讲述过,那么普通的元素删除也可以很容易实现。在力扣203.移除链表元素中提出了一种元素删除操作,题目如下: 本来觉得很简单,但是在实现的过程中遇到...
  • 给你一个链表的头节点 head 和一个整数 val ,请你删除链表中所有满足 Node.val == val 的节点,并返回 新的头节点 。 示例 1: 输入:head = [1,2,6,3,4,5,6], val = 6 输出:[1,2,3,4,5] 示例 2: 输入:head = ...
  • //这是删除链表指定元素,包括链表中所有符合这一元素的结点void dele(node *head,int m,int n) { node *p,*q; p = head; q = head->next; while(q){ if(q->data==m){//当q数据域与m相等时,q的前驱p的下一...
  • 从单向链表删除一个元素 一、题目 从单向链表的中删除一个元素。 二、基本思想 1、遍历整个链表; 2、找到数据域值等于要删除元素的节点; 3、将数据域值等于要删除元素的节点的上一节点的 “next”...
  • 创建一个链表(有头结点),指定链表的大小n,输入链表的n个元素,创建链表,输入要删除的值e,将链表L中所有值为e的元素删除,并输出删除元素后的链表。 仅有一组测试数据 第一行:输入一个整数n表示链表的长度(1...
  • #include #include typedef struct node{ int data; struct node *next;...//创建一个链表  LinkList *Creatlist_L(LinkList *L,int n){ LinkList *p,*h; L=(LinkList*)malloc(sizeof(LinkList)); L->n
  • 算法:删除链表节点

    千次阅读 2022-03-17 20:52:49
    237. 删除链表中的节点 请编写一个函数,用于 删除单链表中某个特定节点 。在设计函数时需要注意,你无法访问链表的头节点 head ,只能直接访问 要被删除的节点 。 题目数据保证需要删除的节点 示例 1: 输入:...
  • 删除结点的步骤 找到该结点的前一个结点 进行删除操作。 具体删除方式:我们假设要删除的节点是 i ,那我们只需要找到 i 的前驱 p , 然后让 p -> next =p -> next -> next,这样就跳过了 i 这个节点,...
  • /本程序中包含对双向链表的::创建、初始化、插入、删除链表长度、查找指定元素的位置以及双向链表的销毁/ #include<stdio.h> #include<stdlib.h> typedef int Elemtype; typedef struct linknode { ...
  • 构造双向链表删除指定节点: public class NodeTest { static class MyNode { int val; MyNode preNode; MyNode nextNode; public MyNode(int val, MyNode preNode, MyNode nextNode) { this.val = val;...
  • 去美菜网面试,第一道算法笔试题就是这个,题目很清楚,删除链表指定值的节点,假定有这样的链表:1->2->6->3->4->5->6,现在要求删除值为6的节点,输入数组[1,2,6,3,4,5,6],要求输出:[1,2,3,...
  • 递归删除链表中的指定元素x

    千次阅读 2017-10-07 22:01:58
    问题描述:递归删除链表中的x 说明:此处要注意的是,在递归删除x的时候,中间并没有产生断链。因为函数传递的是引用。 关于引用,这次又详细的查了一下。特说明如下:其实引用,在教材上被解释成别名。就是给...
  • 【数据结构算法】③、双向链表和双向循环链表的实现、双向链表的创建-遍历-插入-删除-删除指定元素-查询指定元素、双向循环链表的创建-遍历-插入删除
  • 删除指定节点 //删除某个结点 int list_delete(linklist H,int pos){ if(H==NULL){ printf("删除结点失败,链表为空!\n"); return -1; } //获取要删除结点的上一个结点(前驱) listnode *lastnode = list_...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 141,908
精华内容 56,763
关键字:

删除链表指定元素