精华内容
下载资源
问答
  • 单链表删除指定元素出现的最后一个节点
    千次阅读
    2020-03-29 16:26:48
    struct ListNode{
        int val(x);
        ListNode*next;
        ListNode(x):
            val(x),next(NULL){}
    };
    class Solution{
    public:
        ListNode* delecttheaimlastnode(ListNode*phead,int target){
            if(phead==NULL){
                return NULL;
            }
            ListNode*pnode=phead;
            int i=0;
            while(pnode!=NULL){
                if(pnode->val==target){
                    i++;
                }
                pnode=pnode->next;//找指定元素出现次数
            }
            if(i==0){//0次就返回
                return head;
            }
            if(i==1){
                while(pnode!=NULL){
                    if(pnode->next->val==target){
                        pnode->next==pnode->next->next;
                        return phead;
                    }
                    else{
                        pnode=pnode->next;
                    }
                }
                
            }
            while(pnode!=NULL){
                if(pnode->val==target){
                    while(pnode->next->next==target&&pnode->next==target){
                        pnode=pnode->next;
                        
                    }
                    pnode->next=pnode->next->next;
                }
                else{
                    pnode=pnode->next;
                }
            }
            return phead;
        }
    };
    
    更多相关内容
  • 删除单链表最后一个节点

    千次阅读 2021-03-07 01:26:22
    链表中有多个节点,链表的最后一个节点将被删除。1. 链表中只有一个节点条件head → next = NULL将继续存在,因此,链表的唯一节点head将被指定为null。 这将通过使用以下语句来完成。ptr = head;head = NULL;free...

    从链表的末尾删除节点,有两种情况。

    链表中只有一个节点,需要删除。

    链表中有多个节点,链表的最后一个节点将被删除。

    1. 链表中只有一个节点

    条件head → next = NULL将继续存在,因此,链表的唯一节点head将被指定为null。 这将通过使用以下语句来完成。

    ptr = head;

    head = NULL;

    free(ptr);

    2. 链表中有多个节点

    条件head→next = NULL将失败,因此,必须遍历节点才能到达链表的最后一个节点。

    为此,只需声明一个临时指针temp并将其指定给链表的头部。还需要跟踪链表的倒数第二个节点。所以使用两个指针ptr和ptr1,其中ptr将指向最后一个节点,ptr1将指向链表的倒数第二个节点。通过使用以下语句来完成。

    ptr = head;

    while(ptr->next != NULL)

    {

    ptr1 = ptr;

    ptr = ptr ->next;

    }

    现在,只需要使指针ptr1指向下一个节点为NULL,并且ptr将变释放。它将通过使用以下语句来完成。

    ptr1->next = NULL;

    free(ptr);

    算法

    第1步:IF HEAD = NULL

    打印内存溢出。

    转到第8步

    [结束]

    第2步:设置PTR = HEAD

    第3步:重复第4步和第5步,同时PTR - > NEXT!= NULL

    第4步:SET PREPTR = PTR

    第5步:SET PTR = PTR - > NEXT

    [循环结束]

    第6步:SET PREPTR - > NEXT = NULL

    第7步:释放PTR

    第8步:退出

    示意图 -

    03c9f4d169360c87a9e47b33676f5b7d.png

    C语言示例代码 -

    #include

    #include

    void create(int);

    void end_delete();

    struct node

    {

    int data;

    struct node *next;

    };

    struct node *head;

    void main()

    {

    int choice, item;

    do

    {

    printf("1.Append List\n");

    printf("2.Delete node\n");

    printf("3.Exit\n");

    printf("4.Enter your choice ? ");

    scanf("%d", &choice);

    switch (choice)

    {

    case 1:

    printf("\nEnter the item\n");

    scanf("%d", &item);

    create(item);

    break;

    case 2:

    end_delete();

    break;

    case 3:

    exit(0);

    break;

    default:

    printf("\nPlease enter valid choice\n");

    }

    } while (choice != 3);

    }

    void create(int item)

    {

    struct node *ptr = (struct node *)malloc(sizeof(struct node *));

    if (ptr == NULL)

    {

    printf("\nOVERFLOW\n");

    }

    else

    {

    ptr->data = item;

    ptr->next = head;

    head = ptr;

    printf("\nNode inserted\n");

    }

    }

    void end_delete()

    {

    struct node *ptr, *ptr1;

    if (head == NULL)

    {

    printf("\nlist is empty");

    }

    else if (head->next == NULL)

    {

    head = NULL;

    free(head);

    printf("\nOnly node of the list deleted ...");

    }

    else

    {

    ptr = head;

    while (ptr->next != NULL)

    {

    ptr1 = ptr;

    ptr = ptr->next;

    }

    ptr1->next = NULL;

    free(ptr);

    printf("\n Deleted Node from the last ...");

    }

    }

    执行上面示例代码,得到以下结果 -

    1.Append List

    2.Delete node

    3.Exit

    4.Enter your choice?1

    Enter the item

    12

    Node inserted

    1.Append List

    2.Delete node

    3.Exit

    4.Enter your choice?2

    Only node of the list deleted ...

    ¥ 我要打赏

    纠错/补充

    收藏

    上一篇:链表

    下一篇:双链表

    加QQ群啦,易百教程官方技术学习群

    注意:建议每个人选自己的技术方向加群,同一个QQ最多限加 3 个群。

    展开全文
  • # 对于这种题目,循环结束条件设为快指针到达最后一个元素即可,然后倒数第几个元素,就让慢指针慢几步就好。 class Solution: def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode: # 增加头部,是...
  • 删除循环单链表末尾元素

    千次阅读 2021-05-23 06:40:16
    在循环单链表删除末尾节点有三种情况。情况1(链表为空)如果链表为空,则条件head == NULL将变为true,在这种情况下,只需要在屏幕上打印下溢并退出。if(head == NULL) { printf("UNDERFLOWn"); return; }情况2...

    在循环单链表中删除末尾节点有三种情况。

    情况1(链表为空)

    如果链表为空,则条件head == NULL将变为true,在这种情况下,只需要在屏幕上打印下溢并退出。

    if(head == NULL) { printf("UNDERFLOWn"); return; }

    情况2(链表包含单个节点)

    如果链表包含单个节点,则条件head->next == head将变为true。 在这种情况下,需要删除整个链表并使头指针空闲。 这将通过使用以下语句来完成。

    if(head->next == head) { head = NULL; free(head); }

    情况3(链表包含多个元素)

    如果链表中有多个节点,那么要删除最后一个节点,需要到达最后一个节点。 还需要跟踪链表的倒数第二个节点。 为此,需要定义两个指针ptr和preptr。 以下代码序列用于此目的。

    ptr = head; while(ptr ->next != head) { preptr=ptr; ptr = ptr->next; }

    现在,需要再做一次指针调整。需要将指针指向pretr的next指向ptr的next(即head),然后使指针ptr空闲(释放)。

    preptr->next = ptr -> next; free(ptr);

    算法

    第1步:IF HEAD = NULL 提示 “内存溢出” 转到第8步 [IF结束] 第2步:设置PTR = HEAD 第3步:重复第4步和第5步,同时PTR - > NEXT!= HEAD 第4步:SET PREPTR = PTR 第5步:SET PTR = PTR - > NEXT [循环结束] 第6步:设置PREPTR - > NEXT = HEAD 第7步:释放PTR 第8步:退出

    示意图

    c93b78e2f9f9e204b016f45fb416b45f.png

    C语言实现示例代码 –

    #include #include void create(int); void last_delete(); struct node { int data; struct node *next; }; struct node *head; void main() { int choice, item; do { printf("1.Append Listn2.Delete Node from endn3.Exitn4.Enter your choice?"); scanf("%d", &choice); switch (choice) { case 1: printf("Enter the itemn"); scanf("%d", &item); create(item); break; case 2: last_delete(); break; case 3: exit(0); break; default: printf("Please Enter valid choicen"); } } while (choice != 3); } void create(int item) { struct node *ptr = (struct node *)malloc(sizeof(struct node)); struct node *temp; if (ptr == NULL) { printf("OVERFLOWn"); } else { ptr->data = item; if (head == NULL) { head = ptr; ptr->next = head; } else { temp = head; while (temp->next != head) temp = temp->next; ptr->next = head; temp->next = ptr; head = ptr; } printf("Node Insertedn"); } } void last_delete() { struct node *ptr, *preptr; if (head == NULL) { printf("UNDERFLOWn"); } else if (head->next == head) { head = NULL; free(head); printf("Node Deletedn"); } else { ptr = head; while (ptr->next != head) { preptr = ptr; ptr = ptr->next; } preptr->next = ptr->next; free(ptr); printf("Node Deletedn"); } }

    执行上面示例代码,得到以下结果 –

    1.Append List 2.Delete Node from end 3.Exit 4.Enter your choice?1 Enter the item 90 Node Inserted 1.Append List 2.Delete Node from end 3.Exit 4.Enter your choice?2 Node Deleted

    ¥ 我要打赏   纠错/补充 收藏

    展开全文
  • 删除单向链表的最后一个节点

    千次阅读 2020-03-07 20:05:42
    分为三个步骤: 1、找到倒数第二个内存,把它的指针域置为NULL; 2、将最后一个节点所占用的内存(堆内存)释放掉; 第一步:

     

     

    具体操作:

    1、封装一个生成链表的函数(createlist),一个遍历并打印链表的函数(printlist),一个删除链表最后节点的函数(deletelist需要判断是否只剩1个节点);

    2、生成一个包含5个节点的单向链表;

    3、调用5次删除节点的函数,完成删除,其中第五次由于只剩一个节点无法删除。

    关键点:

    1)找到倒数第二个节点{pTemp->next->next=NULL时,确定了最后一个节点,使得pHead=pTemp,而pTemp->nex(在移位前)则是倒数第二的节点},

    2)将最后一个节点所占用的内存(堆内存)释放掉;pTemp = pTemp->next操作使得节点发生移位,之后再free(pTemp->next)

    3)将新的最后一个节点(之前的倒数第二个节点)的指针域置为NULL(移位后的pTemp->next=NULL);

    /*
    *copyright(c) 2018,HH
    *All rights reserved.
    *作 者:HH
    *完成日期:2020年3月7日
    *版本号:v1.0
    *
    *问题描述:生成一条包含5个节点的单向链表,然后从尾部开始依次删除,直至剩下头部节点
    *输入描述:学生C
    *程序输出:学生A、学生C、学生C;。
    *备注:
    思考如何
    *1)获取链表中指定元素的位置;
    *2)获取单链表中结点个数;
    *3)链表插入or删除
    *4)两个链表的合并
    *5)链表倒置
    *6)遍历链表
    */
    
    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    
    struct  Node
    {
    	char name[32];
    	Node  *next;
    };
    
    
    //创建一条链表,拥有N个节点,尾插法
    Node  *   CreateList(int  N)
    {
    	Node  *pHead = NULL;//始终指向第一个节点的首地址,没有节点存在时为NULL
    	Node  *pTail = NULL;//始终指向最后一个节点的首地址,没有节点存在时为NULL
    
    	for (size_t i = 0; i < N; i++)
    	{
    		Node  * pNode = (Node *)malloc(sizeof(Node));//节点生成公式!!!!!pNode为指向所生成的节点的指针
    		sprintf(pNode->name, "学生%d", i+1);//把格式化的数据写入某个字符串缓冲区
    		pNode->next = NULL;
    
    		if (pHead == NULL)//如果是第一个节点
    		{
    			pHead = pNode;
    		}
    		else
    		{
    			pTail->next = pNode;
    		}
    		pTail = pNode;
    	}
    
    	return  pHead;//返回链表头结点的指针
    }
    
    
    //打印一条链表
    void  PrintList(Node  *pHead)
    {
    	while (pHead!=NULL)
    	{
    		printf("%s    ", pHead->name);
    		pHead = pHead->next;//pHead的改变不影响实参,因为是参数的拷贝
    	}
    	printf("\n");
    }
    
    
    //删除链表的尾部节点
    Node *   DeleteTail(Node *pHead)
    {
    	//需要判断这个链表是否只有一个节点,不存在倒数第二个节点
    	if (pHead->next == NULL)
    	{
    		printf("当前链表只有一个节点\n");
    		free(pHead);//删完后,这条链表一个节点也没有了
    		return  NULL;
    	}
    
    
    	Node *pTemp = pHead;
    	//需要获取尾部节点的前一个节点指针(因为我们要把前一个节点的next设置为NULL)
    	
    	while (pTemp->next->next!=NULL) //获取倒数第二个节点的指针
    	{
            //当前节点下一个节点的指针域不是NULL时,移位到下一个节点!!!
    		pTemp = pTemp->next;//pTemp的改变不影响实参
    	}
    
    	printf("当前节点是:%s  \n", pTemp->name);
    
    	//删除最后一个节点的内存!!!
    	free(pTemp->next);
    	//将倒数第二个的next置为NULL,让倒数第二个变成尾节点!!!
    	pTemp->next = NULL;
    
    
    	return pHead;
    }
    
    
    int main()
    {
    	Node  *pHead= CreateList(5);//生成链表
    	PrintList(pHead);//打印链表
    
    	pHead = DeleteTail(pHead);//删除最后一个节点
    	PrintList(pHead);//打印链表
    
    	pHead = DeleteTail(pHead);//删除最后一个节点
    	PrintList(pHead);//打印链表
    
    	pHead = DeleteTail(pHead);//删除最后一个节点
    	PrintList(pHead);//打印链表
    
    	pHead = DeleteTail(pHead);//删除最后一个节点
    	PrintList(pHead);//打印链表
    
    	//接受新的pHead
    	pHead =DeleteTail(pHead);//删除最后一个节点
    	PrintList(pHead);//打印链表
    
        return 0;
    }
    
    

     

    展开全文
  • L是一个带头结点的单链表,函数ListLocateAndDel_L(LinkList L, ElemType x)要求在链表中查找最后一个数据域取值为x的节点并将其删除。例如,原单链表各个节点的数据域依次为1 3 1 4 3 5,则ListLocateAndDel_L(L,3)...
  • 单链表删除某个元素的操作

    千次阅读 2021-05-21 11:19:53
    单链表删除第i个数据结点的算法思路:声明一结点p指向链表第一个结点,初始化j从1开始;当j < i时,就遍历链表,让p的指针向后移动,不断指向下一个结点,j累加 1;若到链表末尾p为空,则说明第i个元素不存在;...
  • 数据结构-有序单链表删除重复元素 void linkedlist_delete(node* head,int x){ int i; node* p = head; int count=0;//后面计算步长使用 while(p!=NULL){//使p指针找到待删除元素x(定位) if
  • 算法 单链表删除重复元素

    千次阅读 2020-05-04 12:12:34
    1.删除重复的元素,保留一个 leetcode题目 代码: /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ class ...
  • 编写一个算法,逐个输出 顺序表 中所有数据元素。设数据元素对的数据类型为int型 题目分析:   要挨个输出顺序表,那咱就得先有一个顺序表才对呀,所以虽然题目中虽然只说输出顺序表中的所有元素,但我们要先...
  • C++删除单链表指定元素

    千次阅读 2021-06-12 21:03:03
    这道题目的棘手之处就在于头结点的处理上,我们知道如果想要删除一个节点,只要让待删除节点前驱的Next指向待删除节点的后继即可,那么如果头结点就是待删除的呢?对于头结点并不存在前驱,而且C++在堆区开辟的内存...
  • s的作用:作为一个前驱,主要是前驱是为了确保在删除最后一个结点的时候,前一个结点指向的是空值(体现在43行) 3、打印输出最后的链表 具体代码 #include<stdio.h> #include<stdlib.h> typedef int ...
  • 一个排序的链表中,存在重复的结点,请删除该链表中重复的结点,重复的结点不保留。 样例1 输入:1->2->3->3->4->4->5 输出:1->2->5 样例2 输入:1->1->1->2->3 输出:2->...
  • 1. 已知单链表A,编写一个算法,删除单链表中第一个最大元素。 2. 已知单链表L, 编写一个算法,删除其重复的结点(只保留一个)。
  • 删除单链表中指定元素

    千次阅读 2019-08-05 21:46:18
    在0(1)时间内删除链表节点 每个节点只有后继没有前驱 分析: 要考虑三种情况,链表只有一个元素、要找的这个节点的next为空他在...如果是就一个元素删除头部返回为空。 public static class Node{ Node next; ...
  • 链表例题之表长

    2022-03-29 11:28:46
    单链表最后一个元素后插入一个新元素 A 头指针是指向第一个元素(结点)的指针。 当删除单链表中的第一个元素时只需要将头指针指向第二个元素,然后释放第一个元素储存空间申请的内存。与链表长度无关。 ...
  • L是一个带头结点的单链表,函数ListLocateAndDel_L(LinkList L, ElemType x)要求在链表中查找最后一个数据域取值为x的节点并将其删除。例如,原单链表各个节点的数据域依次为1 3 1 4 3 5,则ListLocateAndDel_L(L,3)...
  • 单链表删除所有重复元素

    千次阅读 2018-07-08 11:30:43
    直接上代码:package ... * 删除链表中所有指定的元素 * 如: 1-&gt;2-&gt;3-&gt;2-&gt;5-&gt;null 删除2 * 删除后 1-&gt;3-&gt;5-&gt;null * * @author hanxiaofan...
  • 单链表中重复元素删除

    千次阅读 2020-03-17 17:19:50
    按照数据输入的相反顺序(逆位序)建立一个单链表,并将单链表中重复的元素删除(值相同的元素只保留最后输入的一个)。 Input 第一行输入元素个数 n (1 <= n <= 15); 第二行输入 n 个整数,保证在 int 范围...
  • 题目:设一个带头结点的单链表所有元素的数据值无序,试编写函数删除表中介于给定的两个值(作为函数参数给出)之间的元素。 分析: 分别设置pre,p,r指针,遍历,符合条件便进行删除。 代码: struct Link { ...
  • 删除单链表的第一个结点

    千次阅读 2020-09-03 16:42:46
    ElemType DeleteFront(SqList &HL) { if(HL==NULL) { cerr<<"空表"<<endl; exit(1); } LNode *p=HL; HL=HL->next; ElemType temp=p->data; delete(p); return temp;...}
  • 因为是删除的是单链表中的重复元素,这和删除单链表中值为x的元素有区别。例如给出组数:1 2 2 3。前者得到的结果是1 2 3;后者删除2,得到1 3。 算法思想: 本算法适用于事先所得到的单链表元素是有序的,即...
  • 第二行输入一个整数k,表示删除倒数第k个结点。 【输出形式】 输出删除单链表的所有元素。 【样例输入1】 10 20 30 40 50 e 3 【样例输出1】 10 20 40 50 【样例输入2】 10 20 30 40 50 60 70 80 90 100 ...
  • 有趣的数据结构算法4——单链表插入元素删除元素单链表插入元素单链表删除元素实现代码GITHUB下载连接 关于什么是单链表以及如何进行单链表的生成、遍历等操作大家可以关注我的另篇博文《有趣的数据结构算法3...
  • 链表中的数据是以结点来表示的,每结点的构成:元素(数据元素的映象) + 指针(指示后继元素存储位置),元素就是存储数据的存储单元,指针就是连接每结点的地址数据。 “结点的序列”表示线性表称作线性链表...
  • 题目:删除带头结点的单链表中重复值的元素(即让每种值的元素只有一个)解题思路:用一个动态辅助存储数组,每次要向辅助数组中放入元素时,让辅助数组的长度加1,最长时与单链表一样长,设一个指针p,让它指向头结点...
  • void delminnode(LinkNode * & L){ LinkNode *r=L,*p=L->next,*q=p->next,*s=p; //p总是指向最小结点,r总是指向p的前驱结 点,q遍历,s指向q的... } } //删除p结点 r->next = p->next; free(p); }
  • 把链表元素和链表索引分别储存在两list里。 listvalue = [1, 5, 6, 2, 7, 3] listright = [3, 2, 4, 5, -1, 1] 添加元素元素添加时,要先让新元素指针指向后面的元素,再让他前面的元素指针指向新元素!!...
  • 问题:对于一个没有头指针的单链表一个指针指向此单链表中间的节点(不是第一个,也不是最后一个),将该节点从单链表删除。 思路:获取该节点的下一个节点,将此节点与下一个节点进行交换,删除其下一个节点...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 35,851
精华内容 14,340
关键字:

删除单链表最后一个元素

友情链接: jsq.rar