Java玩转《啊哈算法》之链表

最新推荐文章于 2024-02-27 21:05:08 发布
最新推荐文章于 2024-02-27 21:05:08 发布
阅读量879 收藏 22
点赞数 19
分类专栏： 算法 文章标签： java 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qizhi_hu/article/details/136207727
版权
知道为什么而死，那是了不起的事。到了那个时候，人自然会产生一种力量。

文章目录

由来

各位小伙伴们好呀！本人最近看了下《啊哈算法》，写的确实不错。

但稍显遗憾的是，书籍示例代码是c语言，而不是本人常用的Java。

那就弥补遗憾，说干就干，把这本书的示例语言用java写一遍， 顺带附上一些自己的理解！

今天这篇博客讲的是链表。
在这里插入图片描述

来不及买纸质书但又想尽快感受算法魅力的童鞋也甭担心，电子版的下载链接已经放到下方了，可尽情下载。

链接：https://pan.baidu.com/s/1imxiElcCorw2F-HJEnB-PA?pwd=jmgs
提取码：jmgs

代码地址

本文代码已开源：

git clone https://gitee.com/guqueyue/my-blog-demo.git

请切换到gitee分支，

然后查看aHaAlgorithm模块下的src/main/java/com/guqueyue/aHaAlgorithm/chapter_2_StackAndChainTable即可！

数组 vs 链表

在之前的两期博客中，我们都是用数组来模拟队列和栈：

  1. Java玩转《啊哈算法》解密QQ号之队列
  2. Java玩转《啊哈算法》解密回文之栈

当然，我们用链表同样可以模拟队列和栈。

数组和链表可以说是两种最基本的数据结构了。那么，什么是数组？

数组可以说是一段连续的存储空间。

如图：
在这里插入图片描述

而链表是一种离散的存储结构，链表不要求连续，从而可以更好的利用磁盘的存储空间。

链表的每一个元素节点都包括下一个元素节点的地址，如果是尾节点，则下一个元素节点的地址为空。

因此，链表寻找元素就好比找人，就像电视剧《佛陀传》中 耶输陀罗公主 想要找到 悉达多王子，她首先在皇宫问了下 女仆曼阇利卡，然后知道了马厩，又在马厩问了马夫车匿，才知道悉达多在山上的树下，从而找到了悉达多王子。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

如图：

在这里插入图片描述

这样一看，链表似乎灵活的多，数组则显得有点呆。那么，是这样吗？我们来具体分析一下：

一般我们对元素的操作可以分为两类：查找和更新，而更新又可分为插入、删除、修改。

在占用空间是一样的前提下，衡量数据结构的好坏当然是执行速率。数组和链表则是各擅胜场：

  1. 查找、修改元素数组更快。数组是连续的，而链表还需要一个一个的获取下一个元素的地址，然后才能获取或者修改元素。
  2. 插入、删除元素链表更快。链表只需要改动部分元素节点，而数组则需要整体移动更改。

就像作者书中说的那样，如果要在数组中插入一个数，需要整体后移：

在这里插入图片描述
而链表只需要简单改动：

在这里插入图片描述

链表

创建

那么，我们要如何实现链表呢？

在书中，因为作者用的是c语言，需要用到指针，所以作者特意讲解了下指针。

指针这东西确实让人有些头疼。但所幸，咱们用的是Java，Java里面没有指针，所以我们直接跳过指针。

在这里插入图片描述

要通过代码实现链表的话，首先我们需要创建一个节点类用来表示链表的节点：

package com.guqueyue.aHaAlgorithm.entity;

/**
 * @Author: guqueyue
 * @Description: 链表类
 * @Date: 2024/1/15
 **/
public class Node {

    public int data; // 数据
    public Node next; // 下一个数据对象

    /**
     * 无参构造方法
     **/
    public Node() {
    }

    /**
     * 全参构造方法
     **/
    public Node(int data, Node next) {
        this.data = data;
        this.next = next;
    }
}

