Java单链表的学习

前面已经学习过了线性结构中：稀疏数组、队列今天接着学习线性结构——链表

1.链表常见的形式:
链表是有序的列表，一般链表有单链表，双向链表，循环链表。
2.什么是单链表?
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。(百度百科解释)
3.通过具体的图解来理解什么是单链表。

图解:
通过上图总结链表的特点:

1. 链表是以节点的方式来存储，是链式存储。
2. 每个节点包含data域，next域，指向下一个节点。
3. 链表的各个节点不一定是连续存储。
4. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定。

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

通过上面的概念和图解，想必大家对单链表有了初步的认识。
下面就通过模拟单链表，以及对单链表的增删改查操作作进一步的了解。

模拟单链表使用场景:

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

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

前面说过一个节点由data域和next域组成，这里data域存放的是英雄排名、姓名、绰号、next域存放下一个节点的地址。

面向对象思想：每一个节点看做一个对象封装data域信息和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 + '\'' +
                '}';
    }
}

接着对单链表增删改查操作一一分析。

01单链表添加操作

单链表添加操作可以分为直接添加到链表尾部(没有排序)、根据排名将英雄插入到指定位置两种方式。

方式一：直接添加到链表的尾部
思路分析:
1.先创建一个head头节点(头节点的位置不变,保证每个新节点都能添加到链表尾部)，作用是表示单链表的头
2.每添加一个节点到单链表最后
3.借助辅助变量,帮助遍历整个链表
3.遍历:
找出新节点的位置
temp.next指向新节点

具体代码:

    //添加节点
    public void add(HeroNode heroNode) {
        //定义辅助变量指向头节点
        HeroNode temp = head;
        //找到当前链表的最后节点 需要遍历
        while (true) {
            //判断是否存在下一个节点
            if (temp.next == null) {
                break;
            }
            //如果没有找到temp后移
            temp = temp.next;
        }
        //将最后这个节点的next 指向新节点
        temp.next = heroNode;
    }

方式二：根据排名将英雄插入到指定位置
思路分析:
1.找到添加节点的位置 应该是在 辅助变量和辅助变量.next 中间
2.找到了位置以后
3.temp.next = heroNode;
4.heroNode.next = temp.next;
5.我们找到的temp,是位于添加位置的前一个节点

具体代码:

public void addByOrder(HeroNode heroNode) {
      	//定义辅助变量指向头节点
        HeroNode temp = head;
        boolean flag = false;//定义标记 表示是否重复添加英雄
        while (true) {
        	//如果单链表没有一个节点 结束循环
            if (temp.next == null) {
                break;
            }
            //单链表节点的序号大于新节点的序号 结束循环
            if (temp.next.no > heroNode.no) {
                break;
            } else if (temp.next.no == heroNode.no) {//重复添加英雄
                //将标记符置位true
                flag = true;
                break;
            }
            //后移
            temp = temp.next;
        }
        //添加重复英雄，给与提示
        if (flag) {
            System.out.printf("准备添加%d号的英雄,已存在不能加入\n", heroNode.no);
        }
        //插入链表 temp的后面
        heroNode.next = temp.next;
        temp.next = heroNode;
    }

02单链表删除操作

思路分析:

1.找到需要删除节点的位置
2.删除节点后需要将删除节点的前一个节点与后一个节点连接起来
3. temp.next == temp.next.next;

具体代码:

 public void delete(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;
        } else {
            System.out.printf("要删除的节点%d号,不存在", no);
        }
    }

03单链表修改操作

思路分析:

1.找到要修改的数据的前一个节点
2.只能修改节点的姓名和昵称 不能修改节点的编号如果要修改成了添加一个节点

具体代码:

 public void update(HeroNode newHeroNode) {
        //判断是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //辅助变量
        HeroNode temp = head.next;
        boolean flag = false;//标记是找到修改的节点
        //循环判断是否存在要修改的节点信息
        while (true) {
            if (temp == null) {
                break;
            }
            if (temp.no == newHeroNode.no) {
                flag = true;
                break;
            }
            //如果上述条件都不满足,则继续循环遍历查找要修改的节点
            temp = temp.next;
        }
        //判断标记是否为true
        if (flag) {
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        } else {
            System.out.printf("要修改的节点%d号,不存在\n", newHeroNode.no);
        }
    }

04单链表查找操作

思路分析:

1. 判断链表是否为空
2. 直接输出节点的信息(重写了toString方法)

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

05整合

首先定一个SingleLinkList类，其次定义头结点。将上述的增删改查方法添加进来。进行测试即可。

//定义SingleLinkedList
class SingleLinkedList {
    //定义头结点 位置保持不变
    private HeroNode head = new HeroNode(0, "", "");

    /**
     * 1.找到当前链表的最后节点
     * 2.将这个节点的next 指向下一个节点
     *
     * @param heroNode
     */
    //添加节点
    public void add(HeroNode heroNode) {
        //定义辅助变量指向头节点
        HeroNode temp = head;
        //找到当前链表的最后节点 需要遍历
        while (true) {
            //判断是否存在下一个节点
            if (temp.next == null) {
                break;
            }
            //如果没有找到temp后移
            temp = temp.next;
        }
        //将最后这个节点的next 指向新节点
        temp.next = heroNode;
    }

    public void addByOrder(HeroNode heroNode) {
        //找到添加节点的位置  应该是在 辅助变量和辅助变量.next 中间
        //找到了位置以后
        //temp.next = heroNode;
        //heroNode.next = temp.next;
        //我们找到的temp,是位于添加位置的前一个节点
        HeroNode temp = head;
        boolean flag = false;//定义标记 表示是否重复添加英雄
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no > heroNode.no) {
                break;
            } else if (temp.next.no == heroNode.no) {//重复添加英雄
                //将标记符置位true
                flag = true;
                break;
            }
            //后移
            temp = temp.next;
        }
        if (flag) {
            System.out.printf("准备添加%d号的英雄,已存在不能加入\n", heroNode.no);
        }
        //插入链表 temp的后面
        heroNode.next = temp.next;
        temp.next = heroNode;
    }

    /**
     * 修改单链表的数据信息
     * 1.找到要修改的数据的前一个节点
     * 2.只能修改节点的姓名和昵称 不能修改节点的编号如果要修改成了添加一个节点
     */
    public void update(HeroNode newHeroNode) {
        //判断是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //辅助变量
        HeroNode temp = head.next;
        boolean flag = false;//标记是找到修改的节点
        //循环判断是否存在要修改的节点信息
        while (true) {
            if (temp == null) {
                break;
            }
            if (temp.no == newHeroNode.no) {
                flag = true;
                break;
            }
            //如果上述条件都不满足,则继续循环遍历查找要修改的节点
            temp = temp.next;
        }
        //判断标记是否为true
        if (flag) {
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        } else {
            System.out.printf("要修改的节点%d号,不存在\n", newHeroNode.no);
        }
    }

    /**
     * 删除节点信息
     * 思路:
     * 1.找到需要删除节点的位置
     * 2.删除节点后需要将删除节点的前一个节点与后一个节点连接起来
     * temp.next == temp.next.next;
     */
    public void delete(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;
        } else {
            System.out.printf("要删除的节点%d号,不存在", no);
        }
    }


    //显示链表[遍历]
    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.next;

        }
    }
}

05总结

1. 借助标记，实现了代码的逻辑和清晰度。
2. 使用辅助变量，化解头节点不能动的尴尬。
3. 灵活运用面向对象的思想。
4. 图解也许是理解程序的另一种方式。