03单链表及代码实现

链表介绍（Linked List）

链表是有序列表，存储方式如下图（物理结构图）
在这里插入图片描述

链表小结

链表是以结点的方式来存储的。链式存储。
每个结点包含data域、next域（指向下一个结点）。
要注意的是，链表的各个结点不一定是连续存储。
链表分带头结点的和没有头结点的链表。需要根据实际需求来确定。

链表的逻辑结构
在这里插入图片描述

单链表的应用实例

使用带head头的单向链表实现《水浒英雄排行榜管理》

完成对英雄人物的增删改查操作。
第一种方法在添加英雄时，直接添加到链表的尾部。
第二种方法在添加英雄时，根据排名将英雄插入到指定位置。（如果有这个排名，则添加失败，并给出提示）

在这里插入图片描述

添加/创建结点

先创建一个头结点，作用就是表示单链表的头
后面每添加一个结点，就直接加入到链表的最后。

遍历

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

第一种方法代码

package com.linkedlist;

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        //创建三个结点
        HeroNode heroNode1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode heroNode2 = new HeroNode(2, "玉麒麟", "卢俊义");
        HeroNode heroNode3 = new HeroNode(3, "吴用", "智多星");
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.addNode(heroNode1);
        singleLinkedList.addNode(heroNode2);
        singleLinkedList.addNode(heroNode3);
        singleLinkedList.showList();
    }
}

//使用单链表来管理英雄
class SingleLinkedList {
    //初始化一个头结点，一般不能动,
    // 而且每创建一个单链表都需要创建一个头。
    // 所以不需要将他修饰为static final
    private HeroNode head = new HeroNode(0, "", "");

    //添加结点
    public void addNode(HeroNode hero) {
        //找到最后一个结点
        //因为head结点不能用，所以先拷贝一份
        HeroNode temp = head;
        while (true) {
            //最后一个结点特点，结点的next属性值为null
            if (temp.next == null) {
                break;
            }
            temp = temp.next;//指针后移
        }
        //完成上面的循环以后temp指向的是最后一个结点
        temp.next = hero;
    }

    //显示链表【遍历】
    public void showList() {
        /**
         * 1. 判断链表是否为空。
         * 2. 因为头结点不能动，所以拷贝一份。temp
         */
        if (head.next == null) {
            System.out.println("当前链表为空");
            return;
        }
        //因为头结点没有使用，所以第一个显示的结点就是head.next
        HeroNode temp = head.next;
        while (temp != null){
            System.out.println(temp);
            temp = temp.next;//变量后移
        }
    }
}

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

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

注意：

这种添加英雄方式如果添加顺序和编号不一致，得到的链表顺序和添加顺序一样也不一致。不能满足我们日常的需求。所以需要对上面的代码进行改进，想办法通过对序号进行比较，然后使得链表最终得到的顺序和结点中元素序号顺序一致。

第二种方法代码

通过对上面的代码进行改进得到：根据排名将英雄插入到指定位置。（如果这个元素已经存在，给出提示）

按照编号的顺序添加
	1. 首先找到新添加的结点的位置，通过辅助变量（temp指针）。通过遍历来完成。
	2. 新的结点.next = temp.next
	3. 将temp.next = 新的结点

原有基础上再SingleLinkedList中添加方法addNodeByOrder。

//根据序号来添加。
    public void addNodeByOrder(HeroNode hero) {
        //同理，做一个拷贝
        HeroNode temp = head;
        boolean flag = false; //添加的编号是否存在
        //这个指针要找到添加位置的前一个结点。
        while (true) {
            if (temp.next == null) {
                break;//如果此时就是最后一个结点
            }
            //下面这两个顺序不能交换，一定是先判断是否存在再判断下一个编号是否大
            if (temp.no == hero.no) {
                flag = true;//此时已经存在了
                break;
            }
            if (temp.next.no > hero.no) {
                break;//位置找到了在这个后面添加
            }
            temp = temp.next;
        }
        if (flag){
            System.out.printf("准备加入的英雄%d  %s已经存在了，不能添加\n",hero.no, hero.name);
        }else {
            //插入到temp后面 -- 这个顺序不能搞错了。
            hero.next = temp.next;
            temp.next = hero;
        }
    }

测试用例改为

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 heroNode5 = new HeroNode(5, "鲁智深", "花和尚");
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.addNodeByOrder(heroNode4);
        singleLinkedList.addNodeByOrder(heroNode2);
        singleLinkedList.addNodeByOrder(heroNode3);
        singleLinkedList.addNodeByOrder(heroNode1);
        singleLinkedList.addNodeByOrder(heroNode3);
        singleLinkedList.addNodeByOrder(heroNode5);
        singleLinkedList.showList();
    }

修改结点

修改结点信息，通过hero.no进行定位。同时注意no不能改变。

    public void update(HeroNode newHero) {
        /**
         * 思路
         * 1. 判断是否为空
         * 2. 找到需要修改的结点
         */
        if (head.next == null){
            System.out.println("链表为空，不满足修改条件");
            return;
        }

        HeroNode temp = head;
        boolean flag = false;
        while (true){
            if (temp == null){      //遍历完了都没有找到
                break;//已经遍历结束了
            }
            if (temp.no == newHero.no){
                flag = true;
                break;

            }
            temp = temp.next;
        }
        if (flag){
            temp.name = newHero.name;
            temp.nickName = newHero.nickName;
        }else {
            System.out.printf("没有找到 编号为 %d 的结点信息，不能修改\n",newHero.no);
        }
    }

删除结点

思路：

