精华内容
下载资源
问答
  • java--算法--在单链表中删除倒数第K个节点
    2021-03-10 07:49:13

    问题:

    在单链表中删除倒数第K个节点

    说明:

    ●让链表从头开始走到尾,每移动一步,就让 K 值减 1,当链表走到结尾时,如果K值大于0,说明不用调整链表,

    因为链表根本没有倒数第K个节点,此时将原链表直接返回即可;

    ●如果 K 值等于 0,说明链表倒数第 K 个节点就是头节点,此时直接返回head.next,也就是原链表的第二个节点,让第二个节点作为链表的头返回即可,相当于删除头节点;

    ●如果K值小于0,

    1.重新从头节点开始走,每移动一步,就让K的值加1。

    2.当K等于0时,移动停止,移动到的节点就是要删除节点的前一个节点。

    这样做是非常好理解的,因为如果链表长度为N,要删除倒数第K个节点,很明显,倒数第K个节点的前一个节点就是第N-K个节点。在第一次遍历后,

    K的值变为K-N。第二次遍历时,K的值不断加1,加到0就停止遍历,第二次遍历当然会停到第N-K个节点的位置。

    public static void main(String[] args)

    {

    Node node1 = new Node(1);

    Node node2 = new Node(2);

    Node node3 = new Node(3);

    node1.next = node2;

    node2.next = node3;

    Node node = removeLastKthNode(node1, 1);

    System.out.println(node.value);

    }

    private static Node removeLastKthNode(Node head, int lastKth)

    {

    if(head == null || lastKth < 1) return null;

    Node cur = head;

    while(cur != null)

    {

    cur = cur.next;

    lastKth --;

    }

    if(lastKth == 0) return head;

    if(lastKth < 0)

    {

    cur = head;

    while (++lastKth !=0)

    {

    cur = cur.next;

    }

    cur.next = cur.next.next;

    }

    return head;

    }

    更多相关内容
  • 主要为大家详细介绍了python实现单链表中删除倒数第K个节点的方法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 主要介绍了C++实现单链表删除倒数第k个节点的方法,结合实例形式分析了C++单链表的定义、遍历及删除相关操作技巧,需要的朋友可以参考下
  • 分享一个大牛的人工智能教程。... * 在单链表中删除指定值的节点。 * * 思路: * 直接写代码,还是要找到pre节点。 * * @author Created by LiveEveryDay */ public class RemoveNodeInList {

    分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!请轻击http://www.captainbed.net

    package live.every.day.DataStructure.List;
    
    /**
     * 题目:
     * 在单链表中删除指定值的节点。
     *
     * 思路:
     * 直接写代码,还是要找到pre节点。
     *
     * @author Created by LiveEveryDay
     */
    
    public class RemoveNodeInList {
    
        public static class Node {
            public int data;
            public Node next;
    
            public Node(int data) {
                this.data = data;
            }
        }
    
        public static Node removeNode(Node head, int data) {
            while (head != null) {
                if (head.data != data) {
                    break;
                }
                head = head.next;
            }
            Node pre = head;
            Node cur = head;
            while (cur != null) {
                if (cur.data == data) {
                    pre.next = cur.next;
                } else {
                    pre = cur;
                }
                cur = cur.next;
            }
            return head;
        }
    
        public static void main(String[] args) {
            Node node1 = new Node(1);
            Node node2 = new Node(3);
            Node node3 = new Node(2);
            Node node4 = new Node(3);
            Node node5 = new Node(1);
            node1.next = node2;
            node2.next = node3;
            node3.next = node4;
            node4.next = node5;
            removeNode(node1, 3);
            Node n = node1;
            while (n != null) {
                System.out.printf("%d ", n.data);
                n = n.next;
            }
    
        }
    }
    
    // ------ Output ------
    /*
    1 2 1
    */
    展开全文
  • 该楼层疑似违规已被系统折叠 隐藏此楼查看此楼 #include #include #include #include #include #define LEN ... 图二:删除一个节点,之后删除别的节点或者退出时,都会生成第一个节点。 请求大佬解答,万分感谢!

    该楼层疑似违规已被系统折叠 隐藏此楼查看此楼

    #include

    #include

    #include

    #include

    #include

    #define LEN sizeof(struct student) // 结构的长度

    struct student *creat(); // 建立链表

    void print(struct student *head); // 打印链表

    struct student *del(struct student *head,int num); // 删除一个节点

    struct student

    {

    int num;

    float score;

    struct student *next;

    };

    int n,temp; // 全局变量

    void main()

    {

    struct student *stu,*p;

    int m;

    stu=creat();

    p=stu;

    print(stu);

    do

    {

    printf("please enter the num to delete:");

    scanf("%d",&m);

    print(del(p,m));

    }while(m);

    system("pause");

    }

    struct student *creat()

    {

    struct student *p1,*p2,*head;

    p1=p2=(struct student *)malloc(LEN);

    printf("please enter the num:");

    scanf("%d",&p1->num);

    printf("please enter the score:");

    scanf("%f",&p1->score);

    head=NULL;

    n=0;

    while(p1->num)

    {

    n++;

    if(n==1) // 判断是否删除第一个节点

    {

    head = p1;

    }

    else

    {

    p2->next=p1;

    }

    p2=p1;

    p1=(struct student *)malloc(LEN);

    printf("please enter the num:");

    scanf("%d",&p1->num);

    printf("please enter the score:");

    scanf("%f",&p1->score);

    }

    temp=n;

    p2->next=NULL;

    return head;

    };

    void print(struct student *head)

    {

    struct student *p;

    p=head;

    printf("\nThere are %d records\n\n",n);

    if(head)

    {

    do

    {

    printf("The num.%d score is %f\n",p->num,p->score);

    p=p->next;

    }

    while(p);

    }

    }

    struct student *del(struct student *head,int num)

    {

    struct student *p1,*p2;

    if(head == NULL)

    {

    printf("An empty list\n");

    goto end;

    }

    p1=head;

    while(num != p1->num && p1->next != NULL)

    {

    p2=p1;

    p1=p1->next;

    }

    if(p1->num == num)

    {

    if(p1==head)

    {

    head=p1->next;

    }

    else

    {

    p2->next=p1->next;

    }

    printf("Delete No.%d succeed\n",num);

    n=n-1;

    }

    else

    printf("%d not been found!\n",num);

    end:

    return head;

    };

    问题:删除节点是,不删除第一个节点则没事!一旦删除第一个节点,后面输入什么都会生成第一个节点!

    246ae63c62752dabfec82416f58575b2.png

    图一:不删除第一个节点,无事发生。

    e3125fc5919286b4313bcc7be527635e.png

    图二:删除第一个节点,之后删除别的节点或者退出时,都会生成第一个节点。

    请求大佬解答,万分感谢!

    展开全文
  • 单链表的算法之删除节点 1.为什么要删除节点 ...(1)待删除节点不是尾结点的情况:首先把待删除节点的前一个节点的pNext指针指向待删除节点的后一个节点的首地址(这样就把这个节点从链表摘出来了)

    单链表的算法之删除节点
    1.为什么要删除节点
    (1)有时候链表节点中的数据不想要了,因此要删掉这个节点。

    2.删除节点的2个步骤
    (1)第一步:找到要删除的节点;第二部:删除这个节点

    3.如何找到待删除的节点
    (1)通过遍历来查找节点。从头指针+头结点开始,顺着链表依次将各个节点拿出来,按照一定的方法比对,找到我们要删除的那个节点。

    4.如何删除一个节点
    (1)待删除的节点不是尾结点的情况:首先把待删除的节点的前一个节点的pNext指针指向待删除的节点的后一个节点的首地址(这样就把这个节点从链表中摘出来了),然后将整个摘出来的节点free掉。
    (2)待删除的节点是尾结点的情况:待删除的节点是尾节点的情况:首先把待删除的尾节点的前一个节点的pNext指针指向null(这时候就相当于原来尾节点前面的一个节点变成了新的尾节点),然后将摘出来的节点free掉。

    实验编程

    #include <stdio.h>
    
    //构建一个链表的节点
    struct node
    {
        int data;        //有效数据
        struct node* pNext;  //指向下一个节点的指针
    };
    
    //创建一个链表的节点
    //返回值:指针,指针指向我们本函数新创建的节点的首地址
    struct node* creat_node(int data)
    {
        struct node* pHeader = NULL;
    
        //每创建一个新的节点,把这个新的节点和它前一个节点关联起来
        //创建一个链表节点
        struct node* p = (struct node*)malloc(sizeof(struct node));
        if(NULL == p)
        {
            printf("malloc failure\n");
            return NULL;
        }
        memset(p, 0, sizeof(struct node));
        //bzero(p, sizeof(struct node));
        p->data = data;
        p->pNext = NULL;  //将来要指向下一个节点的首地址,实际操作时将下一个节点malloc返回的指针赋值给它
    
        return p;
    }
    
    //尾部插入
    //计算添加了新的节点后总共有多少个节点,然后把这个数写进节点中
    void insert_tail(struct node* pH, struct node* new)
    {
        int count = 0;
        //分两步完成插入
        //第一步,先找到链表中最后一个节点
        struct node* p = pH;
        while(NULL != p->pNext)  //由头指针向后便利,走到最后一个节点
        {
            p = p->pNext;
            count++;
        }
    
        //第二部,将新节点插入到最后一个节点尾部
        p->pNext = new;  //新节点成为最后一个节点
        pH->data = count + 1;
    }
    
    //从头部添加新节点
    void insert_head(struct node* pH, struct node* new)
    {
        //新节点的next指向原来的第一个节点
        new->pNext = pH->pNext; //pH->pNext是第一个节点的地址
        //头结点的next指向新节点的地址
        pH->pNext = new;
        //头结点中的计数加1
        pH->data += 1;
    }
    
    //遍历单链表,pH为指向单链表的指针,将遍历的数据打印出来
    void ergodic(struct node* pH)
    {
        //pH-data;  //头结点数据,不是链表的常规数据,不要算进去
        struct node* p = pH;  //因为头指针后面是头结点
        //struct node* p = pH->pNext;
        while(NULL != p->pNext)
        {
            p = p->pNext;
            printf("node data = %d\n", p->data);
            
        }
        printf("over\n");
    
    }
    
    //从链表pH中删除节点,待删除的节点的特征是数据区等于data
    void delete_node(struct node* pH, int data)
    {
        //找到待删除的节点
        struct node* p = pH;
        struct node* pPrev = NULL;  //用来指向当前节点的前一个节点
        while(NULL != p->pNext)
        {
            pPrev = p;  //在p走向下一个节点前先将其保存
            p = p->pNext;
            if(p->data == data)
            {
                //找到了节点
                //分为2种情况:一个是普通节点,一个是尾结点
                if(NULL == p->data)
                { 
                    //尾结点
                    pPrev->pNext = NULL;  //原来尾结点的前一个节点变成新尾结点
                    free(p);              //释放原来的尾结点的内存
                }
                else
                {
                    //普通节点
                    pPrev->pNext = p->pNext;//要删除的节点的前一个节点和它的后一个节点相连
                    free(p);
                }
    
                //处理完成之后退出程序
                return 0;
            }
        }
        //没有找到节点
        printf("no node");
        return -1;
    }
    
    int main()
    {
        //头指针
        //struct node* pHeader = NULL;
        struct node* pHeader = creat_node(0);
    
        insert_head(pHeader, creat_node(1));
        insert_head(pHeader, creat_node(2));
        insert_head(pHeader, creat_node(3));
    
        ergodic(pHeader);
    
        delete_node(pHeader, 2);
        ergodic(pHeader);
    
    
    
        return 0;
    }
    

    在这里插入图片描述

    展开全文
  • 满意答案杨喜娟fct2016.02.02采纳率:55%等级:9已帮助:413人实现代码如下:1、线性表的顺序表示时Status ListInsert(SqList * L, int i, ElemType e){//L的第i位置之前插入新的数据元素e,L的长度加1ElemType ...
  • 单链表删除节点

    千次阅读 2021-08-14 15:49:14
    (2.1)如果不是尾节点:首先把待删除节点的前一个节点的pNext指向待删除节点的后一个节点的首地址,然后再将摘出来这个节点free掉。 (2.2)如果这个节点是尾节点,首先把待删除这个节点的前一个节点的pNext指针...
  • 今天做到一道题:设一个有序的单链表中有n个节点,现要求插入一个节点后是的单链表仍保持有序,则该操作的时间为:。 答案是:O(n) 为什么? 因为它是链表! 链表的增删改功能,一定依托于其“low的一批”的...
  • 删除单链表中第i个节点

    千次阅读 2019-01-06 17:53:14
    单链表删除操作是将单链表的第i个节点删去。具体步骤如下:  (1)找到节点ai-1的存储位置p,因为在单链表中节点ai的存储地址是其直接前趋节点ai-1的指针域next;  (2)令p-&gt;next指向ai的直接后继...
  • 在单链表中删除指定值的节点。 题目:给定一个链表的头节点head和一个整数num,请实现函数将值为num的节点全部删除。 例如1->2->3->4->4->null,输出1->2->3->null. num = 4。 1)第一种...
  • 删除在指定节点之后存在的节点,需要跳过所需数量的节点以到达节点,之后的节点将被删除。 需要跟踪这两个节点。如果节点之前存在的节点,则将删除节点。 为此,使用了两指针:ptr和ptr1。使用以下语句来...
  • 删除单链表最后一个节点

    千次阅读 2021-03-07 01:26:22
    链表只有一个节点,需要删除。链表有多个节点,链表的最后一个节点将被删除。1. 链表只有一个节点条件head → next = NULL将继续存在,因此,链表的唯一节点head将被指定为null。 这将通过使用以下语句来完成...
  • 实现一个函数,可以删除单链表中倒数第K个节点。 要求 如果链表长度为N,时间复杂度达到O(N),额外空间复杂度达到O(1)。 思路 如果链表为空或者K值小于1,直接返回head即可,除此之外,从头遍历链表,并让K-1. ...
  • //删除单链表中的任意一个节点,可能是传节点删除,也可能是传节点的值删除 typedef struct _Node { int val; struct _Node* next; }Node,*LinkList; //不带头结点的单链表 void Init(LinkList* list) { (*list) ...
  • 问题:对于一个没有头指针的单链表一个指针指向此单链表中间的节点(不是第一个,也不是最后一个),将该节点单链表中删除。 思路:获取该节点的下一个节点,将此节点与下一个节点进行交换,删除其下一个节点...
  • 在单链表中删除指定值的节点

    千次阅读 2017-11-06 16:44:33
    //在单链表中删除指定值的节点 public class delNode{ //节点的定义 public static class Node{ int value; Node next; public Node(int data) { this.value=data; } } //、变量法存储 publi
  • 在单链表中删除倒数第 K 个节点 要求 如果链表的长度为 N, 时间复杂度达到 O(N), 额外空间复杂度达到 O(1) 难度 士 解答 删除的时候会出现三种情况: 1、不存在倒数第 K 个节点,此时不用删除 2、倒数第 K 个节点...
  • 1、单链表无序,删除重复的多余节点,即重复的节点只保留一个 2、单链表无序,删除重复的所有节点,即重复的节点全部删除 3、单链表有序, 二、c++代码 1.删除无序链表的重复多余节点 代码如下: #include <...
  • 单链表删除节点

    千次阅读 2020-11-07 11:09:50
    //给定单向链表的头指针和一个删除节点的值,定义一个函数删除节点。 //返回删除后的链表的头节点
  • 在单链表中删除指定结点的两种算法
  • 使用C语言定义单链表,并且删除指定节点并返回新链表输出
  • usr/bin/env python#encoding:utf-8'''__Author__:沂水寒城功能:给定一个单链表删除指定节点'''class Node(object):'''节点类'''def __init__(self,data):self.num=dataself.next=Noneclass DeleteNod...
  • plist中删除p节点,时间复杂度要求O(1) 算法 因为时间复杂度为O(1),所以常规思路遍历链表是不行的。删除节点,其实是把该节点数据域清除,已知了p节点,那么可以知道它的next节点,所以可以把p节点的下一个节点的...
  • 题目要求:给定一个单链表,所有的数都不超过n,设计一个高效的算法,删除绝对值相同的元素,只保留第一个出现的节点。 算法思想: 已知每个数都不超过n,所以可以考虑用空间换时间,申请一个n+1大小的数组,全部...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 59,273
精华内容 23,709
关键字:

在单链表中删除一个节点