第 4 章链表

参考：https://blog.csdn.net/oneby1314/category_10231585.html

1、链表(Linked List)介绍

1.1、内存结构

内存上来看：链表存储空间不连续（不像数组）

在这里插入图片描述

1.2、逻辑结构

逻辑上来看：链表属于线性结构

在这里插入图片描述

1.3、链表特点

链表以节点的方式来存储，是链式存储
data域存放数据，next域指向下一个节点
如内存结构图所示，链表的各个节点不一定是连续存储
链表分==带头节点==和**没有头结点**的链表

2、链表应用场景

2.1、水浒英雄榜

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

2.2、链表节点定义

no ：英雄编号
name ：英雄名字
nickName ：英雄昵称
next ：指向下一个 HeroNode 节点

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

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

2.3、链表定义

//定义SingleLinkedList 管理我们的英雄
class SingleLinkedList {
    
    
	// 先初始化一个头节点, 头节点不要动, 不存放具体的数据
	private HeroNode head = new HeroNode(0, "", "");

	// 返回头节点
	public HeroNode getHead() {
    
    
		return head;
	}
    
    // ....

2.4、遍历链表

2.4.1、实现思路

定义辅助变量temp，相当于一个指针，指向当前节点
何时完成？temp==null 表明当前节点为null，即表示已到链表末尾
如何遍历？temp=temp.next , 每次输出当前节点信息之后，temp指针后移

2.4.2、代码实现

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

2.5、尾部插入

2.5.1、代码思路

定义辅助变量temp，相当于一个指针，指向当前节点
如何在链表末尾插入节点？
- 首先需要遍历链表，找到链表最后一个节点，当temp.next == null时，temp节点指向链表最后一个节点
- 然后在temp节点之后插入节点即可：temp.next = heroNode

在这里插入图片描述

2.5.2、代码实现

在链表尾部插入节点

/*
   * 添加节点到单向链表
   * 思路：当不考虑编号顺序时
   * 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 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, "林冲", "豹子头");

        // 创建一个链表
        SingleLinkList singleLinkList = new SingleLinkList();
        singleLinkList.add(hero1);
        singleLinkList.add(hero2);
        singleLinkList.add(hero3);
        singleLinkList.add(hero4);
        // 显示
        singleLinkList.list();
    }

程序运行结果

HeroNode [no=1, name=宋江, nickName=及时雨]
HeroNode [no=2, name=卢俊义, nickName=玉麒麟]
HeroNode [no=3, name=吴用, nickName=智多星]
HeroNode [no=4, name=林冲, nickName=豹子头]

2.6、按顺序插入

2.6.1、实现思路

定义辅助变量temp,相当于一个指针，指向当前节点
如何执行插入？（待插入的节点为heroNode）
- 首先需要遍历链表，找到链表中编号比heroNode.no大的节点，暂且叫它biggerNode,然后把heroNode插入到biggerNode之前
- 怎么找到biggerNode?当 temp.next.no > heroNode.no 时，这时temp.next节点就是biggerNode节点。
- 为什么是temp.next节点？只有找到temp节点和temp.next（binggerNode）节点，才能在temp节点和temp.next节点之间插入heroNode节点
- 怎么插入？
  - heroNode .next = temp.next;
  - temp.next = heroNode;

在这里插入图片描述

2.6.2、代码实现

按照英雄排名的顺序进行插入

    /*
    * 第二种添加英雄的方式，根据排名将英雄插入到指定位置
    * （如果有这个排名，则添加失败，并给出提示）
    * */
    public void addByOrder(HeroNode heroNode) {
    
    
        // 因为头结点不能动，因此我们仍然通过一个辅助指针（变量）来帮助找到添加的位置
        // 我们找的temp是位于添加位置的前一个节点，否则插入不了
        HeroNode temp = head;
        boolean flag = false; // flag标志添加的编号是否存在，默认为false
        while (true) {
    
    
            if (temp.next == null) {
    
     // 说明temp已经在链表的最后
                break;
            }
            if (temp.next.no > heroNode.no) {
    
     // 位置找到，就在temp的后面插入
                break;
            }else if (temp.next.no == heroNode.no) {
    
     // 说明希望添加的heroNode的编号已然存在
                flag = true;
                break;
            }
            temp = temp.next; // 后移，遍历当前链表
        }
        // 判断falg的值
        if (flag) {
    
     // 不能添加，说明编号存在
            System.out.printf("序号 %d 已经存在了，不能重复添加！",heroNode.no);
            System.out.println();
        }else {
    
    
            // 插入链表中，temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

测试代码

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.addByOrder(hero1);
    singleLinkedList.addByOrder(hero4);
    singleLinkedList.addByOrder(hero2);
    singleLinkedList.addByOrder(hero3);

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

程序运行结果

HeroNode [no=1, name=宋江, nickName=及时雨]
HeroNode [no=2, name=卢俊义, nickName=玉麒麟]
HeroNode [no=3, name=吴用, nickName=智多星]
HeroNode [no=4, name=林冲, nickName=豹子头]

2.7、修改节点信息

2.7.1、代码思路

定义辅助变量temp，相当于一个指针，指向当前节点
如何找到找到指定节点？temp.no = newHeroNode.no

2.7.2、代码实现

修改指定节点信息

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

2.8、删除节点

2.8.1、代码思路

定义辅助变量temp，相当于一个指针，指向当前节点
如何找到待删除的节点？遍历链表，当temp.next == no时，temp.next节点就是待删除的节点
如何删除？要找到待删除节点的前一个节点（temp）, temp = temp.next.next即可删除temp.next节点，该节点没有引用指向它，会被垃圾回收机制回收

在这里插入图片描述

2.8.2、代码实现

删除指定节点

  /*
    * 删除节点
    * 思路
    * 1. head不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
    * 2. 说明我们在比较时，是temp.next.no 和 需要删除的节点的no比较
    * */
    public void del(int no) {
    
    
        HeroNode temp = head;
        boolean flag = false; // 标志是否需要待删除节点的
        while (true) {
    
    
            if (head.next == null) {
    
     // 已经到链表的最后
                break;
            }
            if (temp.next.no == no) {
    
    
                // 找到待删除节点的前一个节点temp
                flag = true;
                break;
            }
            temp = temp.next; // temp后移，遍历
        }
        // 判断flag
        if (flag) {
    
    
            // 找到并删除
            temp.next = temp.next.next;
        }else {
    
    
            System.out.printf("没有找到编号为 %d 的英雄",no);
        }
    }

测试代码

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.del(1);
    singleLinkedList.del(4);

    singleLinkedList.list();
}

程序运行结果

HeroNode [no=2, name=卢俊义, nickName=玉麒麟]
HeroNode [no=3, name=吴用, nickName=智多星]

2.9、总结

遍历链表，执行操作时，判断条件有时候是 temp ，有时候是 temp.next ，Why？
- 对于插入、删除节点来说，需要知道当前待操作的节点（heroNode）前一个节点的地址（指针），如果直接定位至当前待操作的节点 heroNode ，那没得玩。。。因为不知道heroNode 前一个节点的地址，无法进行插入、删除操作，所以 while 循环中的条件使用 temp.next 进行判断
- 对于更新、遍历操作来说，我需要的仅仅就只是当前节点的信息，所以 while 循环中的条件使用 temp进行判断
头结点与首节点
- 头结点是为了操作的统一与方便而设立的，放在第一个元素结点之前，其数据域一般无意义（当然有些情况下也可存放链表的长度、用做监视哨等等）
- 首元结点也就是第一个元素的结点，它是头结点后边的第一个结点。

3、单链表面试题

3.1 求单链表中有效节点的个数

思路：遍历即可

    /*
    * @param head 链表的头节点
    * @return 返回的就是有效节点的个数
    * */
    public static int getLengeth(HeroNode head) {
    
    
        if (head.next == null) {
    
     // 空链表
            return 0;
        }
        int length = 0;
        // 定义一个辅助变量，这里没有统计头节点
        HeroNode cur = head.next;
        while (cur != null) {
    
    
            length ++;
            cur = cur.next;
        }
        return length;
    }

3.2 查找单链表中倒数第k个节点

思路
- 先把链表从头到尾遍历，得到链表总长度size
- 得到size之后，我们从链表的第一个开始遍历(size - index)个，就可以得到
- 如果找到了则返回该节点，否则返回null

代码

// 查找单链表中的倒数第k个结点 【新浪面试题】
// 思路
// 1. 编写一个方法，接收head节点，同时接收一个index
// 2. index 表示是倒数第index个节点
// 3. 先把链表从头到尾遍历，得到链表的总的长度 getLength
// 4. 得到size 后，我们从链表的第一个开始遍历 (size-index)个，就可以得到
// 5. 如果找到了，则返回该节点，否则返回nulll
public static HeroNode findLastIndexNode(HeroNode head, int index) {
      
      
    // 判断如果链表为空，返回null
    if (head.next == null) {
      
      
        return null;// 没有找到
    }
    // 第一个遍历得到链表的长度(节点个数)
    int size = getLength(head);
    // 第二次遍历 size-index 位置，就是我们倒数的第K个节点
    // 先做一个index的校验
    if (index <= 0 || index > size) {
      
      
        return null;
    }
    // 定义给辅助变量， for 循环定位到倒数的index
    HeroNode cur = head.next; // 3 // 3 - 1 = 2
    for (int i = 0; i < size - index; i++) {
      
      
        cur = cur.next;
    }
    return cur;
}

3.3 单链表的反转

法1：插头法

思路：新建一个头结点，遍历原链表，把每个节点用头结点插入到新建链表中。最后，新建的链表就是反转后的链表。
过程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Rr6GfZ5b-1604986991672)(图片/第 4 章链表/image-20201103091912921.png)]

