链表知识和代码实现

于 2022-10-28 22:13:36 发布
阅读量392 收藏
点赞数
文章标签： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_50552745/article/details/127525614
版权
本文详细介绍了链表的基础知识，包括单链表的添加、插入、修改和删除操作，以及常见面试题的解题思路。此外，还讨论了双链表的实现，并提及了约瑟夫问题的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.单链表：

单链表：

第一种直接在尾部进行添加：

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        //测试
        HeroNode heroNode = new HeroNode(1,"宋江","狗杂种");
        HeroNode heroNode2 = new HeroNode(2,"林冲","豹子头");
        HeroNode heroNode3 = new HeroNode(3,"吴用","狗腿子");
        HeroNode heroNode4 = new HeroNode(4,"李逵","大二愣子");

        //将上面的元素添加到链表中
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.add(heroNode);
        singleLinkedList.add(heroNode3);
        singleLinkedList.add(heroNode2);
        singleLinkedList.add(heroNode4);

        //遍历
        singleLinkedList.list();
    }
}

class SingleLinkedList{
    //先初始化一个头节点，头节点不能动，不存放任何数据
    HeroNode head = new HeroNode(0,"","");

    public void add(HeroNode heroNode){
        //因为头节不能动 所以我们使用一个 tmp 中间节点来做完 head 节点的替代
        HeroNode temp = head;

        //遍历链表找到最后
        while (true){
            if (temp.next == null){
                //找到链表最后
                break;
            }
            temp = temp.next;
        }
        //当退出 while 循环时，temp就指向了链表的最后一个
        //将最后一个的next添加 新元素
        temp.next = heroNode;
    }

    //显示链表
    public void list(){
        //判断是否为空
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }

        //同上 head指针不能动 所以创一个中间变量
        HeroNode temp = head;

        while (true){
            //判断链表是否为空
            if (temp.next == null){
                break;
            }
            //将temp后移
            temp = temp.next;
            System.out.println(temp);
        }
    }

}

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 "\n HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}

第二种安照编号顺序插入:

//第二种方式添加英雄时，根据排名将英雄插入到指定位置 (如果有这个排名，则添加失败，并给出提示)
public void addByOrder(HeroNode heroNode){
    //因为头节点不能动，所以创建一个辅助指针（变量）来帮助找到添加的位置
    //因为单链表，因为我们找到的temp是位于添加位置的前一个节点，否则无法插入
    HeroNode temp = head;
    boolean flag = false; //flag 标示添加的编号是否存在，默认是false
    while (true){
        if (temp.next == null){ //说明 temp 已经是链表的最后了
            break;
        } else 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.next = temp.next;
        temp.next = heroNode;
    }
}

 修改方法：

//修改方法
/**
 * 修改节点的信息，根据 no 编号来进行修改，即 no 编号不能改
 * 说明：1.根据 newHeroNode 的 no 来修改即可
 * @param newHeroNode
 */
