Java基础算法之------单链表

最新推荐文章于 2021-05-24 20:27:28 发布
最新推荐文章于 2021-05-24 20:27:28 发布
阅读量274 收藏
点赞数
分类专栏： # 算法基础 算法设计 文章标签： 链表 单链表 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LOL_toulan/article/details/105289148
版权

什么是链表

我们平常生活中骑过自行车的话就应该知道，自行车的链条是一个连着一个，每一个都不是单独存在的，否则就无法使用，当然，与我们今天所描述的有一定差距，但是原理差不多。
在这里插入图片描述在这里插入图片描述
由图片我们可以发现，无论是车的链条，还是链表的结构，都是每个节点上有两个位置。

但是我们今天的与链条不同的是我们的结构中，前面是数据，后面存的是下一个节点的地址

在这里插入图片描述

创建单链表

创建链表的数据结构

//创建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;
    }

    public HeroNode() {
    }


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

添加节点

分析示意图
在这里插入图片描述

  1. 首先，我们需要考虑，添加元素时，我们的指针如何移动，我们的数据如何插入
  2. 因为我们此方法，是一个简单的链表尾插法，
  3. 首先，我们需要将链表遍历到尾部，但是我们将链表遍历到尾部的核心是什么，核心是我们的next为null
  4. 找到该节点之后，我们将这个节点的next指向新的next
 private HeroNode head = new HeroNode(0, "", "");

    //首先，我们需要考虑，添加元素时，我们的指针如何移动，我们的数据如何插入
    //因为我们此方法，是一个简单的链表尾插法，
    //首先，我们需要将链表遍历到尾部，但是我们将链表遍历到尾部的核心是什么，核心是我们的next为null
    //找到该节点之后，我们将这个节点的next指向新的next

    /**
     * 尾插法，添加新的节点
     * @param heroNode
     */
   public void add(HeroNode heroNode) {

       // 首先，由于我们的头节点不能动，所以如果我们想判断我们的下一个节点是否为空，我们需要再定义一个指针
       HeroNode temp = head;

       // 我们通过让temp不断后移，来判断我们下一个节点是否为空
       while (true) {
       		//如果为空，退出循环
           if (temp.next == null) {
               break;
           }
           //如果不为空，将指针后移
           temp = temp.next;
       }
       //退出循环后添加我们需要添加的元素
       temp.next = heroNode;
    }

遍历链表

  1. 为了程序的健壮性，我们需要判断程序是否为空，如果为空就直接返回
  2. 然后我们就需要从head.next开始遍历，知道temp.next为null
public void showHeroList(){

        //首先我们判断链表是否为空，如果为空，我们直接返回，
        if (head.next == null) {
            System.out.println("链表为空，请插入数据之后再行遍历");
            return;
        }
        // 因为我们还是那个上面判断过了，所以程序运行到这里说明我们的链表至少有一个为空
        // 所以我们直接将temp直接指向下一个节点，当然，指向头节点也是可以的

        HeroNode temp = head.next;
        while (true) {
            if (temp == null) {
                return;
            }
            System.out.println(temp);
            temp = temp.next;
        }

        /*HeroNode temp = head;
        while (true) {
            if (temp.next == null) {
                return;
            }
            System.out.println(temp.next);
            temp.next = temp.next.next;
        }*/

    }

按顺序插入

分析示意图：
在这里插入图片描述

  1. 首先我们要找到我们需要添加的元素的位置，通过遍历链表了来搞定
  2. 将temp.next新的节点 new.next = temp.next
  3. temp.next = new
