精华内容
下载资源
问答
  • 2021-08-02 15:12:51

    目的:删除一个单链表的头节点。

    实现:让头节点的value值为null,再新建一个节点(头节点的next节点),然后让头节点的next为null,这样头节点相当于删除了(next,value都为null了),再把新节点赋为头节点。

    public void removeHead() {
        if(head==null){
            return;
            }else if(head.next==null){
            //只有一个节点
            head.value=null;
            head.next=null;
            head=null;
            tail=null;
        }else {
            head.value=null;//防止内存泄漏
            Node<T> p=head.next;
            head.next=null;
            head=p;
            }
        }

    时间复杂度O(1)。

    更多相关内容
  • 题目:给你一个链表的头节点 head 和一个整数 val ,请你删除链表中所有满足 Node.val == val 的节点,并返回 新的头节点 。 对于这一题的反转链表,其实也是next域中地址的问题,我们只需要把他们的地址换个顺序...

    【链表OJ题】:

    本题来自于力扣算法题,链接:206. 反转链表

    题目:给你单链表的头节点 head ,请你反转链表,并返回反转后的链表。

    对于这一题的反转链表,其实也是next域中地址的问题,我们只需要把他们的地址换个顺序就可以了,但是这里的问题就是如果你把前面的地址换到后面去,那就会断开链表了:

    如果断开链表,那么后面的就反转不了了,所以我们要做一个先行者,让他来帮我们记录前面的位置,也就是新建一个引用curNext,用来避免丢失前面节点的地址。

    接下来所以我们就是需要一步一步的循环,然后换next域的地址,其实就是这4步:

    1.curNext = cur.next
    2.cur.next = prev
    3.prev = cur
    4.cur = curNext

    这4步我们用一个例子来给大家演示看一下,让大家更好的了解,这里我们演示6步,刚好可以看见效果,下面是图例:
    在这里插入图片描述
    是不是还有一个问题,反转之后如果按照这样子尾节点也不说null啊,我们把prev和cur往前挪一个节点不就可以了,这样子prev = null,cur就是head,然后执行第一次的时候就会把head的next域置为null。

    所以我们只需要在cur还没有遇到结尾也就是null的时候循环就好了,还要注意的两个点就是:1.要判断链表是否为空,为空没得操作。2.要返回新的头节点,那么我们新的头节点是什么呢,我们看上图很明显看出当cur == null的时候,头应该就是prev了。

    参考代码:

    class Solution {
        public ListNode reverseList(ListNode head) {
            if(head == null){
                return null;//判断是否空链表
            }
            ListNode cur =head;
            ListNode prev =null;
           
    
            while(cur != null)//循环遍历
            {
                ListNode curNext = cur.next;//探路
                cur.next = prev;//反转
                prev = cur;//前进
                cur = curNext;//前进
    
            }
            return prev;//返回新的头节点
        }
    }
    

    这就是本链表OJ题的全部内容。

    展开全文
  • 无论插入删除修改遍历我们所需要的实际上只需要让一个新节点(temp【在c里就是指针,Java中没有指针的概念,但其实就是类节点】)获取到我们要进行操作的链表就行 主要 搞清怎么操作指针域就行 temp = head temp = ...

    链表

    链式存储结构
    内存不连续
    以节点的方式存储
    节点包含数据域和指针域
    链表分带有节点和无头节点的链表

    单链表

    在这里插入图片描述

    各种操作的依赖

    无论插入删除修改遍历我们所需要的实际上只需要让一个新节点(temp【在c里就是指针,Java中没有指针的概念,但其实就是类节点】)获取到我们要进行操作的链表就行

    主要

    搞清怎么操作指针域就行

    temp = head
    temp = temp.next
    

    代码

    链表节点

    package linklist;
    
    public class ListNode {
        public int id;
        //数据域
        public String data;
        //指针域
        public ListNode next;
    
        public ListNode(int id,String data){
            this.id = id;
            this.data = data;
        }
    
        @Override
        public String toString() {
            return "ListNode{" +
                    "id=" + id +
                    ", data='" + data + '\'' +
                    '}';
        }
    }
    
    

    单链表实体类

    package linklist;
    
    public class SingleLinkList {
        //先初始化一个头节点,头节点不存放具体数据
        private ListNode head;
    
        public void initSingLinkList() {
            head = new ListNode(0, "");
        }
    
        //添加节点
        public void insertNode(ListNode listNode) {
            //使用temp指针进行遍历
            ListNode temp = head;
            while (true) {
                if (temp.next == null) {
                    break;
                }
                temp = temp.next;
            }
            temp.next = listNode;
        }
    
        //打印链表
        public void showSingleLinkList() {
            if (isEmpty()) {
                return;
            }
            ListNode temp = head.next;
            while (true) {
                if (temp == null) {
                    return;
                }
                System.out.println(temp);
                temp = temp.next;
            }
        }
    
        //判断链表是否为空
        public boolean isEmpty() {
            if (head.next == null) {
                System.out.println("链表为空");
                return true;
            }
            return false;
        }
    
        //按照id顺序添加节点
        public void insertByOrder(ListNode listNode) {
            ListNode temp = head;
            boolean flag = false;
            while (true) {
                if (temp.next == null) {
                    break;
                }
                if (temp.next.id > listNode.id) {
                    break;
                } else if (temp.next.id == listNode.id) {
                    flag = true;
                    break;
                }
                temp = temp.next;
            }
            if (flag == true) {
                System.out.println("准备插入的数据编号已存在,无法添加");
            } else {
                listNode.next = temp.next;
                temp.next = listNode;
                System.out.println("插入成功");
            }
        }
    
        //修改节点数据
        public void updateNode(ListNode listNode) {
            ListNode temp = head;
            boolean flag = false;
            while (true) {
                if (temp.next == null) {
    
                    break;
                }
                if (temp.id == listNode.id) {
                    flag = true;
                    break;
                }
                temp = temp.next;
            }
            if (flag) {
                temp.data = listNode.data;
            } else {
                System.out.println("没有找到要修改的节点");
            }
        }
    
        //删除节点
        public void delNode(int id) {
            ListNode temp = head;
            boolean flag = false;
            while (true) {
                if (temp.next == null) {
                    break;
                }
                if (temp.next.id == id) {
                    flag = true;
                    break;
                }
                temp = temp.next;
            }
            if (flag) {
                temp.next = temp.next.next;
    
            } else {
                System.out.println("要删除的节点不存在");
            }
        }
    
        //获取头节点
        public void getHeadNode() {
            ListNode temp = head;
            if (temp.next == null && temp.id == 0) {
                System.out.println("该链表为空无法获取头节点");
            } else {
                temp = temp.next;
                System.out.println("头节点为:" + temp);
            }
        }
    
        //获取尾节点
        public void getTailNode() {
            ListNode temp = head;
            boolean flag = false;
            while (true) {
                if (temp.next == null && temp.id == 0) {
                    System.out.println("该链表为空无法获取尾节点");
                    break;
                }
                if (temp.next == null) {
                    flag = true;
                    break;
                }
                temp = temp.next;
            }
            if (flag) {
                System.out.println("尾节点为:" + temp);
            } else {
                System.out.println("无法找到该节点");
            }
    
        }
    
        //清空链表
        public void clearLinkList() {
            ListNode temp = head;
            boolean flag = false;
            while (true) {
                if (temp.next == null && temp.id == 0) {
                    System.out.println("该链表为空无法清空");
                    break;
                }
                temp = temp.next;
                temp.data = "";
                if (temp.next == null) {
                    flag = true;
                    break;
                }
            }
            if (flag) {
                System.out.println("清空完成");
            }
        }
    
        //获取长度
        public void getLength() {
            ListNode temp = head;
            int length = 0;
            while (true) {
                if (temp.next == null && temp.id == 0) {
                    System.out.println("该链表为空长度为"+length);
                    break;
                }
                temp = temp.next;
                length++;
                if (temp.next == null) {
                    System.out.println("该链表为空长度为"+length);
                    break;
                }
            }
        }
    }
    
    

    测试类

    package linklist;
    
    import java.util.Scanner;
    
    public class SingleLinkListTest {
        public static void main(String[] args) {
            SingleLinkList singleLinkList = new SingleLinkList();
            int choose = -1;
            Scanner sc = new Scanner(System.in);
            boolean flag = true;
            while (flag) {
                System.out.println("============================");
                System.out.println("=========1.初始化队列========");
                System.out.println("=========2.添加节点=========");
                System.out.println("=========3.显示单链表=========");
                System.out.println("=========4.删除单链表节点========");
                System.out.println("=========5.获取头节点(指id = 1)========");
                System.out.println("=========6.获取单链表长度======");
                System.out.println("=========7.清空单链表=========");
                System.out.println("=========8.销毁单链表=========");
                System.out.println("=========9.获取尾节点========");
                System.out.println("=========10.修改节点数据========");
                System.out.println("=========0.退出exit=========");
                System.out.println("============================");
                System.out.println("请输入你的选择:");
                choose = sc.nextInt();
                if (choose == 0) {
                    System.out.println("exit...");
                    break;
                }
                switch (choose) {
                    case 1:
                        singleLinkList.initSingLinkList();
                        break;
                    case 2:
                        System.out.println("输入你要添加的数据:");
                        System.out.println("输入编号(大于等于1)");
                        int id = sc.nextInt();
                        System.out.println("输入你要添加的内容");
                        String data = sc.next();
                        ListNode listNode = new ListNode(id,data);
                        singleLinkList.insertByOrder(listNode);
                        break;
                    case 3:
                        System.out.println("当前列表为:");
                        singleLinkList.showSingleLinkList();
                        break;
                    case 4:
                        System.out.println("请输入你要移除的节点编号(大于等于0)");
                        int delId =sc.nextInt();
                        singleLinkList.delNode(delId);
                        break;
                    case 5:
                        singleLinkList.getHeadNode();
                        break;
                    case 6:
                        singleLinkList.getLength();
                        break;
                    case 7:
                        singleLinkList.clearLinkList();
                        break;
                    case 8:
                        singleLinkList = null;
                        System.out.println("已销毁--》自动停止程序》》》");
                        System.exit(0);
                        break;
                    case 9:
                        singleLinkList.getTailNode();
                        break;
                    case 10:
                        System.out.println("输入你要添加的数据:");
                        System.out.println("输入编号(大于等于1)");
                        int newId = sc.nextInt();
                        System.out.println("输入你要添加的内容");
                        String newData = sc.next();
                        ListNode newlistNode = new ListNode(newId,newData);
                        singleLinkList.updateNode(newlistNode);
                        break;
                    default:
                        System.out.println("error");
                        break;
                }
    
            }
    
        }
    }
    
    

    程序截图

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 删除在指定节点之后存在的节点,需要跳过所需数量的节点以到达节点,之后的节点将被删除。 需要跟踪这两个节点。如果在该节点之前存在的节点,则将删除节点。 为此,使用了两个指针:ptr和ptr1。使用以下语句来...

    要删除在指定节点之后存在的节点,需要跳过所需数量的节点以到达节点,之后的节点将被删除。 需要跟踪这两个节点。如果在该节点之前存在的节点,则将删除该节点。 为此,使用了两个指针:ptr和ptr1。

    使用以下语句来执行此操作。

    ptr = head; for (i = 0;i < loc;i++) { ptr1 = ptr; ptr = ptr->next; if (ptr == NULL) { printf("There are less than %d elements in the list..", loc); return; } }

    现在,任务差不多完成了,只需要做一些指针调整。 使ptr1(指向指定节点)的下一个指向ptr的下一个(要删除的节点)。

    这将通过使用以下语句来完成。

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

    算法

    第1步:如果HEAD = NULL 打印提示内存溢出 转到第10步 结束时间 第2步:设置TEMP = HEAD 第3步:设置I = 0 第4步:重复第5步到第8步直到 I 第5步:TEMP1 = TEMP 第6步:TEMP = TEMP→NEXT 第7步:如果TEMP = NULL 提示“不存在节点” 转到第12步 结束条件 第8步:I = I + 1 循环结束 第9步:TEMP1→NEXT = TEMP→NEXT 第10步:释放 TEMP 第11步:退出

    示意图 –

    491bdbcdb25b13856c0a2e021220e3dc.png

    C语言示例代码 –

    #include #include void create(int); void delete_specified(); struct node { int data; struct node *next; }; struct node *head; void main() { int choice, item; do { printf("1.Append Listn"); printf("2.Delete noden"): printf("3.Exitn"): printf("4.Enter your choice?"); scanf("%d", &choice); switch (choice) { case 1: printf("Enter the itemn"); scanf("%d", &item); create(item); break; case 2: delete_specified(); 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 *)); if (ptr == NULL) { printf("OVERFLOWn"); } else { ptr->data = item; ptr->next = head; head = ptr; printf("Node insertedn"); } } void delete_specified() { struct node *ptr, *ptr1; int loc, i; scanf("%d", &loc); ptr = head; for (i = 0;i < loc;i++) { ptr1 = ptr; ptr = ptr->next; if (ptr == NULL) { printf("There are less than %d elements in the list..n", loc); return; } } ptr1->next = ptr->next; free(ptr); printf("Deleted %d node ", loc); }

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

    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?1 Enter the item 23 Node inserted 1.Append List 2.Delete node 3.Exit 4.Enter your choice?2 12 There are less than 12 elements in the list.. 1.Append List 2.Delete node 3.Exit 4.Enter your choice?2 1 Deleted 1 node

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

    展开全文
  • 单链表删除节点

    2022-03-26 15:00:39
    //head节点不能动,因此我们需要一个辅助节点temp,帮助我们找到待删除节点的前一个节点 //说明:我们在比较时是temp.next.no和需要删除节点的no比较 public void deleteNode(int no){ HeroNode temp = head; ...
  • 删除单链表的指定节点删除节点基本思想代码复杂度分析 删除节点 3 -> 2 -> 0 -> 3 -> 4 -> 5 假定删除3这个节点删除后的链表:2 -> 0 -> 4 -> 5 基本思想 存在删除头节点的情况 先看...
  • 1.先区分一下概念:结点:在单链表第一个元素结点之前...优点:减少了单链表添加删除时特殊情况的判断,减少了程序的复杂性,主要是添加和删除在第一个有元素的结点(首元结点)上有区别,如果链表没有结点,则...
  • 假如该链表中要删除的数是连续存放的,且几个节点连续的话,要维护这个链 表需要的节点多,删除也不是很方便的。 2.干脆新起一个链表,把非重复的节点接在这个节点的后面(有/无头) 3.那么就可以用原链表的...
  • 单链表删除节点

    2021-07-28 10:50:22
    给定单向链表的指针和一个要删除节点的值,定义一个函数删除节点。 返回删除后的链表的头节点。 示例: 输入: head = [4,5,1,9], val = 5 输出: [4,1,9] 解释: 给定你链表中值为 5 的第二个节点,那么在调用了...
  • 单链表头节点与无头结点的区别

    千次阅读 多人点赞 2020-02-15 22:09:26
    1.先区分一下概念: 结点: 在单链表第一个元素结点之前设置的...优点:减少了单链表添加删除时特殊情况的判断,减少了程序的复杂性,主要是添加和删除在第一个有元素的结点(首元结点)上有区别,如果链表没有...
  • 如果是带有头节点的链表,直接从头部遍历,找到需要删除节点,然后直接删除 删除的方式,加入目前的节点为node ,前一个节点即为pre pre->next = node->next; delete node; node = null; 但是目前没有头节点,所以...
  • 单链表(带头节点)的相关操作 提示:以下代码均基于带头结点的单链表 一、代码 1.单链表的定义 代码如下(示例): typedef struct LNode{//定义单链表节点类型 int data; struct LNode *next; }LNode,*LinkList;...
  • 无头节点单链表和有头节点单链表

    千次阅读 2019-09-15 10:15:31
    无头结点和有头节点 无头结点:第一个节点既有数据域又有指针域。 但是通过一个 pHead 指针指向和标记第一个节点头节点:在第一个节点之前加入一个头节点头节点的 data 域可以设置表长等相关信息,但也可以不...
  • 我在之前一篇博客《C语言实现单链表节点删除(不带头结点)》中详细实现了如何在一个不带头结点的单链表删除一个节点,在这一篇博客中我改成了带头结点的单链表。代码示例上传至 ...
  • 带头非递增无序单链表删除重复节点 (保留第一个节点,删除后续重复节点) 如[1,3,4,1,2,1]执行操作后变为[1,3,4,2] // 非递归实现去重 NODE *Delete(LNODE *L) { NODE *p,*q,*r; p = head->next; // 适用...
  • 使用C语言定义单链表,并且删除指定节点并返回新链表输出
  • 分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!... * 在单链表删除指定值的节点。 * * 思路: * 利用栈或其他容器收集节点。 * * @author Created by LiveE
  • 数据结构之单链表(带头节点

    千次阅读 2020-08-04 10:37:31
    单链表是以节点存的链式结构,分为带头节点和不带头节点单链表单链表中的节点包括data域和next域,data域存储元素的值,next域则存储下一个节点的地址。单链表中的各个节点在内存中不一定是连续存储的,存储形式...
  • 单链表删除重复节点

    千次阅读 2016-10-09 18:54:17
    /*删除重复节点*/ free(r); /*释放r*/ } else q=q->next; /*指针往后移*/ } p=p->next; /*指针往后移*/ } } int main() { LinkList l; Node *p; int i; char *c; l=(Node * )malloc(sizeof(Node)); l...
  • 给定一个带头结点的单链表,设 head 为指针,节点结构为 `(data, next)`,data 为整型元素,next 为指针,试写出算法:按递增次序输出单链表中各节点的数据元素,并释放节点所占的存储空间。要求:不允许使用数组...
  • 带头结点的单链表删除数据

    千次阅读 2022-04-18 14:27:09
    带头结点的单链表删除数据 LLWHdelete.c #include<stdio.h> #include<stdlib.h> #include"LLWHdelete.h" LinkedList *create(void) { LinkedList *l = malloc(sizeof(*l)); l->first = NULL; l...
  • 分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!... * 在单链表删除指定值的节点。 * * 思路: * 直接写代码,还是要找到pre节点。 * * @author Created by LiveEveryDay */ public c
  • 单链表删除常用两种方法: 1.删除p->next的节点 { q=p->next; p->next=q->next; free(q); } 2.删除p指向的节点(需要引入前驱节点q) { q=head; while(q->next!=p) q=q->next...
  • 单链表的算法之删除节点 1.为什么要删除节点 (1)有时候链表节点中的数据不想要了,因此要删掉这个节点。 2.删除节点的2个步骤 (1)第一步:找到要删除节点;第二部:删除这个节点 3.如何找到待删除节点 (1)通过遍...
  • 1 结构体定义 2 动作 3 代码 //指向第一个节点的指针叫指针 //头节点是方便操作而设定的节点,其data变量一般不设置值。但也有可能存储哨兵或者链表的长度 ...//定义单链表节点类型 typedef struct LN...
  • C++单链表删除当前节点

    万次阅读 2018-04-09 22:25:28
    首先要说明的是,如果只知道删除节点的地址的话,想删除这个节点并且保持单链表的连续性,那么,引用(&amp;)是我知道的唯一办法。 如果知道的是删除节点的前一个节点,那么你之前节点类型就会有多重分类: ...
  • 带头节点单链表

    2021-11-16 21:53:34
    特点: 有一个head指针变量,它存放结点的地址,称之为...在插入和删除操作中,只需修改相关节点指针域的链接关系,不需要大量的改变数据的实际储存位置。链表的使用,可以使程序的内存利用率和时间效率大大增加。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 60,183
精华内容 24,073
关键字:

单链表删除头节点