5. 单链表

于 2022-01-13 21:48:12 发布
阅读量132 收藏
点赞数 1
分类专栏： 数据结构与算法（Java） 文章标签： 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59376721/article/details/122444221
版权

文章目录

1.单链表的介绍及内存布局

1）链表是有序的列表，以节点的方式来存储。
2）每个节点包含data域，next域（指向下一节点）。
3）链表的各个节点不一定是连续存储的。
4）链表分带头节点的链表和没有头节点的链表。
5）内存中的存储如下图：
在这里插入图片描述
6）单链表（带头节点）逻辑结构示意图如下：

在这里插入图片描述

2.单链表的创建、添加与遍历

应用举例：
使用带head头节点的单链表实现角色排名，角色属性包括（排名，姓名，昵称）

2.1直接将新数据添加到链表的尾部。

1）思路：不考虑编号时
①找到当前单链表的最后一个节点
②将最后一个节点的next 指向 新的节点

2）代码：

public class linkedList {
    public static void main(String[] args) {
        //创建heroNode的对象
        HeroNode h1 = new HeroNode(1,"宋江","及时雨");
        HeroNode h2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode h3 = new HeroNode(3,"吴用","智多星");
        HeroNode h4 = new HeroNode(4,"林冲","豹子头");

        //创建单链表对象
        SingerLinkedList singerLinkedList = new SingerLinkedList();

        singerLinkedList.add(h1);
        singerLinkedList.add(h2);
        singerLinkedList.add(h3);
        singerLinkedList.add(h4);
        
        singerLinkedList.show();
    }
}

//创建单链表：每一个英雄代表一个节点
class SingerLinkedList{
    private HeroNode head; //头节点：不存放具体的数据，用于定位单链表

    public SingerLinkedList() {
        head = new HeroNode(0,"","");
    }

    //添加节点到单链表
    //思路：不考虑编号时
    //1.找到当前单链表的最后一个节点
    //2.将最后一个节点的next 指向 新的节点
    public void add(HeroNode node){
        //定义一个辅助变量temp代替head
        HeroNode temp = head;
        while(true){
            if(temp.next == null){//找到当前单链表的最后一个节点
                break;
            }
            temp = temp.next; //temp后移
        }
        temp.next = node; //将最后一个节点的next 指向 新的节点
    }