伪代码

1 pNex = pCur.next
2 pCur.next = dummy.next
3 dummy.next = pCur
4 pCur = pNex

代码

// 将单链表反转
public static void reversetList(HeroNode head) {
      
      
    // 如果当前链表为空，或者只有一个节点，无需反转，直接返回
    if (head.next == null || head.next.next == null) {
      
      
        return;
    }

    // 定义一个辅助的指针(变量)，帮助我们遍历原来的链表
    HeroNode cur = head.next;
    HeroNode next = null;// 指向当前节点[cur]的下一个节点
    HeroNode reverseHead = new HeroNode(0, "", "");
    // 遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead 的最前端
    // 动脑筋
    while (cur != null) {
      
      
        next = cur.next;// 先暂时保存当前节点的下一个节点，因为后面需要使用
        cur.next = reverseHead.next;// 将cur的下一个节点指向新的链表的最前端
        reverseHead.next = cur; // 将cur 连接到新的链表上
        cur = next;// 让cur后移
    }
    // 将head.next 指向 reverseHead.next , 实现单链表的反转
    head.next = reverseHead.next;
}

3.4 从尾到头打印单链表

代码思路
1. 方式1 ：先将单链表进行反转操作，然后再遍历输出，问题：破坏原链表结构，不可取
2. 方式2 ：遍历链表，去除节点压入栈中，利用栈先进后出的特点，实现逆序打印