我们先找到需要删除的这个结点的前一个结点
temp.next = temp.next.next
被删除的结点，将不会有其它引用指向，剩下的交给java的垃圾回收机制。

/**
     * 思路：
     * 1. 我们先找到需要删除的这个结点的前一个结点
     * 2. temp.next = temp.next.next
     * 3. 被删除的结点，将不会有其它引用指向，剩下的交给java的垃圾回收机制。
     */
    public void deleteNode(int no){
        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;
            System.out.printf("成功删除编号为 %d 的结点\n", no);
        }else {
            System.out.printf("没有找到编号为 %d 的结点\n", no);
        }
    }

编码注意

使用Node类来确定结点信息、使用LinkedList类来管理Node结点、在Demo中进行测试
LinkedList中使用的是有头结点的链表。要注意头结点不能动。
每次要对链表进行操作时候，一定要先对head结点备份。（不能直接操作head结点）
遍历过程一定要将temp变量（指针）后移

代码整合

package com.linkedlist;

public class SingleLinkedListDemo {
    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 heroNode5 = new HeroNode(5, "鲁智深", "花和尚");
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        //singleLinkedList.addNode(heroNode1);
        //singleLinkedList.addNode(heroNode2);
        //singleLinkedList.addNode(heroNode3);

        singleLinkedList.addNodeByOrder(heroNode4);
        singleLinkedList.addNodeByOrder(heroNode2);
        singleLinkedList.addNodeByOrder(heroNode3);
        singleLinkedList.addNodeByOrder(heroNode1);
        singleLinkedList.addNodeByOrder(heroNode3);
        singleLinkedList.addNodeByOrder(heroNode5);
        singleLinkedList.showList();

        System.out.println("==========修改后的信息==========");
        singleLinkedList.updateNode(new HeroNode(5, "花荣", "小李广"));
        singleLinkedList.updateNode(new HeroNode(8, "花荣", "小李广"));
        singleLinkedList.showList();

        System.out.println("========删除后的结点信息=========");
        singleLinkedList.deleteNode(1);
        singleLinkedList.deleteNode(8);
        singleLinkedList.showList();
    }
}

//使用单链表来管理英雄
class SingleLinkedList {
    //初始化一个头结点，一般不能动,
    // 而且每创建一个单链表都需要创建一个头。
    // 所以不需要将他修饰为static final
    private HeroNode head = new HeroNode(0, "", "");

    //添加结点
    public void addNode(HeroNode hero) {
        //找到最后一个结点
        //因为head结点不能用，所以先拷贝一份
        HeroNode temp = head;
        while (true) {
            //最后一个结点特点，结点的next属性值为null
            if (temp.next == null) {
                break;
            }
            temp = temp.next;//指针后移
        }
        //完成上面的循环以后temp指向的是最后一个结点
        temp.next = hero;
    }

    //根据序号来添加。
    public void addNodeByOrder(HeroNode hero) {
        //同理，做一个拷贝
        HeroNode temp = head;
        boolean flag = false; //添加的编号是否存在
        //这个指针要找到添加位置的前一个结点。
        while (true) {
            if (temp.next == null) {
                break;//如果此时就是最后一个结点
            }
            //下面这两个顺序不能交换，一定是先判断是否存在再判断下一个编号是否大
            if (temp.no == hero.no) {
                flag = true;//此时已经存在了
                break;
            }
            if (temp.next.no > hero.no) {
                break;//位置找到了在这个后面添加
            }
            temp = temp.next;
        }
        if (flag) {
            System.out.printf("准备加入的英雄%d  %s已经存在了，不能添加\n", hero.no, hero.name);
        } else {
            //插入到temp后面 -- 这个顺序不能搞错了。
            hero.next = temp.next;
            temp.next = hero;
        }
    }

    //修改结点信息，通过newHero.no进行定位。同时注意no不能改变。
    public void updateNode(HeroNode newHero) {
        /**
         * 思路
         * 1. 判断是否为空
         * 2. 找到需要修改的结点
         */
        if (head.next == null){
            System.out.println("链表为空，不满足修改条件");
            return;
        }

        HeroNode temp = head;
        boolean flag = false;
        while (true){
            if (temp == null){      //遍历完了都没有找到
                break;//已经遍历结束了
            }
            if (temp.no == newHero.no){
                flag = true;
                break;

            }
            temp = temp.next;
        }
        if (flag){
            temp.name = newHero.name;
            temp.nickName = newHero.nickName;
        }else {
            System.out.printf("没有找到 编号为 %d 的结点信息，不能修改\n",newHero.no);
        }
    }

    //删除结点 -- 通过英雄编号，即hero.no

    /**
     * 思路：
     * 1. 我们先找到需要删除的这个结点的前一个结点
     * 2. temp.next = temp.next.next
     * 3. 被删除的结点，将不会有其它引用指向，剩下的交给java的垃圾回收机制。
     */
    public void deleteNode(int no){
        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;
            System.out.printf("成功删除编号为 %d 的结点\n", no);
        }else {
            System.out.printf("没有找到编号为 %d 的结点\n", no);
        }
    }

    //显示链表【遍历】
    public void showList() {
        /**
         * 1. 判断链表是否为空。
         * 2. 因为头结点不能动，所以拷贝一份。temp
         */
        if (head.next == null) {
            System.out.println("当前链表为空");
            return;
        }
        //因为头结点没有使用，所以第一个显示的结点就是head.next
        HeroNode temp = head.next;
        while (temp != null) {
            System.out.println(temp);
            temp = temp.next;//变量后移
        }
    }
}

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

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