单向链表基本操作（增删改查）

最新推荐文章于 2021-09-13 13:47:11 发布
最新推荐文章于 2021-09-13 13:47:11 发布
阅读量303 收藏 1
点赞数 1
分类专栏： 数据结构学习 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43932518/article/details/107661841
版权

单向链表

链表的基本操作

添加节点

默认添加到链表最后

 public void add(HeroNode heroNode){
        //因为头节点不能动  我们需要一个辅助变量Temp
        HeroNode temp = head;
        //遍历链表找到最后
        while (true){
            //找到链表最后
            if(temp.next==null){
                break;
            }
            //没有找到最后的时候Temp后移
            temp = temp.next;
        }
        temp.next = heroNode;
    }

按链表中的某个信息按顺序添加

示例中按照的是HeroNode中的no顺序添加

 public void addByOrder(HeroNode heroNode){
        //头节点不能动需要定义辅助变量
        //单链表，因此找的Temp是位于添加位置的前一个节点否则插入不了
        HeroNode temp = head;
        boolean flag = false;//标识所需要添加的编号是否存在默认为false
        while (true){
            if(temp.next == null){//说明此时temp在链表的最后
                break;
            }
            if(temp.next.no > heroNode.no){//位置找到就在temp的后面插入
                break;
            }
            else if(temp.next.no == heroNode.no){//该节点的编号已经存在
                flag = true;//说明编号存在System.out.println("该节点的编号已经存在");
                break;
            }
            temp = temp.next;
        }
        if(flag == true){
            System.out.println("准备插入的编号已经存在" + heroNode.no);
        }
        else {
            //可以插入
            heroNode.next = temp.next;
            temp.next = heroNode;
        }

    }

删除节点

示例中的根据节点的no来查找删除