public void addByOrder(HeroNode heroNode) {

        //由于我们的头节点不能动，所以如果我们想判断我们的下一个节点是否可以插入，我们需要再定义一个指针
        HeroNode temp = head;

        //用户来判断我们当前准备添加的英雄是否已经存在
        boolean flag = false;

        //首先我们需要遍历链表
        while (true) {
            //判断当前指针是否已经走到尾部，尾插法
            if (temp.next == null) {
                break;
            }
            //判断当前添加的英雄的编号是否已经存在
            if (temp.next.no == heroNode.no) {
                flag = true;
                break;
            }
            //判断当前节点的下一个节点的编号是否大于当前我们插入的元素的编号
            if (temp.next.no > heroNode.no) {
                break;
            }
            temp = temp.next;
        }
        //判断flag 的值
        if (flag) {
            System.out.printf("您想添加的英雄编号%d已经存在了，不能继续添加\n", heroNode.no);
        } else {
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

更新操作

分析：

  1. 因为我们跟新操作是通过no来更新，所以no不能改变
  2. 因为我们不是增加和删除，所以我们指针的也没有改变
  3. 通过no查询到指定的节点，然后将新的值覆盖到指定的节点的元素上
  4. 更新结束
public void updateList(HeroNode heroNode) {
        if (head.next == null) {
            System.out.println("链表为空，请填充链表后再进行修改");
            return;
        }
        HeroNode temp = head.next;
        boolean flag = false;
        while (true) {
            if (temp.no == heroNode.no) {
                flag = true;
                break;
            }
            if (temp == null) {
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.name = heroNode.name;
            temp.nickName = heroNode.nickName;
        } else {
            System.out.println("该链表中不存在你要修改的节点");
        }
    }

删除指定节点

在这里插入图片描述

public void deleteListByNo(int no) {
        //
        HeroNode temp = head;
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                System.out.println("没有找到您想要删除的节点");
                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 showHeroListByNo(int no) {
        //判断链表是否为空
        HeroNode temp = head;
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                System.out.println("没有找到您想要查询的节点");
                break;
            }
            if (temp.next.no == no) {
                System.out.println(temp.next);
                break;
            }
            temp = temp.next;
        }
    }

完整代码

package com.toulan.linkedlist;

/**
 * @author loltoulan
 * @version 1.0.0
 * @time 2020/4/2 22:23
 * @message
 */
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 hero6 = new HeroNode(6,"林冲","豹子头");

        SingleLinkedList linkedList = new SingleLinkedList();
        linkedList.addByOrder(hero1);
        linkedList.addByOrder(hero2);
        linkedList.addByOrder(hero6);
        linkedList.addByOrder(hero3);
        linkedList.addByOrder(hero3);

        linkedList.showHeroList();
        HeroNode hero67 = new HeroNode(6,"鲁智深","花和尚");
        System.out.println("=====================================================");
        linkedList.updateList(hero67);
        linkedList.showHeroList();
        System.out.println("=====================================================");
        linkedList.showHeroListByNo(3);
        System.out.println("=====================================================");
        linkedList.deleteListByNo(6);
        linkedList.showHeroList();
    }
}

//创建一个类，来管理我们的英雄的增删改查
class SingleLinkedList{

    //初始化一个头节点，因为，我们链表是通过头节点来进行数据的查询删除操作。
    private HeroNode head = new HeroNode(0, "", "");

    //首先，我们需要考虑，添加元素时，我们的指针如何移动，我们的数据如何插入
    //因为我们此方法，是一个简单的链表尾插法，
    //首先，我们需要将链表遍历到尾部，但是我们将链表遍历到尾部的核心是什么，核心是我们的next为null
    //找到该节点之后，我们将这个节点的next指向新的next

    /**
     * 尾插法，添加新的节点
     * @param heroNode
     */
   public void add(HeroNode heroNode) {

       // 首先，由于我们的头节点不能动，所以如果我们想判断我们的下一个节点是否为空，我们需要再定义一个指针
       HeroNode temp = head;

       // 我们通过让temp不断后移，来判断我们下一个节点是否为空
       while (true) {
           if (temp.next == null) {
               break;
           }
           temp = temp.next;
       }
       temp.next = heroNode;
    }

    /**
     * 遍历HeroList
     */
    public void showHeroList(){

        //首先我们判断链表是否为空，如果为空，我们直接返回，
        if (head.next == null) {
            System.out.println("链表为空，请插入数据之后再行遍历");
            return;
        }
        // 因为我们还是那个上面判断过了，所以程序运行到这里说明我们的链表至少有一个为空
        // 所以我们直接将temp直接指向下一个节点，当然，指向头节点也是可以的

        HeroNode temp = head.next;
        while (true) {
            if (temp == null) {
                return;
            }
            System.out.println(temp);
            temp = temp.next;
        }

        /*HeroNode temp = head;
        while (true) {
            if (temp.next == null) {
                return;
            }
            System.out.println(temp.next);
            temp.next = temp.next.next;
        }*/

    }


