数据结构之单链表，详细解释单链表的增删改查操作，图文并茂，分布实现

1.单向链表基本介绍

1）单链表节点的基本介绍

首先我们来介绍节点（Node）是什么，节点是构成链表的基本元素。节点信息一共包含两个部分：

1.数据域：用来存储节点本身的数据
2.指针域：用来存储指向下一个节点或者上一个节点的地址

举例说明：

  假设我现在需要使用链表来存储水浒传中的英雄人物，每一个英雄人物都有姓  名、编号、昵称。那么此时的节点Node就是英雄人物，数据域就用来
存放姓名、编号、昵称，指针域就用来指向下一个英雄或者上一个英雄，由于讲解的是单向链表，所以指针域只有下一个英雄的地址。    

单向链表节点代码设计如下：

/**
 * 定义HeroNode英雄节点类，每个HeroNode，就代表一个节点
 */
class HeroNode{
    /**
     * 1.数据域：编号、姓名、昵称
     */
    //编号
    public int no;
    //姓名
    public String name;
    //昵称
    public String nickname;
    /**
     * 2.指针域：下一个节点地址next
     */
    //下一个英雄节点
    public HeroNode next;
    //构造器
    public HeroNode() {}
    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 + '\'' +
                '}';
    }
}

2）单链表基本介绍

单向链表顾名思义：只能单向访问，也就是说，只能通过当前节点获取到下一个节点，但是不能通过当前节点获取上一个节点。

单向链表类中：
  1.属性：只需要维护一个head头节点即可，每添加一个节点，就使用next链接即可，通过head可以拿到整条链表。
  2.方法：增删改查等。
  注意：head头节点有两种设计方案
  第一种是head数据域不保存任何内容，数据域为null，next指向保存了具体内容的英雄节点，head作用仅仅只是指向了第一个英雄节点。
  第二种是head数据域保存了具体的内容，是实实在在的第一个英雄节点。
  本文均采用的是第一种设计方案。

2.单向链表的图示

3.单向链表的功能分析

1）添加节点

传入一个英雄节点heroNode,将该节点加入链表