代码

    // 方式2：
// 可以利用栈这个数据结构，将各个节点压入到栈中，然后利用栈的先进后出的特点，就实现了逆序打印的效果
    public static void reversePrint(HeroNode head) {
      
      
        if (head.next == null) {
      
      
            return;// 空链表，不能打印
        }
        // 创建要给一个栈，将各个节点压入栈
        Stack<HeroNode> stack = new Stack<HeroNode>();
        HeroNode cur = head.next;
        // 将链表的所有节点压入栈
        while (cur != null) {
      
      
            stack.push(cur);
            cur = cur.next; // cur后移，这样就可以压入下一个节点
        }
        // 将栈中的节点进行打印,pop 出栈
        while (stack.size() > 0) {
      
      
            System.out.println(stack.pop()); // stack的特点是先进后出
        }
    }

4、双向链表

4.1 与单向链表的比较

单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找
单链表不能自我删除，需要靠辅助节点，而双向链表，可以自我删除，所以前面我们单链表删除节点时，总是要找到temp，temp是待删除节点的前一个节点

在这里插入图片描述

4.2 双向链表节点定义

在单向链表节点的基础上，增加pre，用于指向前一个节点

// 定义HeroNode ， 每个HeroNode 对象就是一个节点
class HeroNode {
      
      
	public int no;
	public String name;
	public String nickname;
	public HeroNode next; // 指向下一个节点, 默认为null
	public HeroNode pre; // 指向前一个节点, 默认为null
	// 构造器

	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 + "]";
	}
}