    /**
     * 按顺序插入
     * @param heroNode
     */
    public void addByOrder(HeroNode heroNode) {

        //由于我们的头节点不能动，所以如果我们想判断我们的下一个节点是否可以插入，我们需要再定义一个指针
        HeroNode temp = head;

        //用户来判断我们当前准备添加的英雄是否已经存在
        boolean flag = false;

        //首先我们需要遍历链表
        while (true) {
            //判断当前指针是否已经走到尾部，尾插法
            if (temp.next == null) {
                break;
            }
            //判断当前添加的英雄的编号是否已经存在
            if (temp.next.no == heroNode.no) {
                flag = true;
                break;
            }
            //判断当前节点的下一个节点的编号是否大于当前我们插入的元素的编号
            if (temp.next.no > heroNode.no) {
                break;
            }
            temp = temp.next;
        }
        //判断flag 的值
        if (flag) {
            System.out.printf("您想添加的英雄编号%d已经存在了，不能继续添加\n", heroNode.no);
        } else {
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    /**
     * 更新操作
     * @param heroNode
     */
    public void updateList(HeroNode heroNode) {
        if (head.next == null) {
            System.out.println("链表为空，请填充链表后再进行修改");
            return;
        }
        HeroNode temp = head.next;
        boolean flag = false;
        while (true) {
            if (temp.no == heroNode.no) {
                flag = true;
                break;
            }
            if (temp == null) {
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.name = heroNode.name;
            temp.nickName = heroNode.nickName;
        } else {
            System.out.println("该链表中不存在你要修改的节点");
        }
    }


    /**
     * 删除指定节点
     * @param no
     */
    public void deleteListByNo(int no) {
        //
        HeroNode temp = head;
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                System.out.println("没有找到您想要删除的节点");
                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);
        }
    }

    /**
     * 通过no查询节点数据
     * @param no
     */
    public void showHeroListByNo(int no) {
        //判断链表是否为空
        HeroNode temp = head;
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                System.out.println("没有找到您想要查询的节点");
                break;
            }
            if (temp.next.no == no) {
                System.out.println(temp.next);
                break;
            }
            temp = temp.next;
        }
    }
}

//创建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;
    }

    public HeroNode() {
    }


    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}
