单链表的增删改查

1.链表介绍

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

小结:

链表是以节点的方式来存储,是链式存储

每个节点包含 data 域， next 域：指向下一个节点.

如上图：发现链表的各个节点不一定是连续存储.

链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定

2.带头节点的链表增删改查操作

分析示意图：

1）新增节点信息：

2）按照顺序新增节点信息：

3）删除节点信息：

3.代码演示：

package main.java.Demo04_单链表;

public class SingleLinkedListDemo {

    public static void main(String[] args) {

        HeroNode h1 = new HeroNode(1, "宋江1", "及时雨1");
        HeroNode h2 = new HeroNode(2, "宋江2", "及时雨2");
        HeroNode h3 = new HeroNode(3, "宋江3", "及时雨3");

        SingleLinkedList linkedList = new SingleLinkedList();
//        linkedList.add(h1);
//        linkedList.add(h2);
//        linkedList.add(h3);
//
//        linkedList.list();
//        System.out.println("------------------------");
//        linkedList.update(3,"宋江33","及时雨33");
//        System.out.println("修改后的链表为:");
//        linkedList.list();
//
//        System.out.println("------------------------");
//
//        linkedList.del(3);
//        System.out.println("删除后的链表为:");
//        linkedList.list();

        System.out.println("------------------------");

        HeroNode h4 = new HeroNode(4, "宋江4", "及时雨4");
        linkedList.addByOrder(h2);
        linkedList.addByOrder(h3);
        linkedList.addByOrder(h4);
        linkedList.addByOrder(h1);
        System.out.println("按照顺序添加后的链表为:");
        linkedList.list();

    }
}

//定义SingleLinkedList 管理我们的英雄
class SingleLinkedList {

    //先初始化一个头节点, 头节点不要动, 不存放具体的数据
    private HeroNode head = new HeroNode(0, "", "");


    //添加节点到单向链表
    //思路，当不考虑编号顺序时
    //1. 找到当前链表的最后节点
    //2. 将最后这个节点的next 指向 新的节点
    public void add(HeroNode heroNode) {

        //因为head节点不能动，因此我们需要一个辅助遍历 temp
        HeroNode temp = head;
        //遍历链表，找到最后
        while (true) {
            //找到链表的最后
            if (temp.next == null) {//
                break;
            }
            //如果没有找到最后, 将将temp后移
            temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //将最后这个节点的next 指向 新的节点
        temp.next = heroNode;
    }

    //第二种方式在添加英雄时，根据排名将英雄插入到指定位置
    //(如果有这个排名，则添加失败，并给出提示)
    public void addByOrder(HeroNode heroNode){

        HeroNode temp =head;
        while (true){
            if(temp.next==null){
                //遍历结束
                temp.next=heroNode;
                break;
            }

            if(temp.next.no>heroNode.no){
                //位置找到  插入位置就在temp和temp.next之间
                heroNode.next=temp.next;
                temp.next=heroNode;
                break;
            }else if (temp.next.no == heroNode.no) {
                //说明希望添加的heroNode的编号已然存在
                System.out.printf("准备插入的英雄的编号 %d 已经存在了, 不能加入\n", heroNode.no);
                break;
            }
            //后移，遍历当前链表
            temp=temp.next;
        }
    }

    //删除节点
    //思路
    //1. head 不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
    //2. 说明我们在比较时，是temp.next.no 和  需要删除的节点的no比较
    public void del(int no){
        HeroNode temp=head;
        while (true){
            //遍历结束
            if(temp.next==null){
                System.out.printf("无节点%d信息,不可删除\n",no);
                break;
            }
            //此处找到需要删除节点的前一个节点  将该节点的next域直接指向下下个即可
            if(temp.next.no==no){
                temp.next=temp.next.next;
                break;
            }
            //temp后移，遍历
            temp=temp.next;
        }

    }

    //修改节点
    public void update(int no, String name, String nickName) {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        HeroNode temp = head.next;
        while (true) {
            if(temp==null){
                //遍历完还没找到就直接结束
                System.out.printf("无节点%d信息,不可修改\n",no);
                break;
            }
            if (temp.no == no) {
                temp.name = name;
                temp.nickname = nickName;
                break;
            }
            //temp后移，遍历
            temp=temp.next;
        }
    }


    //显示链表[遍历]
    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);
            //temp后移
            temp = temp.next;
        }
    }

}


//定义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 + "]";
    }


}

运行结果如下：