4.3 链表定义

定义整个链表的头结点，作为链表的入口

// 创建一个双向链表的类
class DoubleLinkedList {
      
      

	// 先初始化一个头节点, 头节点不要动, 不存放具体的数据
	private HeroNode head = new HeroNode(0, "", "");

	// 返回头节点
	public HeroNode getHead() {
      
      
		return head;
	}
    
    // ...

4.4 链表遍历

代码思路

定义辅助变量 temp ，相当于一个指针，指向当前节点 ，用于遍历链表
何时停止 while 循环？temp == null ：已经遍历至链表尾部

代码实现

// 遍历双向链表的方法
// 显示链表[遍历]
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;
    }
}

4.5 尾部插入

代码思路

定义辅助变量 temp ，相当于一个指针，指向当前节点
何时停止 while 循环？temp.next == null ：temp 节点已经是链表最后一个节点，在 temp 节点之后插入 heroNode 节点即可
如何插入？
- temp.next 指向新的尾节点 heroNode ：temp.next = heroNode;
- heroNode .pre 指向旧的尾节点 temp ：heroNode.pre = temp;

代码实现

// 添加一个节点到双向链表的最后.
public void add(HeroNode heroNode) {
    
    

    // 因为head节点不能动，因此我们需要一个辅助遍历 temp
    HeroNode temp = head;
    // 遍历链表，找到最后
    while (true) {
    
    
        // 找到链表的最后
        if (temp.next == null) {
    
    //
            break;
        }
        // 如果没有找到最后, 将将temp后移
        temp = temp.next;
    }
    // 当退出while循环时，temp就指向了链表的最后
    // 形成一个双向链表
    temp.next = heroNode;
    heroNode.pre = temp;
}

4.6 按顺序插入

4.6.1 代码思路

定义辅助变量temp , 相当于一个指针，指向当前节点
我们将heroNode节点插入到temp节点之后，还是之前？

如果插入到temp节点之后：
- 判断条件：temp.next.no > heroNode.no ，即temp的下一个节点的值比heroNode节点的值大，所以需要将heroNode插入到temp节点之后
- while循环终止条件
  - temp.next == null ：temp 节点已经是链表的尾节点
  - temp.next.no > heroNode.no ：heroNode 节点的值介于 temp 节点的值和 temp 下一个节点的值之间
  - temp.next.no == heroNode.no ：heroNode 节点的值等于 temp 下一个节点的值，不能进行插入

在这里插入图片描述

如果插入到temp节点之前：

判断条件：temp.no > heroNode.no ，即 temp 节点的值比 heroNode 节点的值大，所以需要将 heroNode 插入到 temp 节点之前
存在的问题：如果需要在链表尾部插入 heroNode 节点，即需要在 null 节点之前插入 heroNode 节点，定位至 null 节点将丢失其前一个节点的信息（除非使用一个变量保存起来），所以跳出循环的判断条件为：temp.next == null
所以我们选取：【插入到 temp 节点之后】方案

4.6.2 代码实现