Jacobshash
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java算法实例-单链表操作
08-22
在这个"Java算法实例-单链表操作"中，我们将探讨如何在Java中实现单链表，包括其基本操作如插入、删除、遍历等。这些操作对于理解和解决各种算法问题至关重要，尤其对于学习和准备编程考试的学员来说，是非常实用的...
链表——基本算法
sy2453的博客
02-09 2031
1、反转链表 给出3个指针，一个cur，用于遍历链表中的每个节点，一个prev，用于保存cur指向的节点的上一个节点地址，还有一个after，用于保存cur指向的节点的下一个节点地址，链表操作遵循先连后断，即 ...
关于链表的算法总结
if_i_were_a的博客
09-11 437
1.头插法建立链表： 必须有一个终止条件，当输入为-1的时候表示输入的结束 头插法建立链表的函数是没有参数的传递的，在函数中用malloc来申请一个头结点 while的函数在最后一句要有scanf语句，表示等待下一个结点的值输入 头插法用代表头结点的链表，不用区别头结点是否为空，两条核心语句都可以搞定 头插法在建立链表的时候，输出的链表的数据域的值与输入值的顺序相反 在测试输出的时候需...
单链表基本运算算法——C/C++
有人_295的博客
08-22 3817
1、简介 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 2、格式 data域--存放结点值的数据域 next域--存放结点的直接后继的地址（位置）的指针域（链域） 链表通过每个结点的链域将线性表的n...
java实现单链表的简单划分
ma373的博客
12-11 581
给定一个链表和一个值X,将链表划分为两部分，使得划分侯晓宇x的节点在前，不小于x的节点在后。在这两部分中要保持原链表中的出现顺序。
链表相关算法汇总（详细）
泛泛之素
06-06 7980
链表基础知识 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(log
Java算法实例-双向链表操作
08-22
双向链表与单链表相比，其独特之处在于每个节点不仅包含指向下一个节点的指针，还包含指向前一个节点的指针，这使得在链表中的前进和后退操作变得相对高效。 双向链表的操作主要包括创建、插入、删除、遍历等。下面...
Java数据结构与算法-单链表 新浪，腾讯面试题详解
12-22
单链表常见的几个面试题 新浪，腾讯内部面试题目 题目分析 代码实现 测试用例 一，面试题目 统计链表中有效节点的个数（不含头结点）【新浪】 获取链表中倒数第K个元素【新浪】 单向链表的逆转【腾讯】 二，题目分析...
单链表（Linked-List）
最新发布
11-28
单链表是一种基础且重要的数据结构，它在计算机科学中被广泛使用，特别是在处理动态数据集合时。单链表由一系列节点组成，每个节点包含两个部分：数据元素和指向下一个节点的指针。这种数据结构与数组不同，因为它不...
Data_Structures:数据结构类2017-1 | 环评大学
05-14
"Data_Structures:数据结构类2017-1 | 环评大学"是一个课程或资料集合，旨在教授数据结构的基础知识以及它们在Java中的应用。 在这个课程或资源包中，你可能会学习到以下关键知识点： 1. **数组**：基础的数据结构...
java实现单链表及基本方法
silencebreak的博客
01-14 269
（用来做笔记，欢迎交流讨论！） 程序包含以下几个方法： 1.public void add(T data,int i) //在第i个位置处插入节点 2.public void remove(int i) //删除第i个位置处的节点 3.public void removeData(T data)//删除值为data的第一个节点 4.public void length()//如果没有size，求表长 5. public void searchIndex(int i)//按序号(第几个位置)...
单链表的常见基础算法（三）
柠檬超级酸
11-11 474
将带头结点的单链表A分解成两个带头结点的单链表A和B，使得A表中含有原表中序号为奇数的元素，B表中含有原表中序号为偶数的元素，且保持相对顺序不变 LinkList Dis_List(LinkList &A){ LinkList B=(LinkList)malloc(SizeOf(LNode)); LNode *p=A->next,*ra=A->next; A->...
[LeetCode][链表分区]partition-list java
qq_29295351的博客
05-22 116
1.题目： Given a linked list and a valuex, partition it such that all nodes less thanxcome before nodes greater than or equal tox. You should preserve the original relative order of the nodes in ea...
链表的基本算法。
ymk1507050118的博客
06-13 1457
今天我们来学习一波有关链表的基本算法。#pragma once #include<stdio.h> #include<stdlib.h> #include<assert.h> #include<Windows.h> // 值类型 typedef int DataType; typedef struct SListNode { Dat...
Java笔记：单链表
长不大的大灰狼
02-01 212
单链表 链表： 是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。 无头单向非循环链表。 无头双向链表。 不支持随机访问 任意位置插入删除时间复杂度为O（1） // 借助链表中的引用次序进行存储 //需要自己定义一个节点类进行存储 //节点类 class ListNode { public int data; public ListNo...
Java实现单链表
tanxinji的博客
05-24 3007
实现一个可以用任意对象为结点的单链表。嘻嘻，埋伏笔了。因为我是用内部类来实现结点的操作（Java-内部类），和用上一篇文章的Student类来作为本链表的结点的测试案例，另外还有一个如何删除对象结点，哈哈，也是上一篇的，为了防止可能看不懂，记得去看看上一篇的文章哦（Java继承原来就是这样）。创建的任意类对象的实例可以成为单链表的结点，这里也用到的就是一点点泛型的知识。另外提一下，如何解决我的那篇多态的文章的向下转型带来的不安全性就是可以用泛型解决的啦（Java多态到底教了我干啥?）。 一开始以为单链表只
常用算法整理：链表相关
言川的博客
04-24 3730
链表的考点链表很多时候都是考察基本功，因为链表题大部分都不是很复杂，主要是对指针的操作，当然也有难的。 简单的题目包括 删除/插入节点、翻转、去重、排序等，难度高一些的题目依然是这些，不过会有一些条件，比如多个链表或者局部操作。对链表题的两个技巧： - 如果不确定最终结果的head，比如对两个链表进行排序，那么新建一个 dummy node。 - 可以通过快慢指针的方式取中间节点入门题：第一题
【LeetCode-面试算法经典-Java实现】【086-Partition List（将单链表进行分区）】
https://github.com/Wang-Jun-Chao
08-05 2561
【086-Partition List（将单链表进行分区）】【LeetCode-面试算法经典-Java实现】【所有题目目录索引】原题　　Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x. 　　You
轻松搞定面试中的链表题目
热门推荐
计算机的艺术
04-21 6万+
版权所有，转载请注明出处，谢谢！ http://blog.csdn.net/walkinginthewind/article/details/7393134 链表是最基本的数据结构，面试官也常常用链表来考察面试者的基本能力，而且链表相关的操作相对而言比较简单，也适合考察写代码的能力。链表的操作也离不开指针，指针又很容易导致出错。综合多方面的原因，链表题目在面试中占据着很重要的地位。本文对链
Java版数据结构-线性表实现与应用解析
"该资源是一份关于数据结构的Java版线性表实现与应用的完整实验报告，旨在帮助学生理解并掌握线性表在顺序表和单链表两种形式下的实现，以及如何利用它们解决实际问题。实验内容包括实现线性表接口中定义的基本操作...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值