数据结构与算法——链表（LinkedList）

最新推荐文章于 2024-04-22 10:55:12 发布

三月江东

最新推荐文章于 2024-04-22 10:55:12 发布

阅读量191

点赞数 1

分类专栏：数据结构与算法文章标签：链表数据结构 java

本文链接：https://blog.csdn.net/crisp077/article/details/125254204

版权

数据结构与算法专栏收录该内容

22 篇文章 2 订阅

订阅专栏

链表( Linked List )

1 单链表

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

1.1 添加节点

第一种方式：在添加英雄时直接添加到链表的尾部
1. 先创建一个head头节点，作用解释表示单链表的头
2. 后面我们每添加一个节点，就直接加入到链表的最后
3. 通过一个辅助变量，遍历整个链表
第二种方式：在添加英雄时，根据排名将英雄插入到指定位置
1. 首先找到新添加的节点的位置，是通过辅助变量(指针)
2. 新的节点.next = temp.next
3. 将temp.next = 新的节点

1.2 修改节点

先找到该节点，通过遍历
然后依次将新节点的内容替换到辅助节点上

1.3 删除节点

我们先找到需要删除的这个节点的前一个节点temp
temp.next = temp.next.next
被删除的节点，将不会有其他引用指向，会被垃圾回收机制回收

1.4 示例代码

package com.crisp.LinkedList;

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);
        System.out.println();*/
        //排序后输出
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero2);
        //singleLinkedList.addByOrder(hero3);//测试重复添加英雄
        //显示
        singleLinkedList.list();
        System.out.println();
        //测试修改节点的代码
        System.out.println("更改3号节点：");
        HeroNode hero5 = new HeroNode(3,"吴用","智多星");
        singleLinkedList.update(hero5);
        singleLinkedList.list();
        System.out.println();
        //测试删除一个节点
        System.out.println("删除1号节点");
        singleLinkedList.delete(1);
        singleLinkedList.list();
    }
}

//定义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 addByOrder(HeroNode heroNode) {
        //因为头节点不能动，因此通过辅助指针来找添加的位置
        //因为是单链表，因此temp 是位于添加位置的前一个节点，否则插入不了
        HeroNode temp = head;
        boolean flag = false;//标志添加的编号是否存在，默认为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{
            //插入到链表中
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    //修改节点的信息，根据no 编号来修改，即no编号不能改
    //说明：
    //1、根据newHeroNode的no来编写
    public void update(HeroNode newHeroNode){
        //判断是否空
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点，根据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);
        }
    }
    //删除节点
    //思路：
    //1、head 不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
    //2、说明我们在比较时，是temp.next.no 和 需要删除的节点的no比较
    public void delete(int no){
        //找到需要修改的节点，根据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;
        }
        //根据flag 判断是否找到要删除的节点
        if(flag){
            temp.next = temp.next.next;
        }else{//没有找到
            System.out.printf("没有找到编号为 %d 的节点，无法删除\n",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 = temp.next;
        }
    }
}



//定义一个HeroNode，每个HeroNode对象就是一个节点
class HeroNode {
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;//指向下一个节点
    //构造器
    public HeroNode(int hNo,String hName,String hNickname){
        this.no = hNo;
        this.name = hName;
        this.nickname = hNickname;
    }

    //为了显示方便，我们重写toString()
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

1.5 单链表面试题

单链表常见的面试题有如下：

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

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

（2）查找单链表中的倒数第k 个节点（新浪）

思路：

编写一个方法，接收head节点，同时接收一个index
index 表示倒数第index个
先把链表从头到尾遍历，得到链表的总的长度 getLength
得到size 之后我们从链表的第一个开始遍历 (size - index)个，就可以得到

//思路：
    //1、编写一个方法，接收head节点，同时接收一个index
    //2、index 表示倒数第index个
    //3、先把链表从头到尾遍历，得到链表的总的长度 getLength
    //4、得到size 之后我们从链表的第一个开始遍历 (size - index)个，就可以得到
    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;
        for(int i = 0; i < size - index; i++){
            cur = cur.next;
        }
        return cur;
    }

（3）单链表的反转（腾讯）

思路：

先定义一个节点 reverseHead = new HeroNode();
从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead的最前端
原来的链表的head.next = reverseHead.next

