Java 数据结构与算法： 单链表

链表 (Linked List)

一、单链表

目录：

1. 链表的存储结构

2. 知识点

3. 单向链表的功能实现

   ​ 1). 节点的定义

   ​ 2). 插入

   ​ 3). 遍历

   ​ 4). 修改

   ​ 5). 删除

4. 习题

   ​ 1). 求链表的长度

   ​ 2). 求倒数第 k 个节点

   ​ 3). 反转链表

   ​ 4). 合并两个有序的链表

1. 链表的存储结构：

​ 1). 链表是有序存储的，但在内存中是按照下图方式来进行存储的

​ 2). 我们更常见的是链表的逻辑结构，如下图所示：

2. 知识点：

1). 链表是以节点的方式来存储的，是链式存储

2). 每个节点包含 data 域， next 域，其中 next 指向下一个节点

3). 在实际的存储中，链表的各个节点不一定是连续存储的

4). 链表分带头节点和不带头节点的链表，根据实际的需求来确定；一般用头节点来代表整个链表

3. 单向链表的功能实现：

1). 节点定义：

class HeroNode{
    public int no;
    public String name;
    public String nickname; //梁山好汉的花名
    public HeroNode next;

    HeroNode(int no, String name, String nickname){
        this.no = no;
        this.name = name;
        this.nickname = nickname;
        this.next = null;
    }

    /**
     * 为了显示方便，我们便重写了 toString 方法
     * @return 该英雄节点的数据域信息
     */
    @Override
    public String toString(){
        return "HeroNode [no:" + this.no + " name:" + this.name + " nickname:" + this.nickname + " ]";
    }
}

2). 插入：(重点是辅助链接 tmp 的作用)

核心步骤：

step1: 找到目标位置（即应该插入到哪里），通过遍历链表实现

step2: 将节点插入目标位置处，巧用 next 链接指向

​ a. 直接在链表的尾部插入

 /**
  * 向链表中添加节点：直接添加到链表尾部，不考虑顺序
  * 思路：
  *  遍历整个链表找到当前链表尾部的节点（即 next 指向 null 的节点）；
  *  然后另此节点的 next 指向新加入的节点，新加入的节点的 next 指向 null。
  * @param heroNode 要向链表添加的节点
  */
public void add(HeroNode heroNode){
    // 由于链表的头节点不能动，因此需要一个辅助遍历链表的节点引用
    HeroNode tmp = this.head;

    // 1. 遍历整个链表，寻找位于链表尾部的节点
    while(tmp.next != null){
        tmp = tmp.next;
    }
    // 2. 将位于尾部的节点的 next 指向新加入的节点
    tmp.next = heroNode;
}

​

​ b. 在指定位置插入：

	/**
     * 向链表中添加节点：按照英雄序号 node.no 顺序（从小到大），并且需要判断是否存在重复节点
     * 思路：
     *      heroNode 所添加的位置要求 tmp.no < heroNode.no < tmp.next.no
     *      目标位置要是 heroNode 插入位置的前一个节点，因为这样才可以将 heroNode 插入
     *      step1: heroNode.next = tmp.next
     *      step2: tmp.next = heroNode
     * @param heroNode 添加的英雄节点
     */
    public void addByOrder(HeroNode heroNode){

        // 是否存在重复序号节点的标志，true-存在，false-不存在
        boolean flag = false;

        // 凡是涉及到遍历链表的操作，那么就需要一个辅助链接 tmp
        HeroNode tmp = this.head;

        // 1. 遍历寻找节点插入位置
        while(tmp != null){

            // 出现重复英雄序号，不予插入
            if(heroNode.no == tmp.no){
                flag = true;
                break;
            }
            
            // 如果链表为空，或者当前插入的节点序号又比当前链表中所有节点的序号都大，那么直接插在队尾
            /**
             * 注意：此判断一定要写在序号是否重复之后，
             * 因为如果此时插入的节点序号正好与当前链表中尾部节点序号相等，
             * 如果把此判断写在最前面，会没有判断序号是否重复而直接插入到链表末尾了。
             */
            if(tmp.next == null){
                break;
            }

            // 找到目标位置
            if(heroNode.no < tmp.next.no){
                break;
            }

            tmp = tmp.next;
        }

        // 2. 找到目标位置后，将节点插入链表中
        if(!flag){
            heroNode.next = tmp.next;
            tmp.next = heroNode;
        }else{
            System.out.printf("准备插入的英雄序号%d已经存在了，不能插入\n", heroNode.no);
        }

    }