思路分析：
1.只需要将新的节点添加到链表末尾即可
2.因为head头节点不能动，所以我们使用辅助节点temp来进行链表的遍历
3.找到最后一个节点，让最后一个节点的next指向新的节点即可，新的节点的next默认为null，不用理会。
代码如下：

    public void add(HeroNode heroNode){
        //因为head节点不能动，因此我们需要一个辅助遍历 temp
        HeroNode temp = head;
        //遍历链表，找到最后一个节点
        while(temp.next != null){
            //temp往后偏移
            temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表最后一个节点
        //此时将temp的next 指向 新的节点
        temp.next = heroNode;
    }

图解

2）删除节点

根据英雄的编号no来删除对应的节点

思路分析：
1.我们需要找到待删除节点的前一个节点temp，这里为什么不直接找到待删除节点呢？因为是单向链表，找到待删除节点没用，无法拿到它的前一个节点，无法达到删除目的。
2.让待删除节点的前一个节点，也就是temp的下一个节点更新为待删除节点的下一个节点。
 temp.next = temp.next.next
3.被删除的节点没有引用指向，会被java的垃圾回收机制回收。
代码如下：

    public void delete(int no){
        //创建辅助节点来找到被删除节点的前一个节点
        HeroNode temp = head;
        boolean flag = false;//判断是否找到需要被删除的节点 找到为true
        while(temp != null){
            //判断链表是否为空
            if (head.next == null) {
                System.out.println("链表为空，无法删除！");
                break;
            }
            else if (temp.next.no == no){
                //找到被删除节点的前一个
                flag = true;
                break;
            }
            //temp后移
            temp = temp.next;
        }
        //根据flag判断是否找到需要被删除的节点
        if (flag)//找到
            temp.next = temp.next.next;
        else//没找到
            System.out.println("要删除的节点编号" + no + "不存在！");
    }

图解

3）查找节点

根据英雄编号no来查找该节点

思路分析
1.使用辅助节点temp遍历链表，判断temp.no是否等于传入的no
2.找到节点则返回该节点，找不到则返回null
代码如下：

    public HeroNode find(int no){
        //1.判断是否为空
        if (head.next == null) {
            System.out.println("链表为空！");
            return null;
        }
        //2.根据no编号找到需要修改的节点
        //定义一个辅助变量遍历查找
        HeroNode temp = head.next;
        while(temp != null){
            if (temp.no == no){
                //找到了，直接返回
                return temp;
            }
            //temp后移
            temp = temp.next;
        }
        //程序执行到这里说明找不到
        return null;
    }

4）修改节点

传入新的英雄节点，根据新英雄编号no来修改节点信息

思路分析
1.通过查找方法来查找节点
2.找到了则修改信息，找不到则不做处理
代码如下：

    public void update(HeroNode newHeroNode) {
        //调用查找方法来查找编号为newHeroNode.no的英雄编号
        HeroNode temp = find(newHeroNode.no);
        //如果temp不为空说明找到了
        if (temp != null){
            //根据编号重置信息
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        } else
            System.out.println("没有找到编号为" + newHeroNode.no + "的节点，无法修改！");
    }

5）遍历链表

思路分析
1.由于头节点head不能改变，所以需要创建一个辅助节点temp来帮助遍历即可
代码如下：

    public void showList(){
        //1.判断链表是否为空
        if (head.next == null){
            System.out.println("链表为空！");
            return;
        }
        //2.程序执行到这里说明不为空，头节点不能动，所以需要辅助节点来遍历
        HeroNode temp = head.next;
        while(temp != null){
            //程序走到这里说明没有到末尾
            System.out.println(temp);
            //temp向后偏移
            temp = temp.next;
        }
    }

4.单向链表的整体代码实现

整个单链表类SIngleLinkedList的具体代码实现如下：

class SingleLinkedList{
    //先初始化一个头节点用来维护整条链表，头节点不要动，不要存放具体数据
    private HeroNode head = new HeroNode();
    /**
     * 添加节点add
     */
    public void add(HeroNode heroNode){
        //因为head节点不能动，因此我们需要一个辅助遍历 temp
        HeroNode temp = head;
        //遍历链表，找到最后一个节点
        while(temp.next != null){
            //temp往后偏移
            temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表最后一个节点
        //此时将temp的next 指向 新的节点
        temp.next = heroNode;
       }
    /**
     * 查找链表中的某个节点
     * @param no 待查找节点编号
     * @return 找到返回该节点，找不到返回null
     */
    public HeroNode find(int no){
        //1.判断是否为空
        if (head.next == null) {
            System.out.println("链表为空！");
            return null;
        }
        //2.根据no编号找到需要修改的节点
        //定义一个辅助变量遍历查找
        HeroNode temp = head.next;
        while(temp != null){
            if (temp.no == no){
                //找到了，直接返回
                return temp;
            }
            //temp后移
            temp = temp.next;
        }
        //程序执行到这里说明找不到
        return null;
    }
    /**
     * 修改节点信息，根据no编号来修改，即no编号不能改变
     */
    public void update(HeroNode newHeroNode) {
        //调用查找方法来查找编号为newHeroNode.no的英雄编号
        HeroNode temp = find(newHeroNode.no);
        //如果temp不为空说明找到了
        if (temp != null){
            //根据编号重置信息
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        } else
            System.out.println("没有找到编号为" + newHeroNode.no + "的节点，无法修改！");
    }

    /**
     * 删除一个节点方法
     * 思路：
     *   1.我们先找到需要删除的这个节点的前一个节点temp
     *   2.temp.next = temp.next.next
     *   3.被删除的节点，将不会有其他引用指向，所以会被垃圾回收机制回收
     */
    public void delete(int no){
        //创建辅助节点来找到被删除节点的前一个节点
        HeroNode temp = head;
        boolean flag = false;//判断是否找到需要被删除的节点 找到为true
        while(temp != null){
            //判断链表是否为空
            if (head.next == null) {
                System.out.println("链表为空，无法删除！");
                break;
            }
            else if (temp.next.no == no){
                //找到被删除节点的前一个
                flag = true;
                break;
            }
            //temp后移
            temp = temp.next;
        }
        //根据flag判断是否找到需要被删除的节点
        if (flag)//找到
            temp.next = temp.next.next;
        else//没找到
            System.out.println("要删除的节点编号" + no + "不存在！");
    }
 } 

5.单向链表的优缺点

优点：增加节点以及删除节点的效率高
缺点：查找效率低，因为只能通过头节点一个一个查找