链表

根据尚硅谷的韩顺平老师的数据结构视频总结的笔记

观看视频的网址

 

一、链表的介绍

链表是有序的列表，但是它在内存中是存储如下

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

 

二、单链表

1、单链表介绍

单链表（带头节点）逻辑结构如下图：

2、单链表的应用实例

使用带head头的单向链表实现 –水浒英雄排行榜管理 完成对英雄人物的增删改查操作

1）第一种方法在添加英雄时，直接添加到链表的尾部

2）第二种方式在添加英雄时，根据排名将英雄插入到指定位置 (如果有这个排名，则添加失败，并给出提示)

3）修改节点功能

  1.先通过遍历找到该节点

  2.可以修改除了编号的其他属性

4）删除节点

 

代码实现：

package linkedList;

/**
 * @description: 单链表的实现
 * @auther:田坤
 * @date 2020/10/2 22:27
 **/
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.addByOrder(hero4);
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero2);

        singleLinkedList.list();

        //创建一个需要修改的节点
        HeroNode hero5 = new HeroNode(3,"无用","智慧树");
        singleLinkedList.update(hero5);

        //删除节点
        singleLinkedList.delete(1);
        singleLinkedList.delete(4);

        System.out.println("操作后的链表：");
        singleLinkedList.list();
    }
}

//定义SingleLindedList来管理我们的英雄
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 addByOrder(HeroNode heroNode){
        //因为这个头结点不能动，我们仍需要一个辅助指针来帮助找到添加的位置
        // 单链表，我们所找的temp是位于 添加位置的前一个节点
        HeroNode temp = head;
        boolean flag = false;   //flag标志添加的编号是否存在，默认为false
        while (true){
            if(temp.next == null){
                break;
            }
            if(temp.next.no > heroNode.no){ //找到插入位置
                break;
            }else if(temp.next.no == heroNode.no){  //插入英雄的标号在链表中已存在。
                flag = true;
                break;
            }
            //继续遍历
            temp = temp.next;
        }
        if(flag == true){
            System.out.printf("你所输入的编号为:%d英雄已经在链表中\n",heroNode.no);
        }else {
            heroNode.next = temp.next;
            temp.next  = heroNode;
        }
    }

    //修改节点（根据编号来修改名字和花名）
    public void update(HeroNode updateHeroNode){
        HeroNode temp = head;
        boolean flag = false;   //flag标志需要修改的节点是否找到
        if(temp.next == null){
            System.out.println("链表为空，不能修改!");
            return;
        }
        while (true){
            if(temp == null){
                break;  //已遍历完链表
            }
            if(temp.no == updateHeroNode.no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //找到需要修改的节点
        if(flag == true){
            temp.name = updateHeroNode.name;
            temp.nickname = updateHeroNode.nickname;
        }else {
            System.out.printf("你所要修改编号为:%d的英雄不在链表中\n",updateHeroNode.no);
        }

    }


    //删除节点
    // 仍需要一个temp辅助节点来找到待删除节点的前一个节点，并进行 temo.next.no 和 no 比较
    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;
        }
    }
}


//定义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 +"]";

    }
}

 

 3、单链表的面试题

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

    //求单链表的有效个数
    public int getLength(HeroNode head) {
        if (head.next == null) {  //空链表
            return 0;
        }
        int length = 0;
        HeroNode temp = head.next;  //辅助变量
        while (temp != null) {
            length++;
            temp = temp.next;
        }
        return length;
    }

2）查找单链表中的倒数第k个结点 【新浪面试题】

    //查找单链表中的倒数第k个结点 【新浪面试题】
    //思路:   1、编写一个方法，接收head节点，同时接收index
    //        2、index表示倒数第index个节点
    //        3、先把链表从头到尾遍历，得到链表的总的长度 getLength
    //        4、得到size 从链表的第一个开始遍历到 size - index 个（需要校验index的值
    //        5、如果找到，则返回该节点，否则返回null
    public HeroNode findLastIndexNode(HeroNode head, int index) {
        if (head.next == null) {  //此链表为空链表
            return null;
        }
        int count = 0;  //计算节点个数
        HeroNode temp = head.next;
        //第一次遍历（求出节点个数）
        while (temp != null) {
            count++;
            temp = temp.next;
        }
        //校验用户输入的Index 的值
        if (index >= 0 && index <= count) {
            temp = head.next;
            //第二次遍历，找倒数第k个节点
            for (int i = 0; i < count - index; i++) {
                temp = temp.next;
            }
            return temp;
        }
        return null;
    }

 

3）单链表的反转【腾讯面试题，有点难度】

