Java版单链表实现增插删改查

单链表实现增插删改查操作

增加元素操作

思路：遍历寻找到尾节点（节点next为null），将尾节点next指向参数节点就ok

public void add(HeroNode heroNode) {

    //因为头结点不能动，所以需要一个辅助遍历变量temp
    HeroNode temp = head;

    //遍历链表，找到最后一个节点，该节点next变量为null

    //简洁版
    //        while (temp.next != null) {
    //            //让temp指向下一个节点，检测下一个个节点next是不是null
    //            temp = temp.next;
    //        }

    //上一个循环为简洁遍历，看不懂可以参考下面的遍历方法
    while (true) {
        //找到那个节点next变量为null则跳出循环，找不到则继续遍历，将temp指向下一个节点
        if (temp.next == null) {
            break;
        } else {
            temp = temp.next;
        }
    }

    //当退出循环时，temp就指向了最后一个节点
    //将该节点的next指向要添加的那个节点
    temp.next = heroNode;
}

//显示链表[遍历]
public void list(){
    //先判断链表是否为空，为空直接不用遍历
    if(head.next==null){
        System.out.println("链表为空");
        return;
    }
    //头结点不能动，需要一个辅助变量遍历
    HeroNode temp = head;
    //简洁版
    while (temp.next != null) {
        //让temp指向下一个节点，检测下一个个节点next是不是null
        //这里主要要先改遍历节点在输出，否则会出现输出头结点，不输出尾节点的现象
        temp = temp.next;
        System.out.println(temp);
    }
}

插入元素操作

思路：插入就是将上节点next指向插入节点，将插入节点的next指向下一个节点,索引从0开始

//插入操作
public void insert(int index,HeroNode heroNode){
    
    //定义一个索引变量与插入索引比较
    int count=0;
    //定义遍历指针
    HeroNode temp = head;
    //开始循环，寻找插入位置
    while (count!=index){
        temp=temp.next;
        count++;
        if (temp.next==null){
            System.out.println("无效索引，插入失败");
            return;
        }
    }

    //先将插入节点的next指向下一个节点，因为之后要改变temp.next的值
    heroNode.next = temp.next;

    //将该节点next指向插入节点
    temp.next = heroNode;

    System.out.println("插入成功");
}

删除元素操作

思路：参数为节点中第一个数据，先遍历匹配链表节点，定位到第一个含有该数据的节点的上一个节点，之后这个节点的next指向下下个节点就ok，这样就可以将要删除的节点跳过，成功删除

//删除操作
public void delete(int del_id){
    //先判断链表是否为空，为空直接不用遍历
    if(head.next==null){
        System.out.println("链表为空");
        return;
    }
    //判断参数是否有效
    if(del_id<1){
        System.out.println("无效ID，删除失败");
        return;
    }

    //定义遍历指针
    HeroNode temp = head;
    //开始遍历，寻找id为del_id的节点的上一个节点，因为要将id为del_id的节点的上一个节点的next指向id为del_id的节点的下一个节点
    while (temp.next.id!=del_id){
        temp=temp.next;
        if (temp.next==null){
            System.out.println("无效ID,删除失败");
            return;
        }
    }

    //修改该节点的next，将其指向下下个节点
    temp.next = temp.next.next;
    System.out.println("删除成功");
}

修改元素操作

思路：创建一个新对象——数据为参数更新数据，删除索引位置对象，插入新对象

//更新操作
public void updata(int index,int id,String name){
    
    HeroNode uodata_hero = new HeroNode(id,name);
    delete(id);
    insert(index,uodata_hero);
    System.out.println("更新成功");
}

查看单链表操作

思路：定义节点伪指针，遍历单链表，将team指向的节点数据输出

//显示链表[遍历]
public void list(){
    //先判断链表是否为空，为空直接不用遍历
    if(head.next==null){
        System.out.println("链表为空");
        return;
    }
    //头结点不能动，需要一个辅助变量遍历
    HeroNode temp = head;
    //简洁版
    while (temp.next != null) {
        //让temp指向下一个节点，检测下一个个节点next是不是null
        //这里主要要先改遍历节点在输出，否则会出现输出头结点，不输出尾节点的现象
        temp = temp.next;
        System.out.println(temp);
    }
}

完整代码展示

package 数据结构.单链表;

/*
任务背景：使用有头结点的单链表实现——水浒英雄排行榜管理
具体功能要求：1.可以将英雄添加尾部
           2.可以将英雄插入指定位置
           3.可以删除英雄
           4.可以修改英雄
*/

//小知识：类名 变量 = 类；这种不用new的实例化，变量可以作为指针使用（内存地址相同），当变量对象属性改变时，它指向的那个对象属性跟着改变

//编写节点
class HeroNode {
    public int id;//英雄编号
    public String name;//英雄姓名
    public HeroNode next;//指向下一个节点（是个对象）

    //构造器
    public HeroNode(int hid, String hname) {
        this.id = hid;
        this.name = hname;
        this.next = null;//这句可以不用写，没有赋值时next本身就是null
    }