public void deleteHeroNode(int no){
        //判断是否为空
        if(head.next == null){
            System.out.println("链表为空·····");
            return;
        }
        HeroNode temp = head;
        boolean flag = false;
        while (true){
            if(temp.next == null){
                //找到了链表的最后一个节点
                break;
            }

            if(temp.next.no == no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if(flag){//找到需要删除的节点
            temp.next = temp.next.next;
        }
        else {
            System.out.println("需要删除的节点不存在");
        }
    }

    //显示链表遍历
    public void list(){
        //判断链表是否为空
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        //头节点不能动  需要一个辅助变量来遍历
        HeroNode temp = head.next;
        while (true){
            if(temp == null){
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将next后移
            temp = temp.next;
        }
    }

修改链表中的信息

示例中根据节点的no来修改节点的信息

public void update(HeroNode newHeroNode){
        //判断是否为空
        if(head.next == null){
            System.out.println("链表为空·····");
            return;
        }
        HeroNode temp = head;
        boolean flag = false;
        while (true){
            if(temp == null){
                //找到了链表的最后一个节点
                break;
            }
            if (temp.no == newHeroNode.no){
                flag = true;
                break;
            }
            temp = temp.next;
        }

        //链表中没有
        if (flag){
            temp.name = newHeroNode.name;
            temp.nickname =newHeroNode.nickname;
        }
        else {
            System.out.println("没有找到编号为"+ newHeroNode.no + "的节点");
        }
    }

查看链表的详细信息

遍历链表打印即可

public void list(){
        //判断链表是否为空
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        //头节点不能动  需要一个辅助变量来遍历
        HeroNode temp = head.next;
        while (true){
            if(temp == null){
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将next后移
            temp = temp.next;
        }
    }

具体的示例

package com.yc.day01.linkList;
/*
    @ClassName HeroNode
    @author cc
    @Date 2020-07-29 13:22
    @Version 1.0
    1.创建一个head头节点作用就是表示链表的头
    2.后面我们每添加一个节点直接就添加到链表的最后
    遍历
    1.
    顺序添加节点
    1.首先要找到新节点添加的位置 是通过辅助变量（指针） 通过遍历来确定
    2.新的节点的next域指向temp的next域
    3.将temp.next=新节点

    双向链表
    1.遍历和单向链表一样 不同：可以向前也可以先后查找
    2.添加（默认添加到双向链表的最后）
        1).先找到双向链表的最后节点
        2).temp.next = new heroNode
        3).newHeroNode.pro = temp
    3.修改  和单线链表思路一致
    4.删除
        1).双向链表 可以实现自我删除某个节点
        2).直接找到要删除的节点如：temp
        3).temp.pro.next = temp.next
        4).temp.next.pro = temp.pro
*/

import java.util.Stack;

public class SingleLinkedListDome {
    public static void main(String[] args) {
        //测试
        //创建节点
        HeroNode heroNode1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode heroNode2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode heroNode3 = new HeroNode(3,"吴用","智多星");
        HeroNode heroNode4 = new HeroNode(4,"林冲","豹子头");
        //HeroNode newHeroNode = new HeroNode(4,"林冲","32145636524");

        //创建给链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        /*singleLinkedList.add(heroNode1);
        singleLinkedList.add(heroNode4);
        singleLinkedList.add(heroNode2);
        singleLinkedList.add(heroNode3);*/
        singleLinkedList.addByOrder(heroNode1);
        singleLinkedList.addByOrder(heroNode4);
        singleLinkedList.addByOrder(heroNode2);
        singleLinkedList.addByOrder(heroNode3);
        //singleLinkedList.addByOrder(heroNode3);
        //测试逆序打印单链表
        /*System.out.println("原来链表的情况-------------");
        singleLinkedList.list();
        System.out.println("逆序打印单链表-------------");
        reversePrint(singleLinkedList.getHead());*/

        singleLinkedList.deleteHeroNode(2);
        System.out.println("删除后链表的情况-------------");
        singleLinkedList.list();
        /*//测试单链表反转
        System.out.println("原来链表的情况");
        singleLinkedList.list();

        System.out.println("反转链表-------------------------");
        reverseList(singleLinkedList.getHead());
        singleLinkedList.list();*/

        /*System.out.println("-----------------------------");
        singleLinkedList.update(newHeroNode);
        singleLinkedList.list();

        System.out.println("----------------------");
        System.out.println("当前的的节点个数为"+getLength(singleLinkedList.getHead()));
        HeroNode res = findLastIndexNode(singleLinkedList.getHead(),2);
        System.out.println("倒数第"+res+"个节点");*/
    }

    //查找单链表的倒数第K个节点
    /*
    * 1.编写一个方法接收head节点 同时接收一个index
    * 2.index是表示倒数index节点
    * 3.把链表从头到尾遍历 得到链表的总长度 getLength
    * 4.得到Size后 从链表的第一个开始遍历（Size - Index）个就可以得到
    * 5.如果找到了就返回该节点  否则返回Null
    * */
    public static HeroNode findLastIndexNode(HeroNode head,int index){
        //判断链表是否为空
        if(head.next == null){
            return  null;
        }
        //遍历得到链表的长度
        int size =getLength(head);
        //第二次遍历  size-index 位置 就是我们需要的倒数第K个节点
        //先做一个数据校验
        if(index <= 0 || index>size){
            return  null;
        }
        //定义一个辅助变量使用for循坏定位到倒数第K个节点
        HeroNode cur = head.next;//指向第一个有效节点
        for(int i=0;i < size-index; i++){
            cur = cur.next;
        }
        return cur;

    }


    /*
    * 1.定义一个节点reverseHead = new HeroNode();
    * 2.从头遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表的最前端
    * 3.原来链表的Head.next = reverseHead.next
    * 4.
    * */
    //单链表反转
    public static void reverseList(HeroNode head){
        //如果当前的链表为空或者只有一个节点的无需反转直接放回
        if(head.next == null || head.next.next == null){
            return;
        }
        //定义一个辅助变量帮助我们遍历原来的链表
        HeroNode cur = head.next;
        HeroNode next =null;//指向当前节点cur的下一个节点
        HeroNode reverseHead = new HeroNode(0,"","");
        //遍历原来的链表每遍历一个节点就将其取出放在新链表reverseHead的最前端
        while (cur != null){
            next = cur.next;//保存当前节点的下一个节点 后面需要使用
            cur.next = reverseHead.next;//将cur的下一个节点指向新的链表的头部
            reverseHead.next = cur;//将cur连接到reverseHead链表上
            cur =cur.next;
        }
        //将head.next指向reverseHead.next 实现链表反转
        head.next = reverseHead.next;

    }
    //有效节点的个数
    public static int getLength(HeroNode head){
        //判断链表是否是空链表
        if(head.next == null){
            return 0;
        }
        int Length = 0;
        //不统计头节点
        HeroNode cur = head.next;
        while (cur != null){
            Length ++ ;
            cur = cur.next;
        }
        return Length;
    }
    /*
    * 逆序打印单链表
    * 方式一：将单链表反转之后打印单链表
    *       问题：会破坏原来单链表的结构
    * 方式二：利用栈这个数据结构将各个节点压入栈中
    *       然后利用栈先进后出的特点实现逆序打印
    * Stack 栈
    * */
    //使用方式二来实现
    public static  void reversePrint(HeroNode head){
        if(head.next == null){
            return; //空链表
        }
        //创建一个栈
        Stack<HeroNode> stack = new Stack<>();
        HeroNode cur =head.next;
        while (cur != null){
            stack.push(cur);
            cur = cur.next;
        }
        //将栈中的节点打印
        while (stack.size()>0){
            System.out.println(stack.pop());
        }
    }
}
//定义HeroNode ,每个HeroNode就是一个节点
class HeroNode{

    public int no;
    public String name;
    public String nickname;
    public HeroNode next;//指向下一个节点

    public HeroNode(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

    //显示方便从写ToString
    @Override
    public String toString() {
        return "HeroNode{" +
                "no='" + no + '\'' +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }

}

class SingleLinkedList{
    //定义一个头节点 头节点不动
    private HeroNode head = new HeroNode
            (0,"","");
    //返回头节点
    public HeroNode getHead() {
        return head;
    }

    //添加节点方法
    //1.不考虑编号顺序
    //2.将最后的节点的next指向新节点
    public void add(HeroNode heroNode){
        //因为头节点不能动  我们需要一个辅助变量Temp
        HeroNode temp = head;
        //遍历链表找到最后
        while (true){
            //找到链表最后
            if(temp.next==null){
                break;
            }
            //没有找到最后的时候Temp后移
            temp = temp.next;
        }
        temp.next = heroNode;
    }

    //顺序添加节点的方式
    //根据对象里面的字段来进行排序插入（有重复的时候提示添加失败）
    public void addByOrder(HeroNode heroNode){
        //头节点不能动需要定义辅助变量
        //单链表，因此找的Temp是位于添加位置的前一个节点否则插入不了
        HeroNode temp = head;
        boolean flag = false;//标识所需要添加的编号是否存在默认为false
        while (true){
            if(temp.next == null){//说明此时temp在链表的最后
                break;
            }
            if(temp.next.no > heroNode.no){//位置找到就在temp的后面插入
                break;
            }
            else if(temp.next.no == heroNode.no){//该节点的编号已经存在
                flag = true;//说明编号存在System.out.println("该节点的编号已经存在");
                break;
            }
            temp = temp.next;
        }
        if(flag == true){
            System.out.println("准备插入的编号已经存在" + heroNode.no);
        }
        else {
            //可以插入
            heroNode.next = temp.next;
            temp.next = heroNode;
        }

    }
    //修改节点，根据编号来修改
    public void update(HeroNode newHeroNode){
        //判断是否为空
        if(head.next == null){
            System.out.println("链表为空·····");
            return;
        }
        HeroNode temp = head;
        boolean flag = false;
        while (true){
            if(temp == null){
                //找到了链表的最后一个节点
                break;
            }
            if (temp.no == newHeroNode.no){
                flag = true;
                break;
            }
            temp = temp.next;
        }

        //链表中没有
        if (flag){
            temp.name = newHeroNode.name;
            temp.nickname =newHeroNode.nickname;
        }
        else {
            System.out.println("没有找到编号为"+ newHeroNode.no + "的节点");
        }
    }
    //删除节点
    /*
    1.先找到需要删除的这个节点的前一个节点temp
    2.temp.next = temp.next.next
    3.被删除的节点将不会有其他应用会被垃圾回收机制回收
    * */
    public void deleteHeroNode(int no){
        //判断是否为空
        if(head.next == null){
            System.out.println("链表为空·····");
            return;
        }
        HeroNode temp = head;
        boolean flag = false;
        while (true){
            if(temp.next == null){
                //找到了链表的最后一个节点
                break;
            }

            if(temp.next.no == no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if(flag){//找到需要删除的节点
            temp.next = temp.next.next;
        }
        else {
            System.out.println("需要删除的节点不存在");
        }
    }

    //显示链表遍历
    public void list(){
        //判断链表是否为空
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        //头节点不能动  需要一个辅助变量来遍历
        HeroNode temp = head.next;
        while (true){
            if(temp == null){
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将next后移
            temp = temp.next;
        }
    }
}
weixin_43932518
关注
专栏目录
单向链表之增删改查
qq_36273886的博客
08-12 264
单项链表实现增删改啥 思路分析： 该算法的核心在于对链表的数据操控，借助指针，实现对数据的增删改啥，其实是next地址的修改 因为是单向链表，所以进行操作时候，辅助节点（指针）必须位于要操作元素的前一个节点（遍历可以是每个元素的本身） 1.带头节点的单向链表，元素节点分为data域和next域，将next域指向下一个节点的地址 2.创建指针temp，通过指针移动来读取各个节点的元素 3.添加，更新，删除，查看的逻辑，指针的向后移动来进行增删改查 1.新增 1.不做逻辑判断，向...
单向链表的增删改查
让键盘飞的博客
03-19 420
单向链表的增删改查
单链表的基本操作（增删改查）——C语言
Chromium的博客
02-20 140
一、定义 1、存储空间不一定连续 2、想要找到某一元素，必须从头指针位置遍历链表 二、代码 1、定义结构体 typedef struct Node { datatype data; struct Node* next; }Node; 2、创建头结点 struct Node* CreateList() { //创建链表 struct Node* headNode = (struct Node*)malloc(sizeof(struct Node));
有关单向链表的增删改查
11-06
本主题将深入探讨单向链表的增、删、改、查操作。 ### 增加节点 增加节点通常涉及到在链表的特定位置插入新的节点。在单向链表中，插入操作有以下四种常见情况： 1. **头部插入**：在链表的开始处添加新节点。这...
单向链表的增删改查操作
SORYUSHIKINAMI的博客
04-16 326
单向链表:也叫单链表，是链表中最简单的一种形式。 单向链表的基本单位叫“结点”，它包括两部分:元素存储区域(item) +下一元素地址(next)，多个结点组合起来 就是一个单向链表 链表特点：存储空间非连续；插入和删除的时候，不会移动大量的数据。空间不够了，也不需要进行替换 ![单向链表的结构](https://img-blog.csdnimg.cn/20200416143143124.png...
用C++类实现单向链表的增删查和反转操作方法
12-31
今天用了一下午时间终于独立完成了链表操作。 找网上的代码，大多用了结构体，还有些并不适合刚学c++或者数据结构的人看，于是我是用类写的，代码比较符合学生的习惯和水平。 先看类定义 class node { public: int...
用c语言实现链表增删改查
11-07
通过以上分析，我们可以看到这段代码实现了单向链表的基本操作：创建、打印、删除、添加、查询和修改。这些操作为理解和使用链表打下了坚实的基础。此外，该程序还展示了C语言中的指针操作，这对于深入学习C语言和...
链表——单向链表的增删改查
LeeBlog
09-03 303
【目的】 实现单向链表的修改、删除操作 【代码实现】 链表的定义 //定义链表 class SingleLinkedList2{ //初始化一个头结点 private HeroNode head = new HeroNode(0,"" , ""); //添加结点 public void add(HeroNode heroNode) { HeroNode temp...
关于链表的基本操作
方小白
09-15 362
/** *  编写：中医熊猫 *  时间：20150801 *  初次编写，还望指教 */ #include #include #define LEN sizeof(struct STU) int n = 0; struct STU{     int num;     struct STU *next; }; /**************创建链表**
单向链表的基本应用-增删改查
afootball的博客
07-07 238
一、单向链表功能函数初始化 /*********************************************/ /*demon:单向链表 author：乐乐 */ /********************************************/ typedef char data_t; //1.定义单向链表结构体 typedef struct node_t { data_t data; struct node_t *next; }linknod
链表的基本操作-增删改查
学习天地
05-05 255
    链表是一种存储结构，由一系列的结点组成。链表包括单向链表，循环链表，双向链表等，在这里，我们只讲单向链表，单向链表的每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。所以创建链表时，可以先写一个结点类： public class Node { public Node node; public Node next; public...
单向链表 增 删 改 查
ck0816的博客
02-04 339
#include &lt;stdio.h&gt; #include &lt;malloc.h&gt; typedef struct node { int num; node* next; } NODE; int lenght = -1;//线性表的链式结构的长度 /* 创建节点 */ NODE* create_node(int num) { NODE* n = (NODE*...
C语言单链表的基本操作总结（增删改查）
sun007700的专栏
04-01 253
https://blog.csdn.net/kilotwo/article/details/86670811
（C/C++)单链表的基本操作（增删改查)
HYK_DJ5201314的博客
06-05 681
（C/C++)单链表的基本操作（增删改查) int findx(link head,datatype x);查找值为x的结点，返回结点位置 datatype findpos(link head,int i);查找在第i个位置上的结点 void insertH(link head,datatype x)；头插法 void insertR(link head,datatype x,int tail)；尾插法 void insertPos(link head,int i,datatype x)；在指定位置插入元
数据结构：单向链表的增删改查
qq_42128262的博客
04-29 894
单向链表 定义：单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有指针成员变量指向列表中的下一个结点； 数据结构： public class LinkList{ public Integer date; public LinkList next; ...
单向链表增删改查
qq_51058681的博客
09-13 91
package LinkedList; import java.util.Stack; public class LinkedList { public static void main(String[] args) { Node node1=new Node(1,"111"); Node node2=new Node(2,"222"); Node node3=new Node(3,"333"); Node node5=new N.
用单向链表实现增删改查
最新发布
05-17
单向链表是由若干个节点组成的，每个节点都包含一个数据域和一个指向下一个节点的指针域。在单向链表中，只能从头节点开始遍历链表，每个节点只能访问其后继节点。下面是用单向链表实现增删改查的代码实现： ```python # 定义单向链表节点类 class ListNode: def __init__(self, val): self.val = val self.next = None # 定义单向链表类 class LinkedList: def __init__(self): self.head = None # 添加节点 def add_node(self, val): new_node = ListNode(val) if not self.head: self.head = new_node else: curr = self.head while curr.next: curr = curr.next curr.next = new_node # 删除节点 def delete_node(self, val): if not self.head: return if self.head.val == val: self.head = self.head.next else: curr = self.head while curr.next: if curr.next.val == val: curr.next = curr.next.next return curr = curr.next # 修改节点 def update_node(self, old_val, new_val): curr = self.head while curr: if curr.val == old_val: curr.val = new_val return curr = curr.next # 查找节点 def search_node(self, val): curr = self.head while curr: if curr.val == val: return True curr = curr.next return False ``` 在上面的代码中，我们定义了一个单向链表节点类 ListNode ，包含一个数据域 val 和一个指向下一个节点的指针域 next 。然后定义了单向链表类 LinkedList ，包含一个头节点 head 。在 LinkedList 中，我们实现了 add_node() 方法用于添加节点，delete_node() 方法用于删除节点，update_node() 方法用于修改节点，search_node() 方法用于查找节点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值