然后我们可以创建一个方法用于创建链表。在这个方法中，我们通过遍历的方式逐个给链表的节点赋值，并且将链表的头节点返回：

	/**
     * @Description 创建一个链表，并返回头节点
     * @Param []
     * @return com.guqueyue.aHaAlgorithm.entity.ChainTable
     **/
    private static Node createChainTable() {

        System.out.print("您希望输入几个数：");
        int n = scanner.nextInt();

        System.out.print("请输入(以空格分开，再按回车即可)：");
        Node head = null; // 声明头节点
        Node curr = new Node(); // 声明当前节点
        for (int i = 0; i < n; i++) {

            // 创建下一个节点
            Node next = new Node(scanner.nextInt(), null);
            if (head == null) {

                head = next; // 如果头节点为空，则头节点指向下一个节点

            }else {

                curr.next = next; // 如果头节点不为空，则当前节点的下一个节点指向下一个节点
            }

            curr = next; // 给下一个节点赋值
        }

        // 返回头节点
        return head;
    }

遍历

为了方便验证我们的成果，我们需要一个遍历打印链表的方法：

	/**
     * @Description 打印链表
     * @Param [head：头节点]
     * @return void
     **/
    private static void printChainTable(Node head) {

        Node temp = head; // 声明临时节点并赋值
        System.out.print("链表为：" + temp.data); // 打印头节点
        while (temp.next != null) {

            // 获取下一个节点并打印
            temp = temp.next;
            System.out.print("->" + temp.data);
        }
        System.out.println(); // 换行
    }

下面我们来创建一个链表，并且遍历打印试试：

package com.guqueyue.aHaAlgorithm.chapter_2_StackAndChainTable;

import com.guqueyue.aHaAlgorithm.entity.Node;

import java.util.Scanner;

/**
 * @Author: guqueyue
 * @Description: 链表模拟
 * @Date: 2024/1/15
 **/
public class ChainTableTest {

    // 创建一个Scanner对象, 用于控制台输入
  	public static Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) {

        // 创建一个链表，并返回头节点
        Node head = createChainTable();

        // 打印链表
        printChainTable(head);
    }


    /**
     * @Description 打印链表
     * @Param [head：头节点]
     * @return void
     **/
    private static void printChainTable(Node head) {

        Node temp = head; // 声明临时节点并赋值
        System.out.print("链表为：" + temp.data); // 打印头节点
        while (temp.next != null) {

            // 获取下一个节点并打印
            temp = temp.next;
            System.out.print("->" + temp.data);
        }
        System.out.println(); // 换行
    }

    /**
     * @Description 创建一个链表，并返回头节点
     * @Param []
     * @return com.guqueyue.aHaAlgorithm.entity.ChainTable
     **/
    private static Node createChainTable() {

        System.out.print("您希望输入几个数：");
        int n = scanner.nextInt();

        System.out.print("请输入(以空格分开，再按回车即可)：");
        Node head = null; // 声明头节点
        Node curr = new Node(); // 声明当前节点
        for (int i = 0; i < n; i++) {

            // 创建下一个节点
            Node next = new Node(scanner.nextInt(), null);
            if (head == null) {

                head = next; // 如果头节点为空，则头节点指向下一个节点

            }else {

                curr.next = next; // 如果头节点不为空，则当前节点的下一个节点指向下一个节点
            }

            curr = next; // 给下一个节点赋值
        }

        // 返回头节点
        return head;
    }
}

运行得：

在这里插入图片描述

在这里插入图片描述

插入

在这里插入图片描述
按照书上的例子，我们再来写一个往链表中按照元素顺序为从小到大 插入节点的方法：

 	/**
     * @Description 往链表中插入数据
     * @Param [head: 头节点]
     * @return void
     **/
    private static Node insertChainTable(Node head) {


        // 插入
        System.out.print("请输入要插入的数: ");
        int num = scanner.nextInt();

        Node t = head; // 声明临时节点表示当前节点
        while (t != null) {

            if (t.next != null && t.next.data > num) { // 如果下一个节点的值大于插入数，则插入

                // 给插入节点赋值，并将插入节点的下一个节点 指向 当前节点的下一个节点
                Node newNode = new Node(num, t.next);

                t.next = newNode; // 当前节点的下一个节点指向新增节点
                break; // 结束
            }

            t = t.next; // 当前节点指向下一个节点
        }

        return head;
    }

按照这个方法，我们插入后再来打印链表验证一下（完整代码已开源，在本博客最后也可查看）：

public static void main(String[] args) {

        // 创建一个链表，并返回头节点
        Node head = createChainTable();

        // 打印链表
        printChainTable(head);

        // 往链表中插入数据
        head = insertChainTable(head);
//        head = insertChainTable2(head);

        // 再次打印链表
        printChainTable(head);
}