    //显示方法
    @Override
    public String toString() {
        return "HeroNode 英雄编号: " + id + " 英雄姓名: " + name;
    }
}

//创建单链表,管理英雄
class HeroLink {
    //先初始化一个头结点，头结点不能动,且不存放具体数据，因为只能存在一个，故设置其为私有对象
    private HeroNode head = new HeroNode(0, "");

    /*
    添加节点到单向链表中，添加至末尾；
    具体方法：先new一个新节点，上一个节点指针（next变量）指向该节点
    步骤  1.先遍历找到链表的最后节点
         2.new一个新节点（这里因为将新节点作为参数，故无需new）
         3.将上一个节点的next变量指向新节点
     */
    public void add(HeroNode heroNode) {

        //因为头结点不能动，所以需要一个辅助遍历变量temp
        HeroNode temp = head;

        //遍历链表，找到最后一个节点，该节点next变量为null

        //简洁版
//        while (temp.next != null) {
//            //让temp指向下一个节点，检测下一个个节点next是不是null
//            temp = temp.next;
//        }

        //上一个循环为简洁遍历，看不懂可以参考下面的遍历方法
        while (true) {
            //找到那个节点next变量为null则跳出循环，找不到则继续遍历，将temp指向下一个节点
            if (temp.next == null) {
                break;
            } else {
                temp = temp.next;
            }
        }

        //当退出循环时，temp就指向了最后一个节点
        //将该节点的next指向要添加的那个节点
        temp.next = heroNode;
    }

    //显示链表[遍历]
    public void list(){
        //先判断链表是否为空，为空直接不用遍历
        if(head.next==null){
            System.out.println("链表为空");
            return;
        }
        //头结点不能动，需要一个辅助变量遍历
        HeroNode temp = head;
        //简洁版
        while (temp.next != null) {
            //让temp指向下一个节点，检测下一个个节点next是不是null
            //这里主要要先改遍历节点在输出，否则会出现输出头结点，不输出尾节点的现象
            temp = temp.next;
            System.out.println(temp);
        }
    }

    //删除操作
    public void delete(int del_id){
        //先判断链表是否为空，为空直接不用遍历
        if(head.next==null){
            System.out.println("链表为空");
            return;
        }
        //判断参数是否有效
        if(del_id<1){
            System.out.println("无效ID，删除失败");
            return;
        }

        //定义遍历指针
        HeroNode temp = head;
        //开始遍历，寻找id为del_id的节点的上一个节点，因为要将id为del_id的节点的上一个节点的next指向id为del_id的节点的下一个节点
        while (temp.next.id!=del_id){
            temp=temp.next;
            if (temp.next==null){
                System.out.println("无效ID,删除失败");
                return;
            }
        }

        //修改该节点的next，将其指向下下个节点
        temp.next = temp.next.next;
        System.out.println("删除成功");
    }

    //插入操作
    public void insert(int index,HeroNode heroNode){
        /*
            思路：插入就是将上节点next指向插入节点，将插入节点的next指向下一个节点
            索引从0开始
         */
        //定义一个索引变量与插入索引比较
        int count=0;
        //定义遍历指针
        HeroNode temp = head;
        //开始循环，寻找插入位置
        while (count!=index){
            temp=temp.next;
            count++;
            if (temp.next==null){
                System.out.println("无效索引，插入失败");
                return;
            }
        }

        //先将插入节点的next指向下一个节点，因为之后要改变temp.next的值
        heroNode.next = temp.next;

        //将该节点next指向插入节点
        temp.next = heroNode;

        System.out.println("插入成功");
    }

    //更新操作
    public void updata(int index,int id,String name){
        /*
            思路：创建一个新对象，删除索引位置对象，插入新对象
         */
        HeroNode uodata_hero = new HeroNode(id,name);
        delete(id);
        insert(index,uodata_hero);
        System.out.println("更新成功");
    }
}


public class 单链表实现 {
    public static void main(String[] args) {
        //测试
        //先创建节点
        HeroNode hero1 = new HeroNode(1,"宋江");
        HeroNode hero2 = new HeroNode(2,"吴用");
        HeroNode hero3 = new HeroNode(3,"林冲");
        HeroNode hero4 = new HeroNode(4,"武松");

        //创建英雄链表
        HeroLink heroLink = new HeroLink();
        heroLink.add(hero1);
        heroLink.list();
        heroLink.add(hero2);
        heroLink.add(hero3);
        heroLink.add(hero4);
        heroLink.list();

        System.out.println("测试删除样例");
        heroLink.delete(2);
        heroLink.list();

        System.out.println("测试插入样例");
        HeroNode insert_hero = new HeroNode(2,"张三");
        heroLink.insert(1,insert_hero);
        heroLink.list();

        System.out.println("测试更新样例");
        heroLink.updata(1,2,"李四");
        heroLink.list();
    }
}

---

上一篇： 单链表用Java实现

写博文不容易。如果你觉得本文对你有用，请点个赞支持下，谢谢。