// 第二种方式在添加英雄时，根据排名将英雄插入到指定位置
// (如果有这个排名，则添加失败，并给出提示)
public void addByOrder(HeroNode heroNode) {
    
    
    // 因为头节点不能动，因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
    // 目标：在 temp 的后面插入节点
    HeroNode temp = head;
    boolean flag = false; // flag标志添加的编号是否存在，默认为false
    while (true) {
    
    
        if (temp.next == null) {
    
    // 说明temp已经在链表的最后
            break;
        }
        if (temp.next.no > heroNode.no) {
    
     // 位置找到，就在temp的后面插入
            break;
        } else if (temp.next.no == heroNode.no) {
    
    // 说明希望添加的heroNode的编号已然存在
            flag = true; // 说明编号存在
            break;
        }
        temp = temp.next; // 后移，遍历当前链表
    }
    // 判断flag 的值
    if (flag) {
    
     // 不能添加，说明编号存在
        System.out.printf("准备插入的英雄的编号 %d 已经存在了, 不能加入\n", heroNode.no);
    } else {
    
    
        // 插入到链表中, temp的后面

        // heroNode 指向 temp 节点的下一个节点
        heroNode.next = temp.next;
        if(temp.next != null) {
    
    
            temp.next.pre = heroNode;
        }

        // temp 节点指向 heroNode 节点
        temp.next = heroNode;
        heroNode.pre = temp;
    }
}

4.7、修改节点信息

代码思路

定义辅助变量 temp ，相当于一个指针，指向当前节点
如何找到指定节点？temp.no == no

代码实现

    // 修改一个节点的内容
    // 可以看到双向链表的节点内容的修改和单向链表一样，只是节点类型的修改
    public void update(HeroNode2 newHeroNode) {
    
    
        // 先判断列表是否为空
        if (head.next == null) {
    
    
            System.out.println("链表为空！");
        }
        // 找到需要修改的节点，根据no编号
        // 定义一个辅助变量
        HeroNode2 temp = head.next;
        boolean flag = false; // 表示是否找到该节点
        while (true) {
    
    
            if (temp == null) {
    
    
                break; // 已经遍历完链表
            }
            if (temp.no == newHeroNode.no) {
    
    
                flag = true;
                break;
            }
            temp = temp.next;
        }
        // 根据flag判断是否找到要修改的节点
        if (flag) {
    
    
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        } else {
    
    
            // 没有找到
            System.out.printf("没有找到编号 %d 的节点，不能修改\n", newHeroNode.no);
        }
    }

4.8、删除节点

    // 删除节点
    /*
    * 说明：
    * 1. 对于双向链表，我们可以直接找到要删除的这个节点
    * 2. 找到后，自我删除即可
    * */
    public void del(int no) {
    
    
        // 判断当前链表是否为空
        if (head.next == null) {
    
    
            System.out.println("链表为空，无法删除！");
            return;
        }
        HeroNode2 temp = head.next; // 辅助变量(指针)
        boolean flag = false; // 标志是否找到待删除节点的
        while (true) {
    
    
            if (temp == null) {
    
     // 已经到链表的最后
                break;
            }
            if (temp.no == no) {
    
    
                flag = true;
                break;
            }
            temp = temp.next; // temp 后移，遍历
        }
        // 判断flag
        if (flag) {
    
    
            // 找到并删除
            temp.pre.next = temp.next;
            // 这里我们的代码有问题？
            // 如果是最后一个节点，就不需要执行下面这句话，否则出现空指针异常
            if (temp.next != null) {
    
    
                temp.next.pre = temp.pre;
            }
        }else {
    
    
            System.out.printf("没有找到编号为 %d 的英雄",no);
        }
    }

    // 根据顺序插入
    public void addByOrder_first_error_Version(HeroNode2 newHeroNode) {
    
    
        HeroNode2 temp = head.next;
        boolean flag = false;
        while (true) {
    
    
            if (temp == null) {
    
    
                break;
            }
            if (temp.no > newHeroNode.no) {
    
    
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
    
    
            temp.pre.next = newHeroNode;
            newHeroNode.next = temp.next;
        }
    }

5、单向环形链表

5.1 单向环形链表应用场景

Josephu 问题为：设编号为 1， 2， … n 的 n 个人围坐一圈，约定编号为 k（1<=k<=n）的人从 1 开始报数，数到 m 的那个人出列，它的下一位又从 1 开始报数，数到 m 的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。

在这里插入图片描述

5.2 单向环形链表图解

在这里插入图片描述

5.3 Josephu 问题

用一个不带头结点的循环链表来处理 Josephu 问题：先构成一个有 n 个结点的单循环链表，然后由 k 结点起从 1 开始计数，计到 m 时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从 1 开始计数，直到最后一个结点从链表中删除算法结束。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mBroFQRp-1604986991677)(图片/第 4 章链表/image-20201103165637807.png)]

