单链表学习

1.链表的介绍

链表是有序的列表，以节点的方式来存储，每个节点包含data域，next域，指向下一个节点
----

2.单链表的应用实例

需求：使用带head头节点的单向链表，实现对水浒传人物的curd
两种方式：
方式一：在添加英雄的时候，直接添加到链表的尾部
方式二：再添加英雄的时候，根据历史将英雄插入到指定的位置

思路分析：
	创建：
	1.先创建一个头结点，head，作用就是单链表的头
	2.后面我们每添加一个节点，就是直接加入到链表的最后
	遍历：
	1.通过一个辅助变量，帮助遍历整个链表

这里要重点强调一下头节点，头节点不能动，且为空，id为0；

方式一代码实现：

package com.wxit.linkedlist;

/**
 * @Author wj
 **/
public class SingleLinkedListDemo {
    public static void main(String[] args) {
        //测试,先创建节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");

        //创建链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();

        //加入
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);
        singleLinkedList.add(hero4);

        //显示
        singleLinkedList.list();
    }
}

class HeroNode{
    public int id;
    public String name;
    public String nickName;
    public HeroNode next;

    //构造器
    public HeroNode(int id, String name, String nickName) {
        this.id = id;
        this.name = name;
        this.nickName = nickName;
    }

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

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

方式二：添加的方法

 //第二种添加英雄的方式
    public void addById(HeroNode heroNode){
        //因为头节点不能动，因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
        //因为单链表，因为我们找的 temp 是位于 添加位置的前一个节点，否则插入不了
        HeroNode temp = head;
        boolean flag = false; //标志添加的编号是否存在，默认为false
        while (true){
            if (temp.next ==null){//说明temp已经在链表的最后
                break;
            }
            if(temp.next.id > heroNode.id){//位置找到了，就在temp后面插入
                break;
            } else if (temp.next.id == heroNode.id){//说明希望添加的编号已经存在
                flag = true;//说明编号存在
                break;
            }
            temp = temp.next;//后移，遍历当前链表
        }
        //判断flag的值
        if (flag){//不能呢添加，说明编号已经存在
            System.out.print("要添加的编号已经存在，不能加入" + heroNode.id);
        } else {
            //插入到链表中，temp后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

修改节点的方法
代码示例：

    //修改节点的信息,根据id编号来修改，即id不能改
    /**
     * 说明：根据根据新的节点的id来修改即可
     */
    public void update(HeroNode newHeroNode){
        //判断是否为空
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点,根据id编号
        /**
         * 定义一个辅助变量
         */
        HeroNode temp = head.next;
        boolean flag = false;//表示是否找到该节点
        while (true){
            if (temp == null){
                break;//已经遍历完链表
            }
            if (temp.id == newHeroNode.id){
                //找到
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //根据flag判断是否找到要修改的节点
        if (flag){
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;
        } else {
            System.out.println("没有找到要修改的节点");
        }
    }

删除节点
从单链表中删除一个节点的思路：
1.先找到需要删除的节点的前一个节点，temp
2.让temp.next = temp.next.next
3.被删除的节点将不会有其他引用指向，会被垃圾回收机制回收
代码如下：

 //删除节点的代码
    /**
     * 思路：head节点不能动，因此我们需要一个辅助节点，找到待删除的节点的前一个节点
     * 我们在比较的时候，是temp.next.id和需要被删除的节点的id比较
     */
    public void del(int id){
        HeroNode temp = head;
        boolean flag = false;//标志是否找到待删除的节点
        while (true){
            if (temp.next == null){//已经到链表的最后
                break;
            }
            if (temp.next.id == id){
                //找到待删除节点的前一个节点
                flag = true;
                break;
            }
            temp = temp.next;//temp后移，遍历
        }
        //判断flag
        if (flag){
            //找到,可以删除
            temp.next = temp.next.next;
        } else {
            System.out.println("没有找到要删除的节点");
        }
    }