java数据结构与算法：java代码模拟带头节点单向链表的业务

Posted 2021-12-08 温文艾尔

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

• 一、链表
• 二、使用带head头的单向链表完成对数据的增删改查操作
• • 1.单链表的遍历模拟
  • 2.单链表的添加模拟
  • 3.单链表的修改模拟
  • 4.单链表的删除模拟

---

一、链表

链表是有序的列表，他在内存中的存储如下

物理结构示意图‘

1. 链表是以节点的方式来存储,是链式存储
2. 每个节点包含data域，next域：指向下一个节点
3. 链表的各个节点不一定是连续存储
4. 链表分带头节点的链表和不带头结点的链表，根据实际需求来确定
   示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。

带头节点单链表的逻辑结构示意图

二、使用带head头的单向链表完成对数据的增删改查操作

1.单链表的遍历模拟

通过一个辅助遍历，帮助遍历整个链表

package org.wql.LinkedList;

/**
 * Description
 * User:
 * Date:
 * Time:
 */
public class SingleLinkedListDemo {
    public static void main(String[] args) {
        HeroNode hero1 = new HeroNode(1, "aaa", "111");
        HeroNode hero2 = new HeroNode(2, "bbb", "222");
        HeroNode hero3 = new HeroNode(3, "ccc", "333");
        HeroNode hero4 = new HeroNode(4, "ddd", "444");
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero2);
        singleLinkedList.list();

    }
}

class SingleLinkedList{
    //头节点，不存放具体的数据
    private HeroNode head = new HeroNode(0,"","");



    //遍历链表
    public void list(){
        if(head.next==null){
            System.out.println("链表为空");
            return;
        }
        HeroNode temp = head;
        while (temp.next!=null){
            temp = temp.next;
            System.out.println(temp);
        }
    }
}

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

    //构造器
    public HeroNode(int hNo,String hName,String hNickname){
        this.no = hNo;
        this.name = hName;
        this.nickName = hNickname;
    }

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

2.单链表的添加模拟

第一种方法，添加数据时直接添加到链表的尾部

创建链表

1. 先创建一个head头节点，作用就是表示单链表的头
2. 后面我们每添加一个节点，就直接加入到队尾

    /*
    *添加节点到单向链表
    *当不考虑编号顺序时
    * 1.找到当前链表的最后节点
    * 2.将最后这个节点的next指向新的节点
     */
    public void add(HeroNode heroNode){
        //因为head节点不能动，所以我们需要一个辅助节点
        HeroNode temp = head;
        //遍历链表，找到最后
        while (true){
            if(temp.next==null){
                //已经到链表末尾
                break;
            }
                temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        temp.next=heroNode;
    }

第二种方法，添加数据时将数据插入到指定的位置

    //按照指定顺序添加节点
    public void addByOrder(HeroNode heroNode){
        HeroNode temp = head;
        while (true){
            if(temp.next==null){
                add(heroNode);
                break;
            }
            if(temp.next.no>heroNode.no){
                heroNode.next=temp.next;
                temp.next=heroNode;
                break;
            }else if(temp.next.no==heroNode.no){
                System.out.println("准备插入的数据已经存在");
                break;
            }
            temp = temp.next;
        }
    }

3.单链表的修改模拟

    //根据no对单链表进行修改
    public void update(HeroNode newNode){
        HeroNode temp = head;
        if(head.next==null){
            System.out.println("链表为空");
        }
        while (true){
            if(temp.next==null){
                System.out.println("不存在该节点");
                break;
            }
            if(temp.next.no==newNode.no){
                temp.next.name = newNode.name;
                temp.next.nickName = newNode.nickName;

                break;
            }
            temp = temp.next;
        }
    }

4.单链表的删除模拟

在单链表中删除一个节点的思路

1. 我们先找到需要删除的这个节点的前一个节点temp
2. temp.next=temp.next.next

需要注意的是，删除之后的节点会被jvm的垃圾回收机制给处理掉

    //链表某个节点的删除
    public void delete(HeroNode heroNode){
        if(head.next==null){
            System.out.println("该链表为空");
        }
        HeroNode temp = head;
        while (true){
            if(temp.next==null){
                System.out.println("不存在该节点！");
                break;
            }
            if(temp.next.no==heroNode.no){
                //先去除要删除节点和它下一个节点的关联
                temp.next=temp.next.next;
                break;
            }
            temp=temp.next;
        }
    }