    //遍历单链表
    public void show(){
        //判断单链表是否为空
        if(head.next == null){
            System.out.println("单链表为空~~");
            return;
        }
        //定义一个辅助变量temp
        HeroNode temp = head.next;//因为单链表至少有一个值
        while(true){
            if(temp == null){//找到当前单链表的最后一个节点的下一节点
                break;
            }
            System.out.println(temp);
            temp = temp.next; //temp后移
        }
    }
}
//创建英雄节点
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;
    }

    @Override
    public String toString() {
        return "heroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}

2.2按顺序将新数据插入单链表中

1）思路：考虑编号顺序
①找到当前单链表的最后一个节点
②要插入的节点的排名 要小于 要插入的节点的下一个节点的排名
③要插入的节点的next = temp.next
④temp.next = 要插入的节点
⑤重复的节点无法插入

2）代码：

public class linkedList {
    public static void main(String[] args) {
        //创建heroNode的对象
        HeroNode h1 = new HeroNode(1,"宋江","及时雨");
        HeroNode h2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode h3 = new HeroNode(3,"吴用","智多星");
        HeroNode h4 = new HeroNode(4,"林冲","豹子头");

        //创建单链表对象
        SingerLinkedList singerLinkedList = new SingerLinkedList();
        
        singerLinkedList.addByOrder(h1);
        singerLinkedList.addByOrder(h4);
        singerLinkedList.addByOrder(h3);
        singerLinkedList.addByOrder(h2);

        singerLinkedList.show();
    }
}

//创建单链表：每一个英雄代表一个节点
class SingerLinkedList{
    private HeroNode head; //头节点：不存放具体的数据，用于定位单链表

    public SingerLinkedList() {
        head = new HeroNode(0,"","");
    }

    //添加节点到单链表
    //思路：考虑编号顺序
    //1.找到当前单链表的最后一个节点
    //2.要插入的节点的排名 要小于 要插入的节点的下一个节点的排名
    //3.要插入的节点的next = temp.next
    //4.temp.next = 要插入的节点
    //5.重复的节点无法插入
    public void addByOrder(HeroNode node){
        //定义一个辅助变量temp代替head
        HeroNode temp = head;
        boolean flag = false; //用于处理重复节点
        while(true){
            if(temp.next == null){//找到当前单链表的最后一个节点
                break;
            }
            if(node.no < temp.next.no){ //要插入的节点的排名 要小于 要插入的节点的下一个节点的排名
                break;
            }
            if(node.no == temp.next.no){//有重复的节点，使其无法插入
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if(flag){
            System.out.println("插入数据重复，" + "重复编号为：" + node.no); //重复的节点无法插入
        }else{
            node.next = temp.next; //要插入的节点的next = temp.next
            temp.next = node; //temp.next = 要插入的节点
        }
    }

    //遍历单链表
    public void show(){
        //判断单链表是否为空
        if(head.next == null){
            System.out.println("单链表为空~~");
            return;
        }
        //定义一个辅助变量temp
        HeroNode temp = head.next;//因为单链表至少有一个值
        while(true){
            if(temp == null){//找到当前单链表的最后一个节点的下一节点
                break;
            }
            System.out.println(temp);
            temp = temp.next; //temp后移
        }
    }
}
//创建英雄节点
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;
    }

    @Override
    public String toString() {
        return "heroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}

3.单链表的节点修改

1）思路：
①.通过排名，找到要修改的节点
②.要修改的节点的name，nickName修改为要新的值

2）代码：

public class linkedList {
    public static void main(String[] args) {
        //创建heroNode的对象
        HeroNode h1 = new HeroNode(1,"宋江","及时雨");
        HeroNode h2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode h3 = new HeroNode(3,"吴用","智多星");
        HeroNode h4 = new HeroNode(4,"林冲","豹子头");
        HeroNode h5 = new HeroNode(4,"刻晴","玉衡星");

        //创建单链表对象
        SingerLinkedList singerLinkedList = new SingerLinkedList();

        singerLinkedList.addByOrder(h1);
        singerLinkedList.addByOrder(h4);
        singerLinkedList.addByOrder(h3);
        singerLinkedList.addByOrder(h2);
        singerLinkedList.show();
        System.out.println("修改后的链表情况*********************************");
        singerLinkedList.updata(h5);
        singerLinkedList.show();
    }
}

//创建单链表：每一个英雄代表一个节点
class SingerLinkedList{
    private HeroNode head; //头节点：不存放具体的数据，用于定位单链表

    public SingerLinkedList() {
        head = new HeroNode(0,"","");
    }

    public void addByOrder(HeroNode node){
        //定义一个辅助变量temp代替head
        HeroNode temp = head;
        boolean flag = false; //用于处理重复节点
        while(true){
            if(temp.next == null){//找到当前单链表的最后一个节点
                break;
            }
            if(node.no < temp.next.no){ //要插入的节点的排名 要小于 要插入的节点的下一个节点的排名
                break;
            }
            if(node.no == temp.next.no){//有重复的节点，使其无法插入
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if(flag){
            System.out.println("插入数据重复，" + "重复编号为：" + node.no); //重复的节点无法插入
        }else{
            node.next = temp.next; //要插入的节点的next = temp.next
            temp.next = node; //temp.next = 要插入的节点
        }
    }

    //修改单链表中的数据
    //思路：
    //1.通过排名，找到要修改的节点
    //2.要修改的节点的name，nickName修改为要修改的值
    public void updata(HeroNode node){
        //判断单链表是否为空
        if(head.next == null){
            System.out.println("单链表为空~~");
            return;
        }
        //定义一个辅助变量temp
        HeroNode temp = head.next;
        boolean flag = false; //用于判断是否找到要修改的节点
        while(true){
            if(temp == null){//找到当前单链表的最后一个节点的下一节点
                break;
            }
            if(temp.no == node.no){//通过排名，找到要修改的节点
                flag = true;
                break;
            }
            temp = temp.next; //temp后移
        }
        if(flag){//找到要修改的节点
            temp.name = node.name;
            temp.nickName = node.nickName;
        }else{//未找到要修改的节点
            System.out.println("未找到该英雄~~");
        }
    }


    //遍历单链表
    public void show(){
        //判断单链表是否为空
        if(head.next == null){
            System.out.println("单链表为空~~");
            return;
        }
        //定义一个辅助变量temp
        HeroNode temp = head.next;//因为单链表至少有一个值
        while(true){
            if(temp == null){//找到当前单链表的最后一个节点的下一节点
                break;
            }
            System.out.println(temp);
            temp = temp.next; //temp后移
        }
    }
}

//创建英雄节点
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;
    }

    @Override
    public String toString() {
        return "heroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}

4.单链表的节点删除

1）思路：
①找到要删除的节点的前一个节点
②要删除的节点的next赋值给要删除的节点的前一节点的next
2）代码：

public class linkedList {
    public static void main(String[] args) {
        //创建heroNode的对象
        HeroNode h1 = new HeroNode(1,"宋江","及时雨");
        HeroNode h2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode h3 = new HeroNode(3,"吴用","智多星");
        HeroNode h4 = new HeroNode(4,"林冲","豹子头");
        HeroNode h5 = new HeroNode(4,"刻晴","玉衡星");

        //创建单链表对象
        SingerLinkedList singerLinkedList = new SingerLinkedList();
        
        singerLinkedList.addByOrder(h1);
        singerLinkedList.addByOrder(h4);
        singerLinkedList.addByOrder(h3);
        singerLinkedList.addByOrder(h2);
        singerLinkedList.show();
        System.out.println("修改后的链表情况*********************************");
        singerLinkedList.updata(h5);
        singerLinkedList.show();
        System.out.println("删除后的链表情况*********************************");
        singerLinkedList.delete(h3);
        singerLinkedList.show();

    }
}

//创建单链表：每一个英雄代表一个节点
class SingerLinkedList{
    private HeroNode head; //头节点：不存放具体的数据，用于定位单链表

    public SingerLinkedList() {
        head = new HeroNode(0,"","");
    }

    public void addByOrder(HeroNode node){
        //定义一个辅助变量temp代替head
        HeroNode temp = head;
        boolean flag = false; //用于处理重复节点
        while(true){
            if(temp.next == null){//找到当前单链表的最后一个节点
                break;
            }
            if(node.no < temp.next.no){ //要插入的节点的排名 要小于 要插入的节点的下一个节点的排名
                break;
            }
            if(node.no == temp.next.no){//有重复的节点，使其无法插入
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if(flag){
            System.out.println("插入数据重复，" + "重复编号为：" + node.no); //重复的节点无法插入
        }else{
            node.next = temp.next; //要插入的节点的next = temp.next
            temp.next = node; //temp.next = 要插入的节点
        }
    }

    public void updata(HeroNode node){
        //判断单链表是否为空
        if(head.next == null){
            System.out.println("单链表为空~~");
            return;
        }
        //定义一个辅助变量temp
        HeroNode temp = head.next;
        boolean flag = false; //用于判断是否找到要修改的节点
        while(true){
            if(temp == null){//找到当前单链表的最后一个节点的下一节点
                break;
            }
            if(temp.no == node.no){//通过排名，找到要修改的节点
                flag = true;
                break;
            }
            temp = temp.next; //temp后移
        }
        if(flag){//找到要修改的节点
            temp.name = node.name;
            temp.nickName = node.nickName;
        }else{//未找到要修改的节点
            System.out.println("未找到该英雄~~");
        }
    }

    //删除单链表中的数据
    //思路：
    //1.找到要删除的节点的前一个节点
    //2.要删除的节点的next赋值给要删除的节点的前一节点的next
    public void delete(HeroNode node){
        //判断单链表是否为空
        if(head.next == null){
            System.out.println("单链表为空~~");
            return;
        }
        //定义一个辅助变量temp
        HeroNode temp = head.next;
        boolean flag = false; //用于判断是否找到要删除的节点
        while(true){
            if(temp == null){//找到当前单链表的最后一个节点的下一节点
                break;
            }
            if(temp.next.no == node.no){//找到要删除的节点的前一个节点
                flag = true;
                break;
            }
            temp = temp.next; //temp后移
        }
        if(flag){//找到要删除的节点
            temp.next = node.next;//要删除的节点的next赋值给要删除的节点的前一节点的next
        }else{//未找到要修改的节点
            System.out.println("未找到该英雄~~");
        }
    }

    //遍历单链表
    public void show(){
        //判断单链表是否为空
        if(head.next == null){
            System.out.println("单链表为空~~");
            return;
        }
        //定义一个辅助变量temp
        HeroNode temp = head.next;//因为单链表至少有一个值
        while(true){
            if(temp == null){//找到当前单链表的最后一个节点的下一节点
                break;
            }
            System.out.println(temp);
            temp = temp.next; //temp后移
        }
    }
}
//创建英雄节点
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;
    }

    @Override
    public String toString() {
        return "heroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}
一点点星辰
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值