思路分析图解：

 

    //单链表的反转【腾讯面试题，有点难度】（单链表：头插法）
    public void reverseList(HeroNode head){
        //如果当前链表为空，或者只有一个节点，无需翻转，直接返回
        if(head.next == null || head.next.next == null){
            return;
        }

        HeroNode temp = head.next;  //辅助变量，帮助遍历原来的链表
        HeroNode next = null;       //指向当前节点[temp]的下一个节点
        HeroNode reverseHead = new HeroNode();

        //遍历原来的链表，每遍历一个节点，就将其取出，就放在reserveHead的最前端
        while (temp != null){
            next = temp.next;       //保留当前节点的下一个节点
            temp.next = reverseHead.next;   //将temp的下一个节点指向新的链表的最前端
            reverseHead.next = temp;        //将temp链接在 reverseHead 链表上
            temp = next;    //后移，继续遍历
        }
        head.next = reverseHead.next;
    }

 

4）从尾到头打印单链表 【百度，要求方式1：反向遍历 （不推荐）。 方式2：Stack栈】

思路分析图解：

  

    //从尾到头打印单链表 【百度，要求方式1：反向遍历 （不推荐）。 方式2：Stack栈】
    public void reversePrint(HeroNode head){
        if(head.next == null){  //空链表
            return;
        }
        HeroNode temp = head.next;
        //创建一个栈
        Stack<HeroNode> stack = new Stack<>();
        //将链表中的所以节点压入栈
        while (temp != null){
            stack.push(temp);
            temp = temp.next;
        }
        //出栈
        for (int i = 0; i < stack.size(); i++) {
            System.out.println(stack.pop());    //stack的特点先进入后
        }
    }

 

三、单链表的面试题

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

    //求单链表的有效个数
    public int getLength(HeroNode head) {
        if (head.next == null) {  //空链表
            return 0;
        }
        int length = 0;
        HeroNode temp = head.next;  //辅助变量
        while (temp != null) {
            length++;
            temp = temp.next;
        }
        return length;
    }

2、查找单链表中的倒数第k个结点 【新浪面试题】

    //思路:   1、编写一个方法，接收head节点，同时接收index
    //        2、index表示倒数第index个节点
    //        3、先把链表从头到尾遍历，得到链表的总的长度 getLength
    //        4、得到size 从链表的第一个开始遍历到 size - index 个（需要校验index的值
    //        5、如果找到，则返回该节点，否则返回null
    public HeroNode findLastIndexNode(HeroNode head, int index) {
        if (head.next == null) {  //此链表为空链表
            return null;
        }
        int count = 0;  //计算节点个数
        HeroNode temp = head.next;
        //第一次遍历（求出节点个数）
        while (temp != null) {
            count++;
            temp = temp.next;
        }
        //校验用户输入的Index 的值
        if (index >= 0 && index <= count) {
            temp = head.next;
            //第二次遍历，找倒数第k个节点
            for (int i = 0; i < count - index; i++) {
                temp = temp.next;
            }
            return temp;
        }
        return null;
    }

3、单链表的反转【腾讯面试题，有点难度】（单链表：头插法）

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

        HeroNode temp = head.next;  //辅助变量，帮助遍历原来的链表
        HeroNode next = null;       //指向当前节点[temp]的下一个节点
        HeroNode reverseHead = new HeroNode();

        //遍历原来的链表，每遍历一个节点，就将其取出，就放在reserveHead的最前端
        while (temp != null){
            next = temp.next;       //保留当前节点的下一个节点
            temp.next = reverseHead.next;   //将temp的下一个节点指向新的链表的最前端
            reverseHead.next = temp;        //将temp链接在 reverseHead 链表上
            temp = next;    //后移，继续遍历
        }
        head.next = reverseHead.next;
    }

4、从尾到头打印单链表 【百度，要求方式1：反转后遍历 （不推荐）。 方式2：Stack栈】

    public void reversePrint(HeroNode head){
        if(head.next == null){  //空链表
            return;
        }
        HeroNode temp = head.next;
        //创建一个栈
        Stack<HeroNode> stack = new Stack<>();
        //将链表中的所以节点压入栈
        while (temp != null){
            stack.push(temp);
            temp = temp.next;
        }
        //出栈
        for (int i = 0; i < stack.size(); i++) {
            System.out.println(stack.pop());    //stack的特点先进入后
        }
    }