//单链表的反转（腾讯）
    public static void ReverseList(HeroNode head){
        //判断链表为空，返回null
        if(head.next == null || head.next.next == null){
            return;
        }
        //定义一个辅助的指针，帮助我们比哪里原来的链表
        HeroNode cur = head.next;
        HeroNode next = null;
        //定义反转节点
        HeroNode reverseHead = new HeroNode(0,"","");
        //遍历原来的链表，每遍历一个节点，就将其取出，并放在新链表reverseList的最前端
        while(cur != null){
            next = cur.next;
            cur.next = reverseHead.next;
            reverseHead.next = cur;
            cur = next;
        }
        head.next = reverseHead.next;
    }

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

思路：

此题的要求就是逆序打印单链表
方式1：先将单链表进行反转操作，然后再遍历即可，这样做的问题是会破环原来的的单链表的结构，不建议
方式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 后移，压入下一个节点
        }
        //将栈中的节点打印
        while(stack.size() > 0){
            System.out.println(stack.pop());//stack的特点是先进后出
        }
    }

2 双链表

管理单向列表的缺点分析：

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

分析双向链表的增删改查：

遍历方式和单链表一样，只是可以向前，也可以向后查找
添加（默认添加到双向链表的最后节点）
1. 先找到双向链表的最后这个节点
2. temp.next = newHeroNode
3. newHeroNode.pre = temp
修改的思路和原理和单向链表一样
删除
1. 因为是双向链表，因此，我们可以实现自我删除某个节点
2. 直接找到要删除的这个节点，例如temp
3. temp.pre.next = temp.next
4. temp.next.pre = temp.pre

示例代码：

package com.crisp.LinkedList;

import org.w3c.dom.Node;

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, "林冲", "豹子头");

        //添加节点
//        System.out.println("原始链表如下：");
//        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
//        doubleLinkedList.add(hero1);
//        doubleLinkedList.add(hero2);
//        doubleLinkedList.add(hero3);
//        doubleLinkedList.add(hero4);
//        doubleLinkedList.list();

        //按顺序添加节点
        System.out.println("按顺序添加链表如下：");
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.addByOrder(hero4);
        doubleLinkedList.addByOrder(hero3);
        doubleLinkedList.addByOrder(hero2);
        doubleLinkedList.addByOrder(hero1);
        doubleLinkedList.list();


        //修改一个节点
        System.out.println("修改后的链表如下：");
        HeroNode2 hero5 = new HeroNode2(3, "吴用", "智多星");
        doubleLinkedList.update(hero5);
        doubleLinkedList.list();

        //删除一个节点
        System.out.println("删除4号节点后的链表：");
        doubleLinkedList.delete(4);
        doubleLinkedList.list();
    }
}


//创建一个双向链表类
class DoubleLinkedList{
    //初始化头节点
    private HeroNode2 head = new HeroNode2(0,"","");
    //返回头节点
    public HeroNode2 getHead() {
        return head;
    }

    //添加节点到双向链表(默认添加到最后)
    public void add(HeroNode2 newNode){
        //利用辅助函数遍历
        HeroNode2 temp = head;
        while(true){
            if(temp.next == null){
                break;
            }
            temp = temp.next;
        }
        temp.next = newNode;
        newNode.pre = temp;
    }

    //第二种添加方式，按编号顺序来添加好汉
    public void addByOrder(HeroNode2 newNode){
        //利用辅助函数来遍历
        HeroNode2 temp = head;
        while(true){
            if(temp.next == null){
                newNode.next = temp.next;
                temp.next = newNode;
                newNode.pre = temp;
                break;
            }
            if(temp.next.no > newNode.no) {
                newNode.next = temp.next;
                temp.next = newNode;
                newNode.pre = temp;
                break;
            }else if(temp.next.no == newNode.no){
                System.out.println("编号已经存在，无法添加~");
                break;
            }
            temp = temp.next;
        }
    }

    //修改节点的信息
    public void update(HeroNode2 newNode){
        //判断链表是否为空
        if(head.next == null){
            return;
        }
        //遍历节点，找到需要修改的节点
        HeroNode2 temp = head;
        while(true){
            if(temp == null){
                System.out.printf("没有找到编号为 %d 的好汉\n",newNode.no);
                break;
            }
            if(temp.no == newNode.no){
                temp.name = newNode.name;
                temp.nickname = newNode.nickname;
                break;
            }
            temp = temp.next;
        }
    }