3). 遍历：

   /**
     * 遍历整个链表
     * @param method 1-使用 while 循环方式遍历，2-使用 for 循环方式遍历。
     */
    public void showList(int method){

        // 首先链表不能为空，如果为空则立即返回
        if(this.head.next == null){
            System.out.println("此链表当前为空！");
            return;
        }

        if(method == 1){
            HeroNode tmp = this.head.next;
            while(tmp != null){
                // 对节点的操作
                System.out.println(tmp);
                tmp = tmp.next;
            }
        }else if(method == 2){
            for(HeroNode tmp = this.head.next; tmp != null; tmp = tmp.next){
                // 对节点的操作
                System.out.println(tmp);
            }
        }

    }

4). 修改：

    /**
     * 根据传入的节点 heroNode.no 对链表中对应编号节点的 name 和 nickname 进行修改
     * @param heroNode 修改样例
     */
    public void modify(HeroNode heroNode){
        if(this.head.next == null){
            System.out.println("当前链表为空，无法进行修改");
            return;
        }

        HeroNode tmp = this.head.next;
        boolean flag = false;   // 是否找到 no 与 heroNode.no 一致的节点标志

        // 1. 定位
        while(tmp != null){
            if(tmp.no == heroNode.no){
                flag = true;
                break;
            }
            tmp = tmp.next;
        }

        // 2. 修改
        if(flag){
            tmp.name = heroNode.name;
            tmp.nickname = heroNode.nickname;
        }else{
            System.out.printf("未找到编号为%d的节点\n", heroNode.no);
        }

    }

5). 删除

    /**
     * 删除指定编号的节点
     * 思路：
     *      1. 定位，找到要删除节点的前一个节点，即 tmp 为待删除节点的前一个节点，tmp.no = no
     *      2. 删除，令 tmp.next = tmp.next.next
     * @param no
     */
    public void delete(int no){
        if(this.head.next == null){
            System.out.println("当前链表为空，无法进行删除操作");
            return;
        }

        HeroNode tmp = this.head;

        // 是否找到目标删除节点的标志
        boolean flag = false;

        // 1. 定位
        while(tmp.next != null){
            if(tmp.next.no == no){
                flag = true;
                break;
            }
            tmp = tmp.next;
        }

        // 2. 删除
        if(flag)
            tmp.next = tmp.next.next;
        else
            System.out.println("要删除的节点不存在");
    }

4. 习题：

1). 求链表的长度：

    /**
     * 统计链表的长度，不包括链表的头节点 head
     * @param head 需要统计长度的链表的头节点
     * @return 返回链表的长度
     */
    public static int getLength(HeroNode head){
        int length = 0;
        HeroNode tmp = head.next;
        while(tmp != null){
            length++;
            tmp = tmp.next;
        }
        return length;
    }

2). 求倒数第 k 个节点：

法1：

    /**
     * 查找倒数第 index 个节点
     * 思路：
     *      1. 先求出链表的总长度 size
     *      2. 遍历到第 index 个节点，从头开始遍历到第 size-index 个节点返回此节点
     * @param head 查找节点所属链表的头节点
     * @param index 节点的倒数编号
     * @return 返回倒数第 index 个节点
     */
    public static HeroNode findLastIndexNode(HeroNode head, int index){
        // 链表为空
        if(head.next == null){
            return null;
        }

        int size = HeroLinkedList.getLength(head);

        // 查找节点超出范围
        if(index <= 0 || index > size){
            return null;
        }

        HeroNode tmp = head.next;
        for(int i = 0; i < size-index; i++){
            tmp = tmp.next;
        }
        return tmp;
    }