5.4 环形链表的构建与遍历

5.4.1 Boy 节点的定义

Boy 节点就是个普普通通的单向链表节点

// 创建一个Boy类，表示一个节点
class Boy {
    
    
	private int no;// 编号
	private Boy next; // 指向下一个节点,默认null

	public Boy(int no) {
    
    
		this.no = no;
	}

	public int getNo() {
    
    
		return no;
	}

	public void setNo(int no) {
    
    
		this.no = no;
	}

	public Boy getNext() {
    
    
		return next;
	}

	public void setNext(Boy next) {
    
    
		this.next = next;
	}
}

5.4.2 单向循环链表的定义

first 节点为单向循环链表的首节点，是真实存放数据的节点，不是头结点

// 创建一个环形的单向链表
class CircleSingleLinkedList {
      
      
	// 创建一个first节点,当前没有编号
	private Boy first = null;
    
    // ...

5.4.3 构建单向循环链表

1 代码思路

长度为 1 的情况：
- 新创建的 boy 节点即是首节点：first = boy;
- 自封闭（自己构成环形链表）：first.setNext(first);
- 此时 first 节点既是首节点，也是尾节点，辅助指针也指向 first ：curBoy = first;
长度不为 1 的情况：
- 将 boy 节点添加至环形链表的最后：curBoy.setNext(boy); ，curBoy 节点永远是环形链表的尾节点
- 构成环形链表：boy.setNext(first);
- 辅助指针后移，指向环形链表的尾节点：curBoy = boy;

在这里插入图片描述

2 代码实现

// 添加小孩节点，构建成一个环形链表
    public void addBoy(int nums) {
    
    
        // nums 做一个数据实现
        if (nums < 1) {
    
    
            System.out.println("nums 的值不正确");
            return;
        }
        Boy curBoy = null; // 辅助指针，帮助构建形成环形链表
        for (int i = 1; i < nums; i++) {
    
    
            // 根据编号，创建小孩节点
            Boy boy = new Boy(i);
            // 如果是第一个小孩
            if (i == 1) {
    
    
                first = boy;
                first.setNext(first); // 构成环
                curBoy = first; // 让curBoy指向第一个小孩
            }else {
    
    
                curBoy.setNext(boy);
                boy.setNext(first);
                curBoy = boy;
            }
        }
    }

5.4.4 遍历单向循环链表

1 代码思路

定义辅助变量curBoy，相当于一只指针，指向当前节点
何时退出while循环？当curBoy已经指向环形链表的尾节点：curBoy.getNext（）== first

2 代码实现

    // 遍历当前循环链表
    public void showBoy() {
    
    
        if (first == null) {
    
    
            System.out.println("链表为空，不能打印！");
        }
        // 辅助变量
        Boy curBoy = first;
        while (true) {
    
    
            System.out.printf("小孩的编号为 ： %d ", curBoy.getNo());
            System.out.println();
            if (curBoy.getNext() == first) {
    
    
                System.out.println("打印完毕！");
                break;
            }
            curBoy = curBoy.getNext(); // curBoy后移
        }
    }

5.5 解决 Josephu 问题

5.5.1 代码思路

辅助变量helper：helper永远指向环形链表的尾结点，环形链表的尾结点永远都指向首节点，可得出：helper.getNext( )==first

在这里插入图片描述

如何将helper定位至环形链表的尾节点？
- 初始化时，让 helper = first ,此时helper指向环形链表的首节点
- 遍历该环形链表，当 helper.next == first : 此时helper已经指向链表的尾节点，达到目的
如何定位至第 startNo 个节点？如果想要定位至第 2 个节点，那么则需要让 first 和 helper 都移动 1 步，所以让 first 和 helper 都移动 (startNo - 1)步即可
如何数 nums 下？让 first 和 helper 都移动 (nums - 1)步即可
如何实现出圈？
- 我们需要将first指向的节点出圈，first前一个节点的地址在helper中存着（环形链表）
- 先让first后移一步：first = first.getNext()
- 出圈：helper.setNext(first)，原来的first节点由于没有任何引用，便会被垃圾回收机制回收
while循环终止条件？圈中只剩一人：helper == first

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UxVZbnMg-1604986991679)(图片/第 4 章链表/image-20201103222305440.png)]