    //删除一个节点
    public void delete(int Delno){
        //判断链表是否为空
        if(head.next == null){
            System.out.println("链表为空~无法删除");
        }
        //遍历链表，找到需要删除的节点
        HeroNode2 temp = head.next;
        while(true){
            if(temp == null){
                System.out.printf("没有找到编号为 %d 的好汉\n",Delno);
                break;
            }
            if(temp.no == Delno){
                temp.pre.next = temp.next;
                if(temp.next != null){
                    temp.next.pre = temp.pre;
                }
                break;
            }
            temp = temp.next;
        }
    }


    //显示链表[遍历]
    public void list(){
        //先判断链表是否为空
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        //因为头节点不能动，因此我们需要一个辅助变量来遍历
        HeroNode2 temp = head.next;
        while(true){
            //判断是否到链表最后
            if(temp == null){
                break;
            }
            //输出节点的信息
            System.out.println(temp);
            //将temp 后移
            temp = temp.next;
        }
    }
}

//定义一个HeroNode2 ，其中多了pre 向前节点
class HeroNode2{
    public int no;
    public String name;
    public String nickname;
    public HeroNode2 next;//指向后一个节点
    public HeroNode2 pre;//指向前一个节点
    //构造器
    public HeroNode2(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }
    //重写toString
    @Override
    public String toString() {
        return "HeroNode2{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

3 环形链表

3.1 单向环形链表应用场景

Josephu 问题
- 设编号为1，2，…，n的n个人围坐一圈，约定编号为k(1<=k<=n)的人从1开始报数，数到m的那个人出列，他的下一位又从1开始数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列
提示
- 用一个不带头节点的循环链表来处理Josephu 问题：先构成一个又n个节点的单循环链表，然后由k节点起从1开始计数，计到m时，对应节点从链表中删除，然后再从被删除的节点的下一个节点又开始从1开始计数，直到最后一个节点从链表中删除，算法结束
构建一个单向环形链表思路
1. 先创建第一个节点，让first 指向该节点，并形成环形
2. 后面当我们每创建一个新的节点，就把该节点加入到已有的环形链表中即可
遍历环形链表
1. 先让一个辅助指针cur，指向first节点
2. 然后通过一个while 循环遍历该环形链表即可。cur.next == first结束
两种方式实现出圈功能：
- 方法1：创建一个辅助节点temp，初始化在first 指针后面，每次让first 指在需要出圈的节点，然后进行操作
- 方法2：只用一个first 指针，使其每次指在需要出圈节点的前一个节点，然后进行操作

3.2 Josephu问题实现代码

package com.crisp.LinkedList;

public class Josephu {
    public static void main(String[] args) {
        /*//测试环形链表
        CircleSingleLinkedList josephu = new CircleSingleLinkedList();
        //测试环形链表增加功能
        josephu.addBoy(5);
        josephu.showCircle();
        //测试环形链表删除功能
        josephu.delete(5);
        josephu.showCircle();
        //测试环形链表查找功能
        Boy res = josephu.find(5);
        System.out.println(res);*/
        //测试约瑟夫环
        JosephuRing(10,5,2);
    }

    /**
     * 约瑟夫问题
     * @param sum 游戏总人数
     * @param k 由第k个人开始
     * @param m 每次数m个数
     */
    public static void JosephuRing(int sum,int k,int m){
        //k,sum和m取值校验
        //即k的值小于等于sum且大于0
        //m的值大于1，虽然理论上可以取1，但我们认为这是毫无意义的，就相当于将first放在k上依次遍历
        if(k > sum || k <= 0 || m <= 1){
            System.out.println("~~~数据输入有误，请输入正确的数据!!!~~~");
            return;
        }
        CircleSingleLinkedList josephu = new CircleSingleLinkedList();
        josephu.addBoy(sum);

        //将孩子出圈的顺序存入数组中
        int[] arr = new int[sum];

        //根据需求，环形链表中的first节点对于本问题无影响
        //首先将first指针指向第k个人
        josephu.setFirst(josephu.find(k));
        System.out.printf("移动到第 %d 个人的位置：",k);
        josephu.showCircle();
        Boy temp = josephu.getFirst();

        //从第k个人开始数（m-1）个数
        //由于sum个人，所以一共只需要循环sum次
        for(int i = 0; i < sum; i++){
            for(int j = 2; j < m; j++){
                //将first节点向后移动一位，直到移动在数(m - 1)个数的时候
                josephu.setFirst(josephu.getFirst().getNext());
            }
            if(josephu.getFirst().getNext() == josephu.getFirst()){
                arr[i] = josephu.getFirst().getNo();
                josephu.setFirst(null);
                System.out.printf("~第 %d 次后，所有人都已经出圈~\n",i + 1);
                //输出孩子出约瑟夫环顺序
                System.out.println("孩子们的出圈顺序为：");
                for(int count = 0; count < arr.length; count ++){
                    System.out.printf(" => %d",arr[count]);
                }
                return;
            }
            arr[i] = josephu.getFirst().getNext().getNo();
            //要出圈的人就是first节点的下一个节点
            josephu.getFirst().setNext(josephu.getFirst().getNext().getNext());
            josephu.setFirst(josephu.getFirst().getNext());
            //输出每次出圈后的情况
            System.out.printf("第 %d 次出圈后顺序：",i+1);
            josephu.showCircle();
        }
    }
}

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

    //获取头节点
    public Boy getFirst() {
        return first;
    }

    //设置头节点位置
    public void setFirst(Boy first) {
        this.first = first;
    }

    //添加节点，构建成一个环形的链表
    //直接输入参与游戏的人数
    public void addBoy(int sum){
        //对sum做一个数据校验
        if(sum < 1){
            System.out.println("游戏人数不正确~");
            return;
        }
        //创建一个辅助指针，帮助创建变量
        Boy cur = null;
        //使用for循环创建环形链表
        for(int i = 1; i <= sum; i++){
            //根据编号创建节点
            Boy boy = new Boy(i);
            //如果是第一个小孩
            if(i == 1){
                first = boy;
                first.setNext(first);//构成环
                cur = first;//让cur指向第一个节点
            }else{
                cur.setNext(boy);
                boy.setNext(first);
                cur = boy;
            }
        }
    }

    //删除节点
    public void delete(int delnum){
        //判断链表是否为空
        if(first == null){
            System.out.println("~~~链表为空！！！~~~");
            return;
        }
        //创建两个辅助节点
        //一个跟在另一个的后面
        //由前一个cur1发现需要删除的节点
        //后面的cur2指向发现节点的下一个节点
        Boy cur1 = first.getNext();
        Boy cur2 = first;
        //遍历链表找到需要删除的节点
        while(true){
            //System.out.println(cur1.getNo());
            //System.out.println(cur2.getNo());
            if(cur1.getNo() == delnum){
                 cur2.setNext(cur1.getNext());
                if(cur1.getNo() == first.getNo()){
                    first = cur2.getNext();
                }
                 return;
            }
            if(cur1.getNo() == first.getNo()){
                System.out.println("~没有发现所要删除的节点~");
                return;
            }
            //两个节点均向后移位
            cur1 = cur1.getNext();
            cur2 = cur2.getNext();
        }
    }

    //查找节点
    //由于是一个环形节点
    //所以输入值应该为从头节点开始的第num个数，而不是编号值
    //注意：first节点应该算作第一个数
    public Boy find(int num){
        //定义辅助指针，用来在链表中移动
        Boy temp = first;
        for(int i = num; i > 1; i--){
            temp = temp.getNext();
        }
        return temp;
    }

    //遍历当前环形链表
    public void showCircle(){
        //判断是否为空
        if(first == null){
            System.out.println("链表为空~");
            return;
        }
        //first不可移动，因此使用辅助指针
        Boy temp = first;
        while(true){
            System.out.printf("=> %d ",temp.getNo());
            if(temp.getNext() == first){
                //最后一个节点
                System.out.println();
                return;
            }
            temp = temp.getNext();
        }
    }
}


//创建一个Boy类，表示一个节点
class Boy{
    private int no;//编号
    private Boy next;//指向下一个节点
    //构造器
    public Boy(int no) {
        this.no = no;
    }
    //set方法
    public void setNo(int no) {
        this.no = no;
    }
    public void setNext(Boy next) {
        this.next = next;
    }
    //get方法
    public int getNo() {
        return no;
    }
    public Boy getNext() {
        return next;
    }

    //重写toString，方便查看
    @Override
    public String toString() {
        return "Boy{" +
                "no=" + no +
                '}';
    }
}

三月江东

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
数据结构与算法——链表（LinkedList）

1.5 单链表面试题单链表常见的面试题有如下：（2）查找单链表中的倒数第k 个节点（新浪）思路：（3）单链表的反转（腾讯）思路：（4）从尾到头打印单链表（百度，要求方式1：反向遍历。方式2：Stack 栈）思路：2 双链表管理单向列表的缺点分析：分析双向链表的增删改查：...
复制链接

扫一扫