法2：

    /**
     * 查找倒数第 index 个节点，双指针法
     * 思路：
     *      定义两个指针 p 和 q ，初始位置均指向链表的第一个节点;
     *      之后令 p 与 q 相差 index 个节点；
     *      p 与 q 同时后移，当 q 为空时，p 所指向的就为目标节点。
     * @param head 查找的节点所属链表的头节点
     * @param index 所要查找节点的倒数序号
     * @return 返回所要查找的节点
     */
    public static HeroNode findLastIndexNode2(HeroNode head, int index){
        // 链表为空
        if(head.next == null){
            return null;
        }

        int size = HeroLinkedList.getLength(head);

        // 查找节点超出范围
        if(index <= 0 || index > size){
            return null;
        }

        HeroNode p = head.next;
        HeroNode q = p;
        for(int i = 0; i<index; i++){
            q = q.next;
        }

        while(q != null){
            p = p.next;
            q = q.next;
        }

        return p;
    } 

3). 反转链表：

    /**
     * 单链表反转
     * @param head 要反转的链表的头节点
     */
    public static void reverseList(HeroNode head){

        // 如果当前链表为空或只有一个节点，无需反转
        if(head.next == null || getLength(head) == 1){
            return;
        }

        HeroNode newHead = new HeroNode(0, "", "");
        HeroNode current = null;
        while(head.next != null){

            // 1. 将节点从原链表中取出
            current = head.next;
            head.next = current.next;

            // 2. 将取出的节点插入到新的头节点之后
            current.next = newHead.next;
            newHead.next = current;
        }
        head.next = newHead.next;
        
    }

4). 合并两个有序的链表

法1：

    /**
     * 合并链表：合并两个已经有序的链表，并保证合并后链表中的节点是有序的（从小到大）
     * 思路：
     *      两个链表同时从头开始遍历，每遍历一个节点都将两个链表中此时所遍历节点的序号进行比较，
     *      选择其中较小序号的节点，并插入到合并链表中（只有当节点被插入，才会遍历下一个节点）
     * @param head1 要合并的第一个链表的头节点
     * @param head2 要合并的第二个链表的头节点
     * @return 返回合并后新链表的头节点
     */
    public static HeroNode merge(HeroNode head1, HeroNode head2){

        HeroNode mergedHead = new HeroNode();

        // 特殊情况：如果存在合并的链表为空的情况
        if(head1.next == null || head2.next == null){
            mergedHead = head1.next == null ? head2 : head1;
            return mergedHead;
        }

        // 一般情况：
        HeroNode tmp = mergedHead;
        HeroNode tmp1 = head1.next;
        HeroNode tmp2 = head2.next;
        while(tmp1 != null || tmp2 != null){

            if(tmp1 != null && tmp2 != null) {
                if(tmp1.no <= tmp2.no){
                    tmp.next = tmp1;
                    tmp1 = tmp1.next; // 只有当节点被插入到合并后的链表中，才能接着往下遍历比较
                } else{
                    tmp.next = tmp2;
                    tmp2 = tmp2.next;
                }
            } else{
                if(tmp1 == null && tmp2 != null){
                    tmp.next = tmp2;
                    tmp2 = tmp2.next;
                } else if(tmp2 == null && tmp1 != null){
                    tmp.next = tmp1;
                    tmp1 = tmp1.next;
                }
            }
            tmp = tmp.next;
        }

        return mergedHead;
    }

法2：

public static HeroNode merge(HeroNode head1, HeroNode head2){

        // 特殊情况：如果存在合并的链表为空的情况
        if(head1.next == null || head2.next == null)
            return head1.next == null ? head2 : head1;

        // 一般情况：
        HeroNode mergedHead = new HeroNode();
        HeroNode tmp = mergedHead;
        HeroNode tmp1 = head1.next;
        HeroNode tmp2 = head2.next;
        while(tmp1 != null && tmp2 != null){
            if(tmp1.no <= tmp2.no){
                tmp.next = tmp1;
                tmp1 = tmp1.next;
            } else{
                tmp.next = tmp2;
                tmp2 = tmp2.next;
            }
            tmp = tmp.next;
        }
        
        // 当有一个链表为空时，直接将另一个链表的剩余部分接到合并链表的尾部即可
        tmp.next = tmp1 == null ? tmp2 : tmp1;
        
        return mergedHead;
    }