精华内容
下载资源
问答
  • 链表删除指定元素算法

    千次阅读 2019-06-07 14:23:22
    链表删除指定元素算法 我们只需要分情况理清楚就很简单 在算法分析的时候记清楚自己的思路是最重要的 只要链表里有一个元素与给定的元素不相同 第一次与给定元素不相同的节点就为头节点 1:改变头节点 2:不改变头...

    链表删除指定元素算法
    我们只需要分情况理清楚就很简单
    在算法分析的时候记清楚自己的思路是最重要的
    只要链表里有一个元素与给定的元素不相同 第一次与给定元素不相同的节点就为头节点
    1:改变头节点
    2:不改变头节点

    List deleList(List p,int val){
    List r=p;
    List head=NULL;
    while(r ){
    -------if(r->data==val){ //删除指定元素我分为两种情况 删除了头节点和 没有删除头节点
    -------------if(p->data == val){//只要头节点所在的元素与val相等再回执行这条语句
    -------------p=p->next; //第一个与val不相等的节点为头节点 聊表重要的就是头指针
    -------------free( r);
    -------------r=p;
    -------------}
    ------else{
    -------------head->next=r->next;
    -------------free(r );
    -------------r=head->next; //
    -------------}
    }
    -------else{
    -------------head=r; //记录要删除节点的头一个节点
    -------------r=r->next;
    -------------}
    }
    return p;
    }

    展开全文
  • 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语言实现:完整删除链表指定位置的元素的代码。 原链表:3->4->5。现在要删除位置为2处的元素。 删除后的链表:3->5。 #include <stdio.h> #include <stdlib.h> #include <MacTypes...

    采用C语言实现:完整删除链表中指定位置的元素的代码。

    原链表:3->4->5。现在要删除位置为2处的元素。
    删除后的链表:3->5。

    #include <stdio.h>
    #include <stdlib.h>
    #include <MacTypes.h>
    
    /*定义节点*/
    typedef struct Node {
        int data;
        struct Node *next;
    } LinkedList;
    
    /*使用头插法来构建一个链表*/
    void push(struct Node **head_ref, int new_data);
    
    /*给一个指针的指针作为引用,作为这个链表的头指针,进行删除指定位置的节点*/
    void deleteNode(struct Node **head_ref, int position);
    
    /*打印链表*/
    void printList(LinkedList *node);
    
    int main() {
        LinkedList *head_ref = NULL;
        //注意这里要传取地址符
        push(&head_ref, 3);
        push(&head_ref, 4);
        push(&head_ref, 5);
        deleteNode(&head_ref,2);
        printList(head_ref);
        return 0;
    }
    
    /*
     * 头插法的几步
     * 1.定义一个新的指针,给指针申请空间,使其变成一个新的节点。
     * 2.给这个新的节点data数据域赋值。
     * 3.将这个新的节点的next指针指向原来的开始节点(原头指针指向的节点)
     * 4.将原头指针左移移动到新的节点
     */
    void push(struct Node **head_ref, int new_data) {
    
        LinkedList *new_node = (LinkedList *) malloc(sizeof(LinkedList));
        new_node->data = new_data;
        new_node->next = (*head_ref);
        (*head_ref) = new_node;
    }
    
    /*从给定节点往后打印链表*/
    void printList(LinkedList *node) {
        //节点不为空,循环
        while (node != NULL) {
            //打印节点值
            printf(" %d \n", node->data);
            //指针后移
            node = node->next;
        }
    }
    
    /*删除指定位置的的节点*/
    void deleteNode(struct Node **head_ref, int position) {
    
        //1.首先判断这个链表是否为空
        if (*head_ref == NULL) {
            return;
        }
    
        //2.创建一个指针存储头节点
        struct Node *temp = *head_ref;
    
        //3.如果这个position是0,那么直接移除掉头节点
        if (position == 0) {
            *head_ref = temp->next;
            free(temp);
            return;
        }
    
        //4.从头节点遍历,找到删除位置position的前驱节点,temp指向前驱
        for (int i = 0; temp != NULL && i < position - 1; ++i) {
            temp = temp->next;
        }
    
        //5.如果这个位置比链表还长
        if (temp == NULL || temp ->next == NULL){
            return;
        }
    
        //6.创建一个新的指针指向将要删除的节点的下一个节点
        //temp是删除节点的前驱
        //temp->next 这个节点是即将被删除的节点
        struct Node *next = temp->next->next;
        //7.删除节点
        free(temp->next);
    
        //8.将next节点连接在前驱节点temp后面
        temp->next=next;
    
    }
    

    输出:

     5 
     4 
    
    展开全文
  • 删除链表中等于给定值 val 的所有节点。 输入: 1->2->6->3->4->5->6, val = 6 输出: 1->2->3->4->5 分析: 当链表为空时,返回NULL 当链表不为空时 1.当前被删除节点是头节点(包含...
    删除链表中等于给定值 val 的所有节点。

    题目源于领扣:https://leetcode-cn.com/problems/remove-linked-list-elements/description/
    输入: 1->2->6->3->4->5->6, val = 6
    输出: 1->2->3->4->5

    分析:

    • 当链表为空时,返回NULL
    • 当链表不为空时
      1.当前被删除节点是头节点(包含只有一个节点的情况)
      2.被删除节点不是头节点

    删除元素过程(以C++代码为例)
    如图:
    在这里插入图片描述
    注意:

    1. 当删除的节点就是头结点时,新的头结点(即cur->next)就是NULL,满足删除指定val的所有元素的条件。
    2. 当判断完结点是否为头结点时,不能漏掉cur=cur->next这一句,因为指定val值的元素不止一个,所以在删除一个结点之后,还要让cur继续向后走,继续排查。
    3. 下面的C++代码和C语言代码有一点点细微的差别,C语言中有一句free(cur),但C++代码中没有,需要注意是,C语言中的链表结点是一个结构体,是由malloc开辟出来的空间,所以使用free来释放这段内存空间,是真正意义的将结点删除。而在C++代码中,涉及到类和对象,使用free释放内存仅仅释放了对象的内存,而没有调用析构函数,正确的删除对象需要delete,所以这里C++代码中不用free,删除节点实质上是将目标结点覆盖。

    完整代码:
    C++:

    /**
     * Definition for singly-linked list.
     * struct ListNode {
     *     int val;
     *     ListNode *next;
     *     ListNode(int x) : val(x), next(NULL) {}
     * };
     */
    class Solution {
    public:
        ListNode* removeElements(ListNode* head, int val) {
            ListNode* cur = head;
            ListNode* prev = NULL;
            
            //当链表为空
            if(head==NULL)
            {
                return head;
            }
            
            //当链表不为空
            while(cur)
            {
                if(cur->val == val)
                {
                    //当前节点是头节点,那么prev==NULL
                    if(prev == NULL)
                    {
                        head=cur->next;
                    }
                    else{
                        prev->next=cur->next;
                    }
                    
                    cur=cur->next;
                }
                else
                {
                    prev=cur;
                    cur=cur->next;
                }
               
            }
            return head;
        }
    };
    

    C:

    /**
    - Definition for singly-linked list.
    - struct ListNode {
    - int val;
    - struct ListNode *next;
    - };
      */
    struct ListNode* removeElements(struct ListNode* head, int val) {
          struct ListNode* cur=head;
            struct ListNode* prev=NULL;
            
            while(cur)
            {
                if(cur->val==val)
                {
                   struct ListNode* next=cur->next;
                   if(prev==NULL)
                   {
                        head=cur->next;
                   }
                   else
                   {
                       prev->next=cur->next;
                    }
                
                  free(cur);
                  cur = next;
                }
                 else
               {
                 prev=cur;
                 cur=cur->next;
                 }
           }
       
          return head;
    }
    
    展开全文
  • 递归删除链表中的指定元素x

    千次阅读 2017-10-07 22:01:58
    问题描述:递归删除链表中的x 说明:此处要注意的是,在递归删除x的时候,中间并没有产生断链。因为函数传递的是引用。 关于引用,这次又详细的查了一下。特说明如下:其实引用,在教材上被解释成别名。就是给...
  • public Item delete(int k){ if(isEmpty()) throw new RuntimeException("List is empty"); int i = 1; Node prev = null, curr = first; if(size() &gt;= k){ ... ...
  • //这是删除链表指定元素,包括链表中所有符合这一元素的结点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的下一...
  • 链表——删除指定元素

    千次阅读 2017-03-02 20:13:39
    链表-删除指定元素 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Discuss Problem Description  对于一个给定的线性表,要求删除线性表内的大于等于 min 且小于等于 max 的数,并...
  • 链表-删除指定元素

    千次阅读 2015-11-12 09:12:58
    链表-删除指定元素 Time Limit: 1000ms Memory limit: 65536K 有疑问?点这里^_^ 题目描述  对于一个给定的线性表,要求删除线性表内的大于等于 min 且小于等于 max 的数,并输出删除后的线性表 要求...
  • 删除链表指定位置节点

    千次阅读 2018-04-20 14:13:51
    给定一个链表,删除链表的倒数第 n 个节点,并且返回链表的头结点。示例:给定一个链表: 1-&gt;2-&gt;3-&gt;4-&gt;5, 和 n = 2. 当删除了倒数第二个节点后,链表变为 1-&gt;2-&gt;3-&...
  • 在双向链表删除指定元素

    千次阅读 2013-04-01 14:03:35
    #include using namespace std; class List { public: List(int num) { this->num = num; } int num; List* next; List* pre; };...//创建链表 List* createList(int count) { if(count ==
  • 删除链表指定位置的元素

    千次阅读 2016-04-16 15:30:03
    #include #include using namespace std; typedef int Elemtype; typedef struct node {  Elemtype data;  struct node* next; }; node* Greatlist(int n) //创建链表 {  node
  • void FindAndDelete(LinkList List, int data) { LinkList before = List; LinkList temp; List = List-&gt;next; while (List != NULL) { if (List-&gt;...//待删除元素 befo...
  • STL链表删除指定元素(list)

    千次阅读 2014-06-19 17:09:17
    链表-删除指定元素 Time Limit: 1000ms Memory limit: 65536K 有疑问?点这里^_^ 题目描述  对于一个给定的线性表,要求删除线性表内的大于等于 min 且小于等于 max 的数,并输出删除后的线性表 要求...
  • 使用 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; //定义...
  • 删除链表指定结点

    千次阅读 2013-06-01 21:11:12
    原题:使用后置递归法求解删除带有头结点的单链表中所有值为x的数据元素的算法。 (1)采用后置递归算法删除指定结点 #include #include #include typedef struct LNode {//定义表结点结构 char data; struct ...
  • 3,现在要删除与目标值2相等的元素删除后,链表变为1->3。 #include <stdio.h> #include <stdlib.h> #include <MacTypes.h> /*定义节点*/ typedef struct Node { int data; struct ...
  • 链表删除指定值的元素

    千次阅读 2013-11-19 20:37:32
    在网上看到很多删除链表中的元素都是指定了位置的,如何删除所有值为x的节点呢,下面以int节点的单链表为例说明: 这是C++类中的实现 void List::removeData(int data) { for(Node** cur = &m_head;*cur;) { ...
  • 给定一个链表,删除链表中的某个元素, 例如给定链表:1->2->3->4->5->6 删除节点元素5后输出:1->2->3->4->6 链表类 ListNode.java public class ListNode { int val; ListNode ...
  • 去美菜网面试,第一道算法笔试题就是这个,题目很清楚,删除链表指定值的节点,假定有这样的链表:1->2->6->3->4->5->6,现在要求删除值为6的节点,输入数组[1,2,6,3,4,5,6],要求输出:[1,2,3,...
  • LintCode——删除链表中的元素

    千次阅读 2016-04-24 20:25:45
    删除链表中等于给定值val的所有节点。 样例: 给出链表 1->2->3->3->4->5->3, 和 val = 3, 你需要返回删除3之后的链表:1->2->4->5。 分析: 先判断链表的头节点是否为要删除的节点,若是,将head...
  • void LinkList::DeleteElemAtPoint(DataType data) { ElemType * ptemp = Find(data); //查找到指定数据的节点位置 ... //删除指定位置的节点 delete ptemp; ptemp = NULL; } ``` ```
  • python---删除链表中的元素

    千次阅读 2017-11-13 10:46:50
    #! conding:utf-8 __author__ = "hotpot" ...删除链表中等于给定值val的所有节点。 给出链表 1->2->3->3->4->5->3, 和 val = 3, 你需要返回删除3之后的链表:1->2->4->5。 """ class ListNode: def __init__(self, x):
  • 指定位置插入: insert_pos_val(lk headNode, int pos, int val); #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> typedef struct LinkNode { int num; LinkNode* next; }...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 115,076
精华内容 46,030
关键字:

删除链表指定元素