运行得：
在这里插入图片描述

这样看来好像并没有什么问题，但是多观察尝试你会发现作者的逻辑存在两个比较明显的问题：

  1. 如果插入的节点值大小小于头节点，该节点会被插入到头节点后面，违背了从小到大的顺序。
  2. 如果插入的节点值大于等于尾结点，则该节点不会被插入。

如：

在这里插入图片描述
又比如：

在这里插入图片描述
因此，我们来改进一下：

	/**
     * @Description 往链表中插入数据
     * @Param [head: 头节点]
     * @return void
     **/
    private static Node insertChainTable2(Node head) {

        // 插入
        System.out.print("请输入要插入的数: ");
        int num = scanner.nextInt();
        if (num <= head.data) { // 如果插入的节点值小于等于头节点的值，则直接插入为头节点

            // 给插入节点赋值，并将插入节点的下一个节点 指向 当前节点的下一个节点
            Node newNode = new Node(num, head);

            head = newNode;

        }else {

            Node t = head; // 声明临时节点表示当前节点
            while (t != null) {

                if (t.next == null) { // 如果下一个节点为空，则说明是尾节点，并且插入的节点值为最大值，直接插入为尾节点

                    t.next = new Node(num, null);
                    break;

                } else if(t.next.data >= num) { // 如果下一个节点的值大于插入数，则插入

                    // 给插入节点赋值，并将插入节点的下一个节点 指向 当前节点的下一个节点
                    Node newNode = new Node(num, t.next);

                    t.next = newNode; // 当前节点的下一个节点指向新增节点
                    break; // 结束
                }

                t = t.next; // 当前节点指向下一个节点
            }
        }

        return head;
    }

再改动一下代码：

public static void main(String[] args) {

        // 创建一个链表，并返回头节点
        Node head = createChainTable();

        // 打印链表
        printChainTable(head);

        // 往链表中插入数据
//        head = insertChainTable(head);
        head = insertChainTable2(head);

        // 再次打印链表
        printChainTable(head);
}

运行代码，控制台输入，可得：

在这里插入图片描述

以及

在这里插入图片描述

搞定！！！

完整代码

完整代码如下：

package com.guqueyue.aHaAlgorithm.chapter_2_StackAndChainTable;

import com.guqueyue.aHaAlgorithm.entity.Node;

import java.util.Scanner;

/**
 * @Author: guqueyue
 * @Description: 链表模拟
 * @Date: 2024/1/15
 **/
public class ChainTableTest1 {