public void update(HeroNode newHeroNode){
    //判断是否为空
    if (head.next == null){
        System.out.println("链表为空");
    }
    //定义辅助变量
    HeroNode temp = head;
    boolean flag = false; //表示是否找到修改的节点
    while (true){
        if (temp == null){
            break; //已经遍历完链表
        }else 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.on 和 需要删除的 no 做比较
 * @param no
 */
public void del(int  no){
    HeroNode temp = head;
    boolean flag = false; //标记是否需要删除

    while (true){
        if (temp.next == null){
            break;
        } else if (temp.next.no == no){
            //找到待删除节点的前一个
            flag = true;
            break;
        }
        temp = temp.next;
    }
    if (flag){
        // 可以删除
        temp.next = temp.next.next;
    } else {
        System.out.printf("找不到编号为 %n 的英雄",no);
    }
}

单链表相关面试题：

 求有效节点个数：

//方法：获取到单链表的节点的个数（如果带头结点的链表，需求不统计头节点）
//求单链表中的有效节点的个数
/**
 * @param head  链表的头节点
 * @return  返回的就是有效节点的个数
 */
public static int size(HeroNode head){
    if (head.next == null){ //空链表
        return 0;
    }
    //创建一个中间节点
    HeroNode temp = head;
    int length = 0;
    //不统计头节点
    while (temp.next != null){
        length++;
        temp = temp.next;
    }
    return length;
}

查找倒数k的值：

/**
 * 思路：1.编写一个方法，接收 head 节点，同时接收一个 index
 *      2.index 表示是倒数第 index 个节点
 *      3.先把链表从头到尾遍历，得到链表的总长度 size
 *      4.得到size后，我们从链表的第一个开始遍历（size-index）个，就可以得到
 *      5.如果得到了，就返回该节点，否则返回 null
 */
public static HeroNode findLastIndexNode(HeroNode head,int index){
    if (head.next == null){ //空链表
        return null;
    }
    //第一个遍历得到链表的长度（节点个数）
    int size = size(head);
    //第二次遍历是 size-index 位置，就是元素所在的位置
    if (index <= 0 || index > size){
        return null;
    }

    //定义辅助变量 for 循环找到倒数的第 index 元素
    HeroNode temp = head;
    for (int i = 0; i <= size-index; i++) {
        temp = temp.next;
    }
    return temp;
}
 

//方法：获取到单链表的节点的个数（如果带头结点的链表，需求不统计头节点）
//求单链表中的有效节点的个数
/**
 * @param head  链表的头节点
 * @return  返回的就是有效节点的个数
 */
public static int size(HeroNode head){
    if (head.next == null){ //空链表
        return 0;
    }
    //创建一个中间节点
    HeroNode temp = head;
    int length = 0;
    //不统计头节点
    while (temp.next != null){
        length++;
        temp = temp.next;
    }
    return length;
}

链表反转：

 

/反转链表
public static void reversetList(HeroNode head){
    //如果当前链表为空，或者只有一个节点，无需反转，直接返回
    if (head.next == null || head.next.next == null){
        return;
    }
    //定义一个辅助指针（变量），帮助我们遍历原来的链表
    HeroNode temp = head.next;
    HeroNode next = null;//当前节点的下一个节点
    HeroNode reverseHead = new HeroNode(0,"","");
    //遍历原来的链表，每遍历一个节点就将元素取出，并将它放入新的链表 reverseHead 的最前端
    while (temp != null){
        next = temp.next; //先暂时保存下一个节点  防止丢失
        //链表的添加
        temp.next = reverseHead.next;
        reverseHead.next = temp;
        temp = next;//给temp赋值
    }
    //将头节点指向 reverseHead 的元素实现反转
    head.next = reverseHead.next;
}

 逆序打印：

//逆序打印链表(两种方法：1.将链表反转，然后再输出(缺点:会破坏链表原有的结构)  2.使用栈的原理，将链表的节点放入栈中，栈先进后出的原理)
public static void reversePrint(HeroNode head){
    HeroNode temp = head.next;
    Stack<HeroNode> stack = new Stack<HeroNode>();

    //入栈
    while (temp != null){ //说明链表已经遍历结束
        stack.add(temp);
        temp = temp.next;
    }

    //出栈
    while (stack.size() > 0){ //当栈的长度小于 0 或等于 0 时结束循环
        System.out.println(stack.pop());
    }
}

 个人任务（和并有序链表，使其仍然是有序的）：

/**
 * @author peiyu
 * @version 1.0
 * 合并两个有序列表，合并之后任然是有序的
 */
public class Test {
    public static void main(String[] args) {
        HeroNode head = new HeroNode(0,"","");
        ListLink_ listLink_ = new ListLink_(head);
        HeroNode heroNode1 = new HeroNode(1,"曹操","丞相");
        HeroNode heroNode2 = new HeroNode(3,"孙权","大都督");
        HeroNode heroNode3 = new HeroNode(2,"刘备","刘皇叔");
        listLink_.add(heroNode1);
        listLink_.add(heroNode2);
        listLink_.add(heroNode3);

        System.out.println("遍历链表1");
        listLink_.list(head);

        HeroNode head1 = new HeroNode(0,"","");
        ListLink_ listLink_1 = new ListLink_(head1);
        HeroNode heroNode4 = new HeroNode(2,"诸葛亮","丞相");
        HeroNode heroNode5 = new HeroNode(5,"周瑜","大都督");
        HeroNode heroNode6 = new HeroNode(4,"吕布","三姓家奴");
        listLink_1.add(heroNode4);
        listLink_1.add(heroNode5);
        listLink_1.add(heroNode6);

        System.out.println("遍历链表2");
        listLink_.list(head1);

        System.out.println("合并链表");
        listToMerge(head,head1);
        System.out.println();
        listLink_.list(head1);
    }

    //将两链表合并 两个参数 第一个参数是链表1 第二个是链表2  将链表1合并到链表2
    public static void listToMerge(HeroNode heroNode1,HeroNode heroNode2){
        if (heroNode1.next == null || heroNode2.next == null){
            System.out.println("存在空链表");
        }
        HeroNode temp = heroNode1.next;
        while (temp != null){
            HeroNode cur = temp.next;
            insertTheList(temp,heroNode2); //调用插入的方法  传入一个要插入的元素  和 一个要插入的链表
            temp = cur;
        }
    }

    //链表插入方法 两个参数 第一个是插入的元素 第二个是插入的链表 其思想和顺序插入一样 只是在面对相同的 no 时 将第一个参数添加到前面
    public static void insertTheList(HeroNode heroNode,HeroNode head){
        HeroNode temp = head;
        while (true){
            if (temp.next == null){
                heroNode.next = temp.next;
                temp.next = heroNode;
                break;
            } else if (temp.next.no == heroNode.no){
                heroNode.next = temp.next;
                temp.next = heroNode;
                break;
            } else if (temp.next.no > heroNode.no){
                heroNode.next = temp.next;
                temp.next = heroNode;
                break;
            }
            temp = temp.next;
        }
    }
}

class ListLink_{
    private HeroNode head;

    public ListLink_(HeroNode head) {
        this.head = head;
    }

    public void add(HeroNode node){
        HeroNode temp = head;
        while (true){
            if (node.no == temp.no){  //等等于的时候不添加
                System.out.printf("准备出入的英雄编号 %d 已经存在了，不能加入\n",node.no);
                break;
            } else if (temp.next == null){  //当遍历到最后时，直接添加在最后
                node.next = temp.next;
                temp.next = node;
                break;
            } else if (temp.next.no > node.no){  //注意 其一定要放在 temp.next == null  因为当外卖遍历到最后一个时 其没有 no 属性 会报错
                node.next = temp.next;
                temp.next = node;
                break;
            }
            temp = temp.next;
        }
    }

    public void list(HeroNode head){
        HeroNode temp = head;
        if (temp.next == null){
            System.out.println("链表为空");
        }

        while (temp.next != null){
            temp = temp.next;
            System.out.println(temp);
        }
    }
}

2.双链表：

代码实现：

public class DoubleLinkedListDemo {
    public static void main(String[] args) {
        //测试
        HeroNode1 heroNode = new HeroNode1(1,"宋江","狗杂种");
        HeroNode1 heroNode4 = new HeroNode1(4,"李逵","大二愣子");
        HeroNode1 heroNode2 = new HeroNode1(2,"林冲","豹子头");
        HeroNode1 heroNode3 = new HeroNode1(3,"吴用","狗腿子");

        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.add1(heroNode);
        doubleLinkedList.add1(heroNode4);
        doubleLinkedList.add1(heroNode2);
        doubleLinkedList.add1(heroNode3);

        System.out.println("链表");
        doubleLinkedList.list();

        HeroNode1 heroNode5 = new HeroNode1(3,"吴用","无用");

        System.out.println("修改后的链表");
        doubleLinkedList.update(heroNode5);
        doubleLinkedList.list();

        System.out.println("删除链表");
        doubleLinkedList.del(3);
        doubleLinkedList.list();
    }
}

class DoubleLinkedList{
    //先创建一个头结点
    HeroNode1 head = new HeroNode1(0,"","");

    //有的场景需要获取头结点
    public HeroNode1 getHead() {
        return head;
    }

    //遍历双向链表的方法
    public void list(){
        //先判断链表是否为空
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        //头结点不能动 使用一个中间节点
        HeroNode1 temp = head;
        while (temp.next != null){
            temp = temp.next;
            System.out.println(temp);
        }
    }

    //顺序添加
    public void add1(HeroNode1 heroNode){
        //创建一个中间变脸  头节点不能动
        HeroNode1 temp = head;
        while (true) {
            if (temp.next == null){
                temp.next = heroNode;
                heroNode.pre = temp;
                break;
            } else if (temp.next.no > heroNode.no){
                heroNode.next = temp.next;
                temp.next.pre = heroNode;
                heroNode.pre = temp;
                temp.next = heroNode;
                break;
            } else if (temp.next.no == heroNode.no) {
                System.out.printf("已经存在 %d 节点\n",heroNode.no);
                break;
            }
            temp = temp.next;
        }
    }

    //添加一个节点到双向链表的最后
    public void add(HeroNode1 heroNode){
        //创建一个中间变脸  头节点不能动
        HeroNode1 temp = head;
        while (true) {
            //当链表的下一个为空时 插入数据
            if (temp.next == null) {
                temp.next = heroNode;
                heroNode.pre = temp;
                break;
            }
            temp = temp.next;
        }
    }

    //修改节点的内容
    public void update(HeroNode1 heroNode){
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        //找一个中间变量 head把你的动
        HeroNode1 temp = head.next;
        while (true) {
            if (temp == null) {
                System.out.printf("没有找到编号 %d 的节点，不能修改\n",heroNode.no);
                break;
            }
            if (temp.no == heroNode.no) {
                temp.no = heroNode.no;;
                temp.name = heroNode.name;
                temp.nickName = heroNode.nickName;
                break;
            }
            temp = temp.next;
        }
    }

    //删除一个节点
    public void del(int no){
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        //找一个中间变量 head把你的动
        HeroNode1 temp = head.next;

        while (true){
            if (temp == null) {
                System.out.printf("没有找到编号 %d 的节点，不能修改\n",no);
                break;
            }
            if (temp.no == no) {
                temp.pre.next = temp.next;
                //当遍历到最后一个节点时就不需要执行 下一句   因为 temp。next = null 出现空指针异常
                if (temp.next != null) {
                    temp.next.pre = temp.pre;
                }
                break;
            }
            temp = temp.next;
        }
    }
}

class HeroNode1{
    public int no;
    public String name;
    public String nickName;
    public HeroNode1 next;
    public HeroNode1 pre;

    public HeroNode1(int no, String name, String nickName) {
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

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

 

3.约瑟夫问题

 

 

public class Jospfu {
    public static void main(String[] args) {
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(20);
        circleSingleLinkedList.showBoy();
    }
}

class CircleSingleLinkedList{
    private Boy first = null;

    //天机小孩节点，构建一个环形的链表
    public void addBoy(int nums){
        if (nums < 1){
            System.out.printf("输入的 nums 不正确");
            return;
        }
        //辅助指针，帮助创建环形链表
        Boy curBoy = null;
        //使用for循环创建我们的链表
        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); //指向 first 形成环状
                curBoy = boy; //将 curBoy 指向新加的 boy
            }
        }
    }
    //循环遍历当前的链表
    public void showBoy(){
        //先判断链表是否为空
        if (first == null){
            System.out.println("链表为空");
            return;
        }
        //因为first不能动所以使用一个中间变量
        Boy curBoy = first;
        while (true){
            System.out.println(curBoy);
            if (curBoy.getNext() == first){
                break;
            }
            curBoy = curBoy.getNext(); //循环
        }
    }
}

class Boy{
    private int no;//编号
    private Boy next;

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

    @Override
    public String toString() {
        return "小孩编号:" + no ;
    }
}

小孩出圈：

/**
 *
 * @param startNo 表示从第几个位置开始
 * @param countNum 表示数几下
 * @param nums 表示最初多少小孩在圈
 */
public void countBoy(int startNo,int countNum,int nums){
    //先校验数据
    if (first == null || startNo <0 || startNo > nums){
        System.out.println("输入参数有关");
    }
    //先创建中间变量
    Boy helper = first;
    //将 helper 指向最后的节点
    while (true) {
        if (helper.getNext() == first ) { //说明已经在最后一个位置了
            break;
        }
        helper = helper.getNext();
    }
    //先将其移动到 最开始小孩的位置
    for (int i = 0;i < startNo - 1 ; i++) {
        first = first.getNext();
        helper = helper.getNext();
    }
    //开始报数
    while (true) {
        if (helper == first) { // 说明圈内只有一个节点
            break;
        }
        for (int j = 0 ; j < countNum - 1; j++) {
            first = first.getNext();
            helper = helper.getNext();
        }

        //此时 first 指向的节点就是 要出圈的节点
        System.out.printf("\n 小孩 %d 出圈",first.getNo());
        first = first.getNext();
        helper.setNext(first);
    }
    System.out.println("\n 剩余的 first 是"+first);
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值