5.5.2 代码实现

    // 根据用户的输入，计算小孩出圈的顺序
    /**
     * @param startNo  表示从第几个小孩开始数数
     * @param countNum 表示数几下
     * @param nums     表示最初有多少小孩在圈中
     */
    public void countBoy(int startNo, int countNum, int nums) {
    
    
        // 先对数据进行校验
        if (first == null || startNo < 1 || startNo > nums) {
    
    
            System.out.println("参数输入有误，请重新输入！");
            return;
        }
        // 创建一个辅助指针，帮助完成小孩出圈
        Boy helper = first;
        // 让helper指向最后小孩节点
        while (true) {
    
    
            if (helper.getNext() == first) {
    
     // 说明helper指向最后小孩节点
                break;
            }
            helper = helper.getNext();
        }
        // 小孩报数前，先让 first 和 helper 移动 startNo-1 次
        for (int j = 0; j < startNo - 1; j ++) {
    
    
            first = first.getNext();
            helper = helper.getNext();
        }
        // 当小孩报数时，让first 和 helper指针同时移动 m-1 次,然后出圈
        // 这里是一个循环操作，直到圈中只有一个节点
        while (true) {
    
    
            if (helper == first) {
    
     // 圈中只有一个人
                break;
            }
            // 让first 和 helper指针同时移动 m-1 次
            for(int j = 0; j < countNum - 1; j ++) {
    
    
                first = first.getNext();
                helper = helper.getNext();
            }
            // 这时first指向的就是要出圈的小孩
            System.out.printf("%d 号小孩出列",first.getNo());
            System.out.println();
            first = first.getNext();
            helper.setNext(first);
        }
        System.out.printf("最后留在圈中的小孩的编号是 : %d", first.getNo());
    }

【尚硅谷数据结构】第4章 链表

第 4 章 链表

1、链表(Linked List)介绍

1.1、内存结构

1.2、逻辑结构

1.3、链表特点

2、链表应用场景

2.1、水浒英雄榜

2.2、链表节点定义

2.3、链表定义

2.4、遍历链表

2.4.1、实现思路

2.5、尾部插入

2.5.1、代码思路

2.5.2、代码实现

2.6、按顺序插入

2.6.1、实现思路

2.6.2、代码实现

2.7、修改节点信息

2.7.1、代码思路

2.7.2、代码实现

2.8、删除节点

2.8.1、代码思路

2.8.2、代码实现

2.9、总结

3、单链表面试题

3.1 求单链表中有效节点的个数

3.2 查找单链表中倒数第k个节点

3.3 单链表的反转

3.4 从尾到头打印单链表

4、双向链表

4.1 与单向链表的比较

4.2 双向链表节点定义

4.3 链表定义

4.4 链表遍历

4.5 尾部插入

4.6 按顺序插入

4.6.1 代码思路

4.6.2 代码实现

4.7、修改节点信息

4.8、删除节点

5、单向环形链表

5.1 单向环形链表应用场景

5.2 单向环形链表图解

5.3 Josephu 问题

5.4 环形链表的构建与遍历

5.4.1 Boy 节点的定义

5.4.2 单向循环链表的定义

5.4.3 构建单向循环链表

1 代码思路

2 代码实现

5.4.4 遍历单向循环链表

1 代码思路

5.5 解决 Josephu 问题

5.5.1 代码思路

5.5.2 代码实现

猜你喜欢

【尚硅谷数据结构】第4章链表

第 4 章链表