    // 创建一个Scanner对象, 用于控制台输入
   public static Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) {

        // 创建一个链表，并返回头节点
        Node head = createChainTable();

        // 打印链表
        printChainTable(head);

        // 往链表中插入数据
//        head = insertChainTable(head);
        head = insertChainTable2(head);

        // 再次打印链表
        printChainTable(head);
    }

    /**
     * @Description 往链表中插入数据
     * @Param [head: 头节点]
     * @return void
     **/
    private static Node insertChainTable(Node head) {


        // 插入
        System.out.print("请输入要插入的数: ");
        int num = scanner.nextInt();

        Node t = head; // 声明临时节点表示当前节点
        while (t != null) {

            if (t.next != null && t.next.data > num) { // 如果下一个节点的值大于插入数，则插入

                // 给插入节点赋值，并将插入节点的下一个节点 指向 当前节点的下一个节点
                Node newNode = new Node(num, t.next);

                t.next = newNode; // 当前节点的下一个节点指向新增节点
                break; // 结束
            }

            t = t.next; // 当前节点指向下一个节点
        }

        return head;
    }

    /**
     * @Description 往链表中插入数据
     * @Param [head: 头节点]
     * @return void
     **/
    private static Node insertChainTable2(Node head) {

        // 插入
        System.out.print("请输入要插入的数: ");
        int num = scanner.nextInt();
        if (num <= head.data) { // 如果插入的节点值小于等于头节点的值，则直接插入为头节点

            // 给插入节点赋值，并将插入节点的下一个节点 指向 当前节点的下一个节点
            Node newNode = new Node(num, head);

            head = newNode;

        }else {

            Node t = head; // 声明临时节点表示当前节点
            while (t != null) {

                if (t.next == null) { // 如果下一个节点为空，则说明是尾节点，并且插入的节点值为最大值，直接插入为尾节点

                    t.next = new Node(num, null);
                    break;

                } else if(t.next.data >= num) { // 如果下一个节点的值大于插入数，则插入

                    // 给插入节点赋值，并将插入节点的下一个节点 指向 当前节点的下一个节点
                    Node newNode = new Node(num, t.next);

                    t.next = newNode; // 当前节点的下一个节点指向新增节点
                    break; // 结束
                }

                t = t.next; // 当前节点指向下一个节点
            }
        }

        return head;
    }


    /**
     * @Description 打印链表
     * @Param [head：头节点]
     * @return void
     **/
    private static void printChainTable(Node head) {

        Node temp = head; // 声明临时节点并赋值
        System.out.print("链表为：" + temp.data); // 打印头节点
        while (temp.next != null) {

            // 获取下一个节点并打印
            temp = temp.next;
            System.out.print("->" + temp.data);
        }
        System.out.println(); // 换行
    }

    /**
     * @Description 创建一个链表，并返回头节点
     * @Param []
     * @return com.guqueyue.aHaAlgorithm.entity.ChainTable
     **/
    private static Node createChainTable() {

        System.out.print("您希望输入几个数：");
        int n = scanner.nextInt();

        System.out.print("请输入(以空格分开，再按回车即可)：");
        Node head = null; // 声明头节点
        Node curr = new Node(); // 声明当前节点
        for (int i = 0; i < n; i++) {

            // 创建下一个节点
            Node next = new Node(scanner.nextInt(), null);
            if (head == null) {

                head = next; // 如果头节点为空，则头节点指向下一个节点

            }else {

                curr.next = next; // 如果头节点不为空，则当前节点的下一个节点指向下一个节点
            }

            curr = next; // 给下一个节点赋值
        }

        // 返回头节点
        return head;
    }
}
古阙月
关注
  • 19
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java算法实例-双向链表操作
08-22
双向链表与单链表相比，其独特之处在于每个节点不仅包含指向下一个节点的指针，还包含指向前一个节点的指针，这使得在链表中的前进和后退操作变得相对高效。 双向链表的操作主要包括创建、插入、删除、遍历等。下面...
Java算法练习-链表的分化练习题
10-07
java
Java玩转《啊哈算法》之模拟链表
最新发布
Qizhi_Hu的博客
02-27 1017
各位小伙伴们好呀！本人最近看了下《啊哈算法》，写的确实不错。但稍显遗憾的是，书籍示例代码是c语言，而不是本人常用的Java。那就弥补遗憾，说干就干，把这本书的示例语言用java写一遍， 顺带附上一些自己的理解！今天这篇博客讲的是如何用数组来模拟链表。
Java玩转《啊哈算法》解密QQ号之队列
Qizhi_Hu的博客
02-01 1016
各位好！本人在看《啊哈算法》，写的确实不错。但略微遗憾的是，书籍示例代码是c语言，不是本人常用的Java。那就弥补遗憾，说干就干，把这本书的示例语言用java过一遍， 顺便附上自己的一些理解！于是就有了本篇博客，本篇博客主要是讲常见数据结构的一种：队列。
labuladong算法小结
热门推荐
limx的博客
06-30 1万+
1. 数据结构的存储方式 2. 数据结构基本操作——遍历+访问 线性 ​ for/while void traverse(int[] arr) { for (int i = 0; i < arr.length; i++) { // 迭代访问 arr[i] } } 非线性 ​ 递归 链表遍历框架 兼具迭代和递归结构: class ListNode{ int val; ListNode next; } void traverse(ListNod
Java学习之路
AthlenaA的博客
05-21 1万+
第一部分是我在参加2018春招时所写，主要记录了我在研究生期间学习Java后端的心路历程。 第二部分内容是我参加2019秋季招聘过程中所作，记录了秋招路上所经历的一切。 第三部分内容则是我在秋招尘埃落定之后，对之前所学所想而做出的总结。 第一部分：Java后端学习之路 第二部分：我的秋招回忆录 第三部分：我的秋招经验分享（研发方向） 一、Java后端学习之路 这部分内容是我在准备2018年春招的时...
Java实现链表的常见操作算法详解
08-25
主要介绍了Java实现链表的常见操作算法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java算法练习-环形链表插值练习题
10-01
java学习
Java算法设计-链表的回文结构练习题
10-08
java
今天我们来聊聊递归喝汽水问题
Qizhi_Hu的博客
06-26 1万+
用代码喝汽水的正确打开方式...
实现两个数互换的八种方法
Qizhi_Hu的博客
03-08 1万+
目录基本数据类型借助第三个变量不借助第三个变量异或引用数据类型 基本数据类型 借助第三个变量 /** * @author guqueyue * @Date 2020/3/6 * 方法一：实现两个数交换 **/ public class Exchange1 { public static void main(String[] args) { /** ...
贪心算法求解：王者荣耀购买点券最优策略
Qizhi_Hu的博客
09-05 5200
最近看了下《算法图解》确实给自己不少启发，感觉自己看世界多了一个角度、多了一分透彻，就连玩游戏比如王者荣耀的时候也是如此..
一行代码求出三个数中的最大值（Java三元操作符）
Qizhi_Hu的博客
02-15 3398
如何求出三个数中的最大数？ 首先我们来看版本一： /** * @author guqueyue * @Date 2020/2/15 * 求三个数中的最大数 * 版本一 **/ public class ThreeMax1 { public static void main(String[] args) { // 随机产生三个固定序列的0-100之间的整数 ...
肝了几万字，送给看了《算法图解》却是主攻Java的你和我（上篇）
Qizhi_Hu的博客
08-02 3206
最近看了下《算法图解》这本书，写的确实通俗易懂、生动有趣，很适合算法入门。但可惜书中示例都是用Python代码实现的，对于主攻Java语言的程序员包括我有点不太友好。为此，我特意将书中的Python代码翻译成了Java代码。当然，本博主并不是简单粗暴的直接翻译，而是辅以必要的讲解，所以没有看过《算法图解》一书也可放心阅读。
递归和循环之间不得不说的故事
Qizhi_Hu的博客
02-20 1554
递归直通车帝龟出世寻欢初识帝龟初现端倪来龙去脉迷失的帝龟我要这递归有何用？考考你 帝龟出世 大家好，我是今天的主角，帝龟！ 一只自带帝王之气的乌龟殿下 - - wo来自遥远的东海之滨，每天清晨我…咳咳, 有些扯远了 下面进入重点： 寻欢初识帝龟 下文为循环和递归的一些基本概念 循环：重复性的执行某段程序 "寻欢"和"帝龟"不一样，它是个直性子，它会一次性干脆利落的把活全都干完，...
Java玩转《啊哈算法》排序之桶排序
Qizhi_Hu的博客
01-24 1289
大家好！本人最近看了下《啊哈算法》，写的确实不错，生动形象又有趣（~~我没收钱，确实如此~~ ）。但对我来说，稍显遗憾的是，书籍代码是c语言，而不是本人常用的Java。那就弥补遗憾，说干就干，把这本书的示例语言用java给翻译一遍！！！
递归实战篇：查询商品分类的实现
Qizhi_Hu的博客
03-05 1227
引言 之前我写了一篇关于递归的博客，反响还不错，链接如下： 递归和循环之间不得不说的故事：https://blog.csdn.net/Qizhi_Hu/article/details/104395547， 然后不久有朋友问了我个关于递归的问题，其实具体实现逻辑和我上次写的博客举的最后一个例子是一样的。 问题如图，以哲学分类为例，使哲学为父节点，通过点击哲学，获取父节点下的所有子节点，包括子节点...
Java玩转《啊哈算法》排序之快速排序
Qizhi_Hu的博客
01-30 1049
搭嘎好！本人最近看的《啊哈算法》这本书写的确实不错，生动形象，在保持算法讲解准确性的同时又不失趣味性。但对我来说，稍显遗憾的是，书籍代码是c语言，而不是本人常用的Java。那就弥补遗憾，说干就干，把这本书的示例语言用java给翻译一遍！！！于是就有了本篇博客，这是第三篇博客，主要讲解快速排序。
高频算法题目总结1
08-04
"这是一个关于Java算法的总结，涵盖了链表操作、二叉树遍历、缓存设计、数组问题、字符串处理等多种算法题目。" 这篇总结涉及了多个计算机科学中的经典算法题目，主要集中在数据结构（如链表、数组、二叉树）和算法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值