5、合并两个有序的单链表，合并之后的链表依然有序，如果有重复的节点则不加入

    public HeroNode mergeList(HeroNode head1,HeroNode head2){
        //如果其中一个链表为空，则直接返回另一个链表\
        boolean flag = false;   //设置一个标识符，查看是否有重复的数据
        //如果要合并的俩个链表中有一个为空，则不必排序，直接返回不为空的链表
        if(head1.next == null)
            return head2;
        if(head2.next == null)
            return head1;
        if(head1.next == null && head2.next == null){
            return null;
        }
        HeroNode temp1 = head1;
        HeroNode temp2 = head2.next;
        HeroNode cur = null;
        while (temp2 != null){
            cur = temp2.next;
            flag = false;
            while (true) {
                if (temp1.next == null) {
                    break;
                }
                if (temp1.next.no > temp2.no) { //找到插入位置
                    break;
                }else if(temp1.next.no == temp2.no){
                    System.out.println("编号为"+temp2.no+"重复，将不会加入");
                    flag = true;
                    break;
                }
                //继续遍历
                temp1 = temp1.next;
            }
            //如果不和上一个链表中的元素有重复则加入
            if(flag == false){
                temp2.next = temp1.next;
                temp1.next = temp2;
            }
            temp2 = cur;
        }
        return head1;
    }

 

四、双向链表

使用带head头的双向链表实现 –水浒英雄排行榜

管理单向链表的缺点分析:

（1）单向链表，查找的方向只能是一个方向，而双向链 表可以向前或者向后查找。

（2）单向链表不能自我删除，需要靠辅助节点 ，而双向 链表，则可以自我删除，所以前面我们单链表删除 时节点，总是找到temp,temp是待删除节点的前一 个节点

 

代码实现：

package linkedList;

/**
 * @description: 双向链表的实现
 * @auther:田坤
 * @date 2020/10/6 22:51
 **/
public class DoubleLinkedListDemo {
    public static void main(String[] args) {
        //检测
        //创建节点
        HeroNode2 hero1 = new HeroNode2(1, "宋江", "及时雨");
        HeroNode2 hero2 = new HeroNode2(2, "卢俊义", "玉麒麟");
        HeroNode2 hero3 = new HeroNode2(3, "吴用", "智多星");
        HeroNode2 hero4 = new HeroNode2(4, "公孙胜", "入云龙");

        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.add(hero1);
        doubleLinkedList.add(hero2);
        doubleLinkedList.add(hero3);
        doubleLinkedList.add(hero4);

        doubleLinkedList.list();

        doubleLinkedList.update(new HeroNode2(2, "小卢", "玉麒麟"));
        System.out.println("修改后的链表");
        doubleLinkedList.list();

        doubleLinkedList.delete(new HeroNode2(2, "小卢", "玉麒麟"));
        System.out.println("删除后的链表");
        doubleLinkedList.list();

        //按编号顺序添加节点
        DoubleLinkedList doubleLinkedList1 = new DoubleLinkedList();
        doubleLinkedList1.addByOrder(hero3);
        doubleLinkedList1.addByOrder(hero1);
        doubleLinkedList1.addByOrder(hero4);
        doubleLinkedList1.addByOrder(hero2);
        System.out.println("按照编号顺序添加节点：");
        doubleLinkedList1.list();
    }
}

//定义一个DoubleLinkedList类来管理HeroNode2
class DoubleLinkedList{

    //创建一个头结点
    private HeroNode2 head = new HeroNode2();

    public HeroNode2 getHead() {
        return head;
    }

    //显示双向链表链表
    public void list(){
        HeroNode2 temp = head.next;
        if(head.next == null){
            System.out.println("链表为空！");
            return;
        }
//        while (temp.next != null){
//            System.out.println(temp);
//            temp = temp.next;
//        }
        while (true){
            if(temp == null)
                break;
            System.out.println(temp);
            temp = temp.next;
        }
    }

    //添加一个节点到双向链表的尾部
    public void add(HeroNode2 heroNode2){
        HeroNode2 temp = head;
//        while (temp != null){
//            temp = temp.next;
//        }
        while (true){
            if(temp.next == null)
                break;
            temp = temp.next;
        }
        temp.next = heroNode2;
        heroNode2.pre = temp;
    }

    //按照编号的顺序添加节点
    public void addByOrder(HeroNode2 heroNode2){
        HeroNode2 temp = head;
        while (true){
            if(temp.next == null){
                break;
            }
            if(temp.next.no > heroNode2.no){
                break;
            }
            temp = temp.next;
        }
        heroNode2.next = temp.next;
        temp.next = heroNode2;
    }

    //修改一个节点的内容
    public void update(HeroNode2 heroNode2){
        boolean flag = false;   //标识是否找到要修改的节点
        HeroNode2 temp = head.next;
        if(head.next == null){
            System.out.println("链表为空！");
            return;
        }
        while (true){
            if(temp == null){   //链表遍历完
                break;
            }
            if(temp.no == heroNode2.no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //如果找到需要修改的节点
        if(flag == true){
            temp.name = heroNode2.name;
            temp.nickname = heroNode2.nickname;
        }else {
            System.out.println("你所需要修改的编号为"+heroNode2.no+"的节点不存在，不能修改！");
        }
    }

    //从双向链表上删除一个节点
    public void delete(HeroNode2 heroNode2){
        HeroNode2 temp = head.next;
        boolean flag = false;
        if(head.next == null){
            System.out.println("链表为空，不能删除！");
            return;
        }
        while (true){
            if(temp == null){   //链表遍历完
                break;
            }
            if(temp.no == heroNode2.no){
                flag  = true;
                break;
            }
            temp = temp.next;
        }
        if(flag == true){
            temp.pre.next = temp.next;
            //要考虑最后一个节点的空指针异常
            if(temp.next != null) {
                temp.next.pre = temp.pre;
            }
        }else {
            System.out.println("没有找到编号为"+heroNode2.no+"的节点，无法删除！");
        }

    }

}



//定义HeroNode2,每个HeroNode2 对象就是一个节点
class HeroNode2 {
    public int no;          //编号
    public String name;     //名字
    public String nickname; //别名，花名
    public HeroNode2 next;   //指向下一个节点
    public HeroNode2 pre;   //指向上一个节点

    //构造器
    public HeroNode2(){

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

    }
}

 

五、单向环形链表   and   Josephu（约瑟夫，约瑟夫环）问题

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

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

约瑟夫问题示意图：

 

1、创建一个环形列表

 

小孩出圈的思路分析图

 

约瑟夫问题的代码实现

package linkedList;

/**
 * @description:   约瑟夫问题的代码实现
 * @auther:田坤
 * @date 2020/10/7 8:50
 **/
public class Josephu {
    public static void main(String[] args) {
        //测试
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(5);
        circleSingleLinkedList.list();

        //顺序出圈
        circleSingleLinkedList.countBoy(1,2,5); // 2->4->1->5->3
    }

}

//创建一个环形单链表
class CircleSingleLinkedList {
    //创建第一个节点
    private Boy frist = null;

    //创建一个环形单链表，nums为环形链表的节点数
    public void addBoy(int nums) {
        Boy cur = null;
        Boy boyNode = null;
        if (nums < 1) {
            System.out.println("加入环形单链表的个数不能小于1");
            return;
        }
        for (int i = 1; i <= nums; i++) {
            boyNode = new Boy(i);
            if (i == 1) {
                frist = boyNode;
                boyNode.setNext(frist);
                cur = frist;
            } else {
                cur.setNext(boyNode);
                boyNode.setNext(frist);
                cur = boyNode;
            }
        }
    }

    //遍历打印
    public void list() {
        Boy cur = frist;
        if (frist == null) {
            System.out.println("链表为空，无法遍历！");
        }
        while (true) {
            System.out.println("小孩的编号为：" + cur.getNo());
            if (cur.getNext() == frist)
                break;
            cur = cur.getNext();
        }
    }

    /**
     *  根据用户的输入，计算小孩出圈的顺序
     *  startNo     表示从几个小孩开始数数
     *  countNum    表示数几下
     *  nums        最初由多少小孩在圈中
     *
     */
    public void countBoy(int startNo,int countNum,int nums){
        if(frist == null){
            System.out.println("链表为空！");
            return;
        }
        //对用户输入的数据进行校验
        if(startNo <1 || startNo > nums){
            System.out.println("参数输入有误！");
            return;
        }
        //设置一个辅助指针变量，使得其指向这个环形链表的最后的节点
        Boy helper = frist;

        while (true){
            if(helper.getNext() == frist)
                break;
            helper = helper.getNext();
        }

        //设置开始数数的位置， 先让frist 和 helper移动 startNo -1 次
        for (int i = 0; i < startNo-1 ; i++) {
            helper = frist;
            frist = frist.getNext();
        }


        //循环出圈
        while(true){
            if(helper == frist){    //说明圈中只有一个小孩
                break;
            }
            for (int i = 0; i < countNum-1 ; i++) {
                helper = frist;
                frist = frist.getNext();
            }
            System.out.println("编号为"+frist.getNo()+"的小孩出圈");
            //将小孩出圈
            frist = frist.getNext();
            helper.setNext(frist);
        }
        //使最后一个小孩出圈
        System.out.println("编号为"+frist.getNo()+"的小孩出圈");
        frist = null;
    }


}


//创建一个小孩类
class Boy {
    private int no; //编号
    private Boy next;

    //构造器
    public Boy() {

    